static bool orientationMediaFeatureEval(CSSValueImpl *value, RenderStyle *, KHTMLPart *part, MediaFeaturePrefix /*op*/) { if (value) { CSSPrimitiveValueImpl *pv = static_cast<CSSPrimitiveValueImpl *>(value); if (!value->isPrimitiveValue() || pv->primitiveType() != CSSPrimitiveValue::CSS_IDENT || (pv->getIdent() != CSS_VAL_PORTRAIT && pv->getIdent() != CSS_VAL_LANDSCAPE)) { return false; } KHTMLPart *rootPart = part; while (rootPart->parentPart()) { rootPart = rootPart->parentPart(); } DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl *>(rootPart->document().handle()); QPaintDevice *pd = doc->paintDevice(); bool printing = pd ? (pd->devType() == QInternal::Printer) : false; if (printing) { if (pd->width() > pd->height()) { return (pv->getIdent() == CSS_VAL_LANDSCAPE); } } else { if (part->view()->visibleWidth() > part->view()->visibleHeight()) { return (pv->getIdent() == CSS_VAL_LANDSCAPE); } } return (pv->getIdent() == CSS_VAL_PORTRAIT); } return false; }
void CSSStyleSelector::applySVGRule(int id, DOM::CSSValueImpl* value) { CSSPrimitiveValueImpl* primitiveValue = 0; if (value->isPrimitiveValue()) primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value); SVGRenderStyle* svgstyle = style->accessSVGStyle(); unsigned short valueType = value->cssValueType(); bool isInherit = parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT; bool isInitial = valueType == CSSPrimitiveValue::CSS_INITIAL || (!parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT); // What follows is a list that maps the CSS properties into their // corresponding front-end RenderStyle values. Shorthands(e.g. border, // background) occur in this list as well and are only hit when mapping // "inherit" or "initial" into front-end values. switch (id) { // ident only properties case CSS_PROP_ALIGNMENT_BASELINE: { HANDLE_INHERIT_AND_INITIAL(alignmentBaseline, AlignmentBaseline) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_AUTO: svgstyle->setAlignmentBaseline(AB_AUTO); break; case CSS_VAL_BASELINE: svgstyle->setAlignmentBaseline(AB_BASELINE); break; case CSS_VAL_BEFORE_EDGE: svgstyle->setAlignmentBaseline(AB_BEFORE_EDGE); break; case CSS_VAL_TEXT_BEFORE_EDGE: svgstyle->setAlignmentBaseline(AB_TEXT_BEFORE_EDGE); break; case CSS_VAL_MIDDLE: svgstyle->setAlignmentBaseline(AB_MIDDLE); break; case CSS_VAL_CENTRAL: svgstyle->setAlignmentBaseline(AB_CENTRAL); break; case CSS_VAL_AFTER_EDGE: svgstyle->setAlignmentBaseline(AB_AFTER_EDGE); break; case CSS_VAL_TEXT_AFTER_EDGE: svgstyle->setAlignmentBaseline(AB_TEXT_AFTER_EDGE); break; case CSS_VAL_IDEOGRAPHIC: svgstyle->setAlignmentBaseline(AB_IDEOGRAPHIC); break; case CSS_VAL_ALPHABETIC: svgstyle->setAlignmentBaseline(AB_ALPHABETIC); break; case CSS_VAL_HANGING: svgstyle->setAlignmentBaseline(AB_HANGING); break; case CSS_VAL_MATHEMATICAL: svgstyle->setAlignmentBaseline(AB_MATHEMATICAL); break; default: break; } break; } case CSS_PROP_BASELINE_SHIFT: { HANDLE_INHERIT_AND_INITIAL(baselineShift, BaselineShift); if (!primitiveValue) break; if (primitiveValue->getIdent()) { switch (primitiveValue->getIdent()) { case CSS_VAL_BASELINE: svgstyle->setBaselineShift(BS_BASELINE); break; case CSS_VAL_SUB: svgstyle->setBaselineShift(BS_SUB); break; case CSS_VAL_SUPER: svgstyle->setBaselineShift(BS_SUPER); break; default: break; } } else { svgstyle->setBaselineShift(BS_LENGTH); svgstyle->setBaselineShiftValue(primitiveValue); } break; } case CSS_PROP_KERNING: { if (isInherit) { HANDLE_INHERIT_COND(CSS_PROP_KERNING, kerning, Kerning) return; } else if (isInitial) { HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_KERNING, Kerning, Kerning) return; } svgstyle->setKerning(primitiveValue); break; } case CSS_PROP_POINTER_EVENTS: { HANDLE_INHERIT_AND_INITIAL(pointerEvents, PointerEvents) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_NONE: svgstyle->setPointerEvents(PE_NONE); break; case CSS_VAL_STROKE: svgstyle->setPointerEvents(PE_STROKE); break; case CSS_VAL_FILL: svgstyle->setPointerEvents(PE_FILL); break; case CSS_VAL_PAINTED: svgstyle->setPointerEvents(PE_PAINTED); break; case CSS_VAL_VISIBLE: svgstyle->setPointerEvents(PE_VISIBLE); break; case CSS_VAL_VISIBLESTROKE: svgstyle->setPointerEvents(PE_VISIBLE_STROKE); break; case CSS_VAL_VISIBLEFILL: svgstyle->setPointerEvents(PE_VISIBLE_FILL); break; case CSS_VAL_VISIBLEPAINTED: svgstyle->setPointerEvents(PE_VISIBLE_PAINTED); break; case CSS_VAL_ALL: svgstyle->setPointerEvents(PE_ALL); break; default: break; } break; } case CSS_PROP_DOMINANT_BASELINE: { HANDLE_INHERIT_AND_INITIAL(dominantBaseline, DominantBaseline) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_AUTO: svgstyle->setDominantBaseline(DB_AUTO); break; case CSS_VAL_USE_SCRIPT: svgstyle->setDominantBaseline(DB_USE_SCRIPT); break; case CSS_VAL_NO_CHANGE: svgstyle->setDominantBaseline(DB_NO_CHANGE); break; case CSS_VAL_RESET_SIZE: svgstyle->setDominantBaseline(DB_RESET_SIZE); break; case CSS_VAL_IDEOGRAPHIC: svgstyle->setDominantBaseline(DB_IDEOGRAPHIC); break; case CSS_VAL_ALPHABETIC: svgstyle->setDominantBaseline(DB_ALPHABETIC); break; case CSS_VAL_HANGING: svgstyle->setDominantBaseline(DB_HANGING); break; case CSS_VAL_MATHEMATICAL: svgstyle->setDominantBaseline(DB_MATHEMATICAL); break; case CSS_VAL_CENTRAL: svgstyle->setDominantBaseline(DB_CENTRAL); break; case CSS_VAL_MIDDLE: svgstyle->setDominantBaseline(DB_MIDDLE); break; case CSS_VAL_TEXT_AFTER_EDGE: svgstyle->setDominantBaseline(DB_TEXT_AFTER_EDGE); break; case CSS_VAL_TEXT_BEFORE_EDGE: svgstyle->setDominantBaseline(DB_TEXT_BEFORE_EDGE); break; default: break; } break; } case CSS_PROP_COLOR_INTERPOLATION: { HANDLE_INHERIT_AND_INITIAL(colorInterpolation, ColorInterpolation); svgstyle->setColorInterpolation(colorInterpolationForValue(primitiveValue)); break; } case CSS_PROP_COLOR_INTERPOLATION_FILTERS: { HANDLE_INHERIT_AND_INITIAL(colorInterpolationFilters, ColorInterpolationFilters) svgstyle->setColorInterpolationFilters(colorInterpolationForValue(primitiveValue)); break; } case CSS_PROP_COLOR_RENDERING: { HANDLE_INHERIT_AND_INITIAL(colorRendering, ColorRendering) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_AUTO: svgstyle->setColorRendering(CR_AUTO); break; case CSS_VAL_OPTIMIZESPEED: svgstyle->setColorRendering(CR_OPTIMIZESPEED); break; case CSS_VAL_OPTIMIZEQUALITY: svgstyle->setColorRendering(CR_OPTIMIZEQUALITY); break; default: break; } break; } case CSS_PROP_CLIP_RULE: { HANDLE_INHERIT_AND_INITIAL(clipRule, ClipRule) if (primitiveValue) svgstyle->setClipRule((primitiveValue->getIdent() == CSS_VAL_NONZERO) ? RULE_NONZERO : RULE_EVENODD); break; } case CSS_PROP_FILL_RULE: { HANDLE_INHERIT_AND_INITIAL(fillRule, FillRule) if (primitiveValue) svgstyle->setFillRule((primitiveValue->getIdent() == CSS_VAL_NONZERO) ? RULE_NONZERO : RULE_EVENODD); break; } case CSS_PROP_STROKE_LINEJOIN: { HANDLE_INHERIT_AND_INITIAL(joinStyle, JoinStyle) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_MITER: svgstyle->setJoinStyle(khtml::MiterJoin); break; case CSS_VAL_ROUND: svgstyle->setJoinStyle(khtml::RoundJoin); break; case CSS_VAL_BEVEL: svgstyle->setJoinStyle(khtml::BevelJoin); break; default: break; } break; } case CSS_PROP_IMAGE_RENDERING: { HANDLE_INHERIT_AND_INITIAL(imageRendering, ImageRendering) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_AUTO: svgstyle->setImageRendering(IR_AUTO); break; case CSS_VAL_OPTIMIZESPEED: svgstyle->setImageRendering(IR_OPTIMIZESPEED); break; case CSS_VAL_OPTIMIZEQUALITY: svgstyle->setImageRendering(IR_OPTIMIZEQUALITY); break; default: break; } break; } case CSS_PROP_SHAPE_RENDERING: { HANDLE_INHERIT_AND_INITIAL(shapeRendering, ShapeRendering) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_AUTO: svgstyle->setShapeRendering(SR_AUTO); break; case CSS_VAL_OPTIMIZESPEED: svgstyle->setShapeRendering(SR_OPTIMIZESPEED); break; case CSS_VAL_CRISPEDGES: svgstyle->setShapeRendering(SR_CRISPEDGES); break; case CSS_VAL_GEOMETRICPRECISION: svgstyle->setShapeRendering(SR_GEOMETRICPRECISION); break; default: break; } break; } case CSS_PROP_TEXT_RENDERING: { HANDLE_INHERIT_AND_INITIAL(textRendering, TextRendering) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_AUTO: svgstyle->setTextRendering(TR_AUTO); break; case CSS_VAL_OPTIMIZESPEED: svgstyle->setTextRendering(TR_OPTIMIZESPEED); break; case CSS_VAL_OPTIMIZELEGIBILITY: svgstyle->setTextRendering(TR_OPTIMIZELEGIBILITY); break; case CSS_VAL_GEOMETRICPRECISION: svgstyle->setTextRendering(TR_GEOMETRICPRECISION); break; default: break; } break; } // end of ident only properties case CSS_PROP_FILL: { HANDLE_INHERIT_AND_INITIAL(fillPaint, FillPaint) if (SVGPaintImpl* paint = toPaint(value)) svgstyle->setFillPaint(paint); break; } case CSS_PROP_STROKE: { HANDLE_INHERIT_AND_INITIAL(strokePaint, StrokePaint) if (SVGPaintImpl* paint = toPaint(value)) svgstyle->setStrokePaint(paint); break; } case CSS_PROP_STROKE_WIDTH: { HANDLE_INHERIT_AND_INITIAL(strokeWidth, StrokeWidth) if (!primitiveValue) return; svgstyle->setStrokeWidth(primitiveValue); break; } case CSS_PROP_STROKE_DASHARRAY: { HANDLE_INHERIT_AND_INITIAL(strokeDashArray, StrokeDashArray) if (!primitiveValue && value && value->isValueList()) { CSSValueListImpl* dashes = static_cast<CSSValueListImpl*>(value); svgstyle->setStrokeDashArray(dashes); } break; } case CSS_PROP_STROKE_DASHOFFSET: { HANDLE_INHERIT_AND_INITIAL(strokeDashOffset, StrokeDashOffset) if (!primitiveValue) return; svgstyle->setStrokeDashOffset(primitiveValue); break; } case CSS_PROP_FILL_OPACITY: { HANDLE_INHERIT_AND_INITIAL(fillOpacity, FillOpacity) if (!primitiveValue) return; float f = 0.0f; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_PERCENTAGE) f = primitiveValue->floatValue() / 100.0f; else if (type == CSSPrimitiveValue::CSS_NUMBER) f = primitiveValue->floatValue(); else return; svgstyle->setFillOpacity(f); break; } case CSS_PROP_STROKE_OPACITY: { HANDLE_INHERIT_AND_INITIAL(strokeOpacity, StrokeOpacity) if (!primitiveValue) return; float f = 0.0f; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_PERCENTAGE) f = primitiveValue->floatValue() / 100.0f; else if (type == CSSPrimitiveValue::CSS_NUMBER) f = primitiveValue->floatValue(); else return; svgstyle->setStrokeOpacity(f); break; } case CSS_PROP_STOP_OPACITY: { HANDLE_INHERIT_AND_INITIAL(stopOpacity, StopOpacity) if (!primitiveValue) return; float f = 0.0f; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_PERCENTAGE) f = primitiveValue->floatValue() / 100.0f; else if (type == CSSPrimitiveValue::CSS_NUMBER) f = primitiveValue->floatValue(); else return; svgstyle->setStopOpacity(f); break; } case CSS_PROP_MARKER_START: { HANDLE_INHERIT_AND_INITIAL(startMarker, StartMarker) if (!primitiveValue) return; String s; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_URI) s = primitiveValue->getStringValue(); else return; svgstyle->setStartMarker(s); break; } case CSS_PROP_MARKER_MID: { HANDLE_INHERIT_AND_INITIAL(midMarker, MidMarker) if (!primitiveValue) return; String s; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_URI) s = primitiveValue->getStringValue(); else return; svgstyle->setMidMarker(s); break; } case CSS_PROP_MARKER_END: { HANDLE_INHERIT_AND_INITIAL(endMarker, EndMarker) if (!primitiveValue) return; String s; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_URI) s = primitiveValue->getStringValue(); else return; svgstyle->setEndMarker(s); break; } case CSS_PROP_STROKE_LINECAP: { HANDLE_INHERIT_AND_INITIAL(capStyle, CapStyle) if (!primitiveValue) break; switch (primitiveValue->getIdent()) { case CSS_VAL_BUTT: svgstyle->setCapStyle(ButtCap); break; case CSS_VAL_ROUND: svgstyle->setCapStyle(RoundCap); break; case CSS_VAL_SQUARE: svgstyle->setCapStyle(SquareCap); break; default: break; } break; } case CSS_PROP_STROKE_MITERLIMIT: { HANDLE_INHERIT_AND_INITIAL(strokeMiterLimit, StrokeMiterLimit) if (!primitiveValue) return; float f = 0.0f; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_NUMBER) f = primitiveValue->floatValue(); else return; svgstyle->setStrokeMiterLimit(f); break; } case CSS_PROP_FILTER: { HANDLE_INHERIT_AND_INITIAL(filter, Filter) if (!primitiveValue) return; String s; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_URI) s = primitiveValue->getStringValue(); else return; svgstyle->setFilter(s); break; } case CSS_PROP_MASK: { HANDLE_INHERIT_AND_INITIAL(maskElement, MaskElement) if (!primitiveValue) return; String s; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_URI) s = primitiveValue->getStringValue(); else return; svgstyle->setMaskElement(s); break; } case CSS_PROP_CLIP_PATH: { HANDLE_INHERIT_AND_INITIAL(clipPath, ClipPath) if (!primitiveValue) return; String s; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_URI) s = primitiveValue->getStringValue(); else return; svgstyle->setClipPath(s); break; } case CSS_PROP_TEXT_ANCHOR: { HANDLE_INHERIT_AND_INITIAL(textAnchor, TextAnchor) if (primitiveValue) { switch (primitiveValue->getIdent()) { case CSS_VAL_START: svgstyle->setTextAnchor(TA_START); break; case CSS_VAL_MIDDLE: svgstyle->setTextAnchor(TA_MIDDLE); break; case CSS_VAL_END: svgstyle->setTextAnchor(TA_END); break; } } break; } case CSS_PROP_WRITING_MODE: { HANDLE_INHERIT_AND_INITIAL(writingMode, WritingMode) if (!primitiveValue) return; switch (primitiveValue->getIdent()) { case CSS_VAL_LR_TB: svgstyle->setWritingMode(WM_LRTB); break; case CSS_VAL_LR: svgstyle->setWritingMode(WM_LR); break; case CSS_VAL_RL_TB: svgstyle->setWritingMode(WM_RLTB); break; case CSS_VAL_RL: svgstyle->setWritingMode(WM_RL); break; case CSS_VAL_TB_RL: svgstyle->setWritingMode(WM_TBRL); break; case CSS_VAL_TB: svgstyle->setWritingMode(WM_TB); break; default: break; } break; } case CSS_PROP_STOP_COLOR: { HANDLE_INHERIT_AND_INITIAL(stopColor, StopColor); SVGColorImpl* c = toColor(value); if (!c) break; QColor col; if (c->colorType() == SVGColorImpl::SVG_COLORTYPE_CURRENTCOLOR) col = style->color(); else col = c->color(); svgstyle->setStopColor(col); break; } case CSS_PROP_LIGHTING_COLOR: { HANDLE_INHERIT_AND_INITIAL(lightingColor, LightingColor); SVGColorImpl* c = toColor(value); if (!c) break; QColor col; if (c->colorType() == SVGColorImpl::SVG_COLORTYPE_CURRENTCOLOR) col = style->color(); else col = c->color(); svgstyle->setLightingColor(col); break; } case CSS_PROP_FLOOD_OPACITY: { HANDLE_INHERIT_AND_INITIAL(floodOpacity, FloodOpacity) if (!primitiveValue) return; float f = 0.0f; int type = primitiveValue->primitiveType(); if (type == CSSPrimitiveValue::CSS_PERCENTAGE) f = primitiveValue->floatValue() / 100.0f; else if (type == CSSPrimitiveValue::CSS_NUMBER) f = primitiveValue->floatValue(); else return; svgstyle->setFloodOpacity(f); break; } case CSS_PROP_FLOOD_COLOR: { QColor col; if (isInitial) col = SVGRenderStyle::initialFloodColor(); else { SVGColorImpl* c = toColor(value); if (!c) break; if (c->colorType() == SVGColorImpl::SVG_COLORTYPE_CURRENTCOLOR) col = style->color(); else col = c->color(); } svgstyle->setFloodColor(col); break; } case CSS_PROP_GLYPH_ORIENTATION_HORIZONTAL: { HANDLE_INHERIT_AND_INITIAL(glyphOrientationHorizontal, GlyphOrientationHorizontal) if (!primitiveValue) return; if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_DEG) { int orientation = angleToGlyphOrientation(primitiveValue->floatValue()); ASSERT(orientation != -1); svgstyle->setGlyphOrientationHorizontal((EGlyphOrientation) orientation); } break; } case CSS_PROP_GLYPH_ORIENTATION_VERTICAL: { HANDLE_INHERIT_AND_INITIAL(glyphOrientationVertical, GlyphOrientationVertical) if (!primitiveValue) return; if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_DEG) { int orientation = angleToGlyphOrientation(primitiveValue->floatValue()); ASSERT(orientation != -1); svgstyle->setGlyphOrientationVertical((EGlyphOrientation) orientation); } else if (primitiveValue->getIdent() == CSS_VAL_AUTO) svgstyle->setGlyphOrientationVertical(GO_AUTO); break; } case CSS_PROP_ENABLE_BACKGROUND: // Silently ignoring this property for now // http://bugs.webkit.org/show_bug.cgi?id=6022 break; default: // If you crash here, it's because you added a css property and are not handling it // in either this switch statement or the one in CSSStyleSelector::applyProperty kWarning() << "unimplemented property" << id << getPropertyName(id).string(); return; }
void CSSFontSelector::addFontFaceRule(const CSSFontFaceRuleImpl *fontFaceRule) { // Obtain the font-family property and the src property. Both must be defined. const CSSStyleDeclarationImpl *style = fontFaceRule->style(); CSSValueImpl *fontFamily = style->getPropertyCSSValue(CSS_PROP_FONT_FAMILY); CSSValueImpl *src = style->getPropertyCSSValue(CSS_PROP_SRC); CSSValueImpl *unicodeRange = style->getPropertyCSSValue(CSS_PROP_UNICODE_RANGE); if (!fontFamily || !src || !fontFamily->isValueList() || !src->isValueList() || (unicodeRange && !unicodeRange->isValueList())) { return; } CSSValueListImpl *familyList = static_cast<CSSValueListImpl *>(fontFamily); if (!familyList->length()) { return; } CSSValueListImpl *srcList = static_cast<CSSValueListImpl *>(src); if (!srcList->length()) { return; } // CSSValueListImpl* rangeList = static_cast<CSSValueListImpl*>(unicodeRange); unsigned traitsMask = 0; /* if (CSSValueImpl* fontStyle = style->getPropertyCSSValue(CSS_PROP_FONT_STYLE)) { if (fontStyle->isPrimitiveValue()) { CSSValueListImpl* list = new CSSValueListImpl(CSSValueListImpl::Comma); list->append(fontStyle); fontStyle = list; } else if (!fontStyle->isValueList()) return; CSSValueListImpl* styleList = static_cast<CSSValueListImpl*>(fontStyle); unsigned numStyles = styleList->length(); if (!numStyles) return; for (unsigned i = 0; i < numStyles; ++i) { switch (static_cast<CSSPrimitiveValueImpl*>(styleList[i])->getIdent()) { case CSS_ALL: traitsMask |= FontStyleMask; break; case CSS_NORMAL: traitsMask |= FontStyleNormalMask; break; case CSS_ITALIC: case CSS_OBLIQUE: traitsMask |= FontStyleItalicMask; break; default: break; } } } else traitsMask |= FontStyleMask; if (CSSValueImpl* fontWeight = style->getPropertyCSSValue(CSS_PROP_FONT_WEIGHT)) { if (fontWeight->isPrimitiveValue()) { CSSValueListImpl* list = new CSSValueListImpl(CSSValueListImpl::Comma); list->append(fontWeight); fontWeight = list; } else if (!fontWeight->isValueList()) return; CSSValueListImpl* weightList = static_cast<CSSValueListImpl*>(fontWeight); unsigned numWeights = weightList->length(); if (!numWeights) return; for (unsigned i = 0; i < numWeights; ++i) { switch (static_cast<CSSPrimitiveValueImpl*>(weightList[i])->getIdent()) { case CSS_VAL_ALL: traitsMask |= FontWeightMask; break; case CSS_VAL_BOLDER: case CSS_VAL_BOLD: case CSS_VAL_700: traitsMask |= FontWeight700Mask; break; case CSS_VAL_NORMAL: case CSS_VAL_400: traitsMask |= FontWeight400Mask; break; case CSS_VAL_900: traitsMask |= FontWeight900Mask; break; case CSS_VAL_800: traitsMask |= FontWeight800Mask; break; case CSS_VAL_600: traitsMask |= FontWeight600Mask; break; case CSS_VAL_500: traitsMask |= FontWeight500Mask; break; case CSS_VAL_300: traitsMask |= FontWeight300Mask; break; case CSS_VAL_LIGHTER: case CSS_VAL_200: traitsMask |= FontWeight200Mask; break; case CSS_VAL_100: traitsMask |= FontWeight100Mask; break; default: break; } } } else traitsMask |= FontWeightMask; if (CSSValueImpl* fontVariant = style->getPropertyCSSValue(CSS_PROP_FONT_VARIANT)) { if (fontVariant->isPrimitiveValue()) { CSSValueListImpl* list = new CSSValueListImpl(CSSValueListImpl::Comma); list->append(fontVariant); fontVariant = list; } else if (!fontVariant->isValueList()) return; CSSValueListImpl* variantList = static_cast<CSSValueListImpl*>(fontVariant); unsigned numVariants = variantList->length(); if (!numVariants) return; for (unsigned i = 0; i < numVariants; ++i) { switch (static_cast<CSSPrimitiveValueImpl*>(variantList[i])->getIdent()) { case CSS_VAL_ALL: traitsMask |= FontVariantMask; break; case CSS_VAL_NORMAL: traitsMask |= FontVariantNormalMask; break; case CSS_VAL_SMALL_CAPS: traitsMask |= FontVariantSmallCapsMask; break; default: break; } } } else traitsMask |= FontVariantNormalMask; */ // Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace. CSSFontFace *fontFace = 0; const int srcLength = srcList->length(); #if 0 // ENABLE(SVG_FONTS) bool foundSVGFont = false; #endif for (int i = 0; i < srcLength; i++) { // An item in the list either specifies a string (local font name) or a URL (remote font to download). CSSFontFaceSrcValueImpl *item = static_cast<CSSFontFaceSrcValueImpl *>(srcList->item(i)); CSSFontFaceSource *source = 0; #if 0 // ENABLE(SVG_FONTS) foundSVGFont = item->isSVGFontFaceSrc() || item->svgFontFaceElement(); #endif if (!item->isLocal()) { if (item->isSupportedFormat() && m_document) { source = new CSSFontFaceSource(item->resource(), true /*distant*/); #if 0 // ENABLE(SVG_FONTS) if (foundSVGFont) { cachedFont->setSVGFont(true); } #endif } } else { source = new CSSFontFaceSource(item->resource()); } if (source) { #if 0 // ENABLE(SVG_FONTS) source->setSVGFontFaceElement(item->svgFontFaceElement()); #endif if (!fontFace) { fontFace = new CSSFontFace(static_cast<FontTraitsMask>(traitsMask), this); } fontFace->addSource(source); } } if (!fontFace || !fontFace->isValid()) { delete fontFace; return; } /* if (rangeList) { unsigned numRanges = rangeList->length(); for (unsigned i = 0; i < numRanges; i++) { CSSUnicodeRangeValueImpl* range = static_cast<CSSUnicodeRangeValueImpl*>(rangeList->item(i)); fontFace->addRange(range->from(), range->to()); } } */ // Hash under every single family name. int familyLength = familyList->length(); for (int i = 0; i < familyLength; i++) { CSSPrimitiveValueImpl *item = static_cast<CSSPrimitiveValueImpl *>(familyList->item(i)); DOMString familyName; if (item->primitiveType() == CSSPrimitiveValue::CSS_STRING) { familyName = DOMString(static_cast<FontFamilyValueImpl *>(item)->fontName()); } else if (item->primitiveType() == CSSPrimitiveValue::CSS_IDENT) { // We need to use the raw text for all the generic family types, since @font-face is a way of actually // defining what font to use for those types. switch (item->getIdent()) { case CSS_VAL_SERIF: familyName = "-khtml-serif"; break; case CSS_VAL_SANS_SERIF: familyName = "-khtml-sans-serif"; break; case CSS_VAL_CURSIVE: familyName = "-khtml-cursive"; break; case CSS_VAL_FANTASY: familyName = "-khtml-fantasy"; break; case CSS_VAL_MONOSPACE: familyName = "-khtml-monospace"; break; default: break; } } if (familyName.isEmpty()) { continue; } fontFace->addFamilyName(familyName); m_locallyInstalledFontFaces.insertMulti(familyName.lower(), fontFace); fontFace->ref(); #if 0 // ENABLE(SVG_FONTS) // SVG allows several <font> elements with the same font-family, differing only // in ie. font-variant. Be sure to pick up the right one - in getFontData below. if (foundSVGFont && (traitsMask & FontVariantSmallCapsMask)) { familyName += "-webkit-svg-small-caps"; } #endif /* Vector<RefPtr<CSSFontFace> >* familyFontFaces = m_fontFaces.get(familyName); if (!familyFontFaces) { familyFontFaces = new Vector<RefPtr<CSSFontFace> >; m_fontFaces.set(familyName, familyFontFaces); ASSERT(!m_locallyInstalledFontFaces.contains(familyName)); Vector<RefPtr<CSSFontFace> >* familyLocallyInstalledFaces; Vector<unsigned> locallyInstalledFontsTraitsMasks; fontCache()->getTraitsInFamily(familyName, locallyInstalledFontsTraitsMasks); unsigned numLocallyInstalledFaces = locallyInstalledFontsTraitsMasks.size(); if (numLocallyInstalledFaces) { familyLocallyInstalledFaces = new Vector<RefPtr<CSSFontFace> >; m_locallyInstalledFontFaces.set(familyName, familyLocallyInstalledFaces); for (unsigned i = 0; i < numLocallyInstalledFaces; ++i) { RefPtr<CSSFontFace> locallyInstalledFontFace = CSSFontFace::create(static_cast<FontTraitsMask>(locallyInstalledFontsTraitsMasks[i])); locallyInstalledFontFace->addSource(new CSSFontFaceSource(familyName)); ASSERT(locallyInstalledFontFace->isValid()); familyLocallyInstalledFaces->append(locallyInstalledFontFace); } } } familyFontFaces->append(fontFace); */ } // Should be impossible, but in case empty/invalid family name makes it through... if (fontFace->refCount() < 1) { delete fontFace; } }