src/css/SVGCSSStyleSelector.cpp

0001 /*
0002     Copyright (C) 2005 Apple Computer, Inc.
0003     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
0004     Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
0005     Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
0006     Copyright (C) 2009 Maksim Orlovich <maksim@kde.org>
0007
0008     Based on khtml css code by:
0009     Copyright (C) 1999-2003 Lars Knoll <knoll@kde.org>
0010     Copyright (C) 2003 Apple Computer, Inc.
0011     Copyright (C) 2004 Allan Sandfeld Jensen <kde@carewolf.com>
0012     Copyright (C) 2004 Germain Garand <germain@ebooksfrance.org>
0013
0014     This file is part of the KDE project
0015
0016     This library is free software; you can redistribute it and/or
0017     modify it under the terms of the GNU Library General Public
0018     License as published by the Free Software Foundation; either
0019     version 2 of the License, or (at your option) any later version.
0020
0021     This library is distributed in the hope that it will be useful,
0022     but WITHOUT ANY WARRANTY; without even the implied warranty of
0023     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0024     Library General Public License for more details.
0025
0026     You should have received a copy of the GNU Library General Public License
0027     along with this library; see the file COPYING.LIB.  If not, write to
0028     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
0029     Boston, MA 02110-1301, USA.
0030 */
0031
0032 #include "cssstyleselector.h"
0033 #include "css_valueimpl.h"
0034 #include "css_svgvalueimpl.h"
0035 #include "cssvalues.h"
0036
0037 #include "SVGNames.h"
0038 #include "SVGRenderStyle.h"
0039 #include "SVGRenderStyleDefs.h"
0040 #include "SVGStyledElement.h"
0041
0042 #include <wtf/MathExtras.h>
0043
0044 #define HANDLE_INHERIT(prop, Prop) \
0045     if (isInherit) \
0046     {\
0047         svgstyle->set##Prop(parentStyle->svgStyle()->prop());\
0048         return;\
0049     }
0050
0051 #define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
0052     HANDLE_INHERIT(prop, Prop) \
0053     else if (isInitial) \
0054         svgstyle->set##Prop(SVGRenderStyle::initial##Prop());
0055
0056 #define HANDLE_INHERIT_COND(propID, prop, Prop) \
0057     if (id == propID) \
0058     {\
0059         svgstyle->set##Prop(parentStyle->svgStyle()->prop());\
0060         return;\
0061     }
0062
0063 #define HANDLE_INITIAL_COND(propID, Prop) \
0064     if (id == propID) \
0065     {\
0066         svgstyle->set##Prop(SVGRenderStyle::initial##Prop());\
0067         return;\
0068     }
0069
0070 #define HANDLE_INITIAL_COND_WITH_VALUE(propID, Prop, Value) \
0071     if (id == propID) { \
0072         svgstyle->set##Prop(SVGRenderStyle::initial##Value()); \
0073         return; \
0074     }
0075
0076 namespace khtml
0077 {
0078
0079 using namespace DOM;
0080 using namespace WebCore;
0081
0082 static SVGPaintImpl *toPaint(CSSValueImpl *val)
0083 {
0084     if (val->cssValueType() != DOM::CSSValue::CSS_SVG_VALUE) {
0085         return nullptr;
0086     }
0087     SVGCSSValueImpl *svgVal = static_cast<SVGCSSValueImpl *>(val);
0088     if (svgVal->isSVGPaint()) {
0089         return static_cast<SVGPaintImpl *>(svgVal);
0090     } else {
0091         return nullptr;
0092     }
0093 }
0094
0095 static SVGColorImpl *toColor(CSSValueImpl *val)
0096 {
0097     if (val->cssValueType() != DOM::CSSValue::CSS_SVG_VALUE) {
0098         return nullptr;
0099     }
0100     SVGCSSValueImpl *svgVal = static_cast<SVGCSSValueImpl *>(val);
0101     if (svgVal->isSVGColor()) {
0102         return static_cast<SVGColorImpl *>(svgVal);
0103     } else {
0104         return nullptr;
0105     }
0106 }
0107
0108 static float roundToNearestGlyphOrientationAngle(float angle)
0109 {
0110     angle = fabsf(fmodf(angle, 360.0f));
0111
0112     if (angle <= 45.0f || angle > 315.0f) {
0113         return 0.0f;
0114     } else if (angle > 45.0f && angle <= 135.0f) {
0115         return 90.0f;
0116     } else if (angle > 135.0f && angle <= 225.0f) {
0117         return 180.0f;
0118     }
0119
0120     return 270.0f;
0121 }
0122
0123 static int angleToGlyphOrientation(float angle)
0124 {
0125     angle = roundToNearestGlyphOrientationAngle(angle);
0126
0127     if (angle == 0.0f) {
0128         return GO_0DEG;
0129     } else if (angle == 90.0f) {
0130         return GO_90DEG;
0131     } else if (angle == 180.0f) {
0132         return GO_180DEG;
0133     } else if (angle == 270.0f) {
0134         return GO_270DEG;
0135     }
0136
0137     return -1;
0138 }
0139
0140 static EColorInterpolation colorInterpolationForValue(DOM::CSSPrimitiveValueImpl *primitiveValue)
0141 {
0142     if (!primitiveValue) {
0143         return CI_AUTO;
0144     }
0145
0146     switch (primitiveValue->getIdent()) {
0147     case CSS_VAL_SRGB:
0148         return CI_SRGB;
0149     case CSS_VAL_LINEARRGB:
0150         return CI_LINEARRGB;
0151     case CSS_VAL_AUTO:
0152     default:
0153         return CI_AUTO;
0154     }
0155 }
0156
0157 void CSSStyleSelector::applySVGRule(int id, DOM::CSSValueImpl *value)
0158 {
0159     CSSPrimitiveValueImpl *primitiveValue = nullptr;
0160     if (value->isPrimitiveValue()) {
0161         primitiveValue = static_cast<CSSPrimitiveValueImpl *>(value);
0162     }
0163
0164     SVGRenderStyle *svgstyle = style->accessSVGStyle();
0165     unsigned short valueType = value->cssValueType();
0166
0167     bool isInherit = parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT;
0168     bool isInitial = valueType == CSSPrimitiveValue::CSS_INITIAL || (!parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT);
0169
0170     // What follows is a list that maps the CSS properties into their
0171     // corresponding front-end RenderStyle values. Shorthands(e.g. border,
0172     // background) occur in this list as well and are only hit when mapping
0173     // "inherit" or "initial" into front-end values.
0174     switch (id) {
0175     // ident only properties
0176     case CSS_PROP_ALIGNMENT_BASELINE: {
0177         HANDLE_INHERIT_AND_INITIAL(alignmentBaseline, AlignmentBaseline)
0178         if (!primitiveValue) {
0179             break;
0180         }
0181
0182         switch (primitiveValue->getIdent()) {
0183         case CSS_VAL_AUTO:
0184             svgstyle->setAlignmentBaseline(AB_AUTO);
0185             break;
0186         case CSS_VAL_BASELINE:
0187             svgstyle->setAlignmentBaseline(AB_BASELINE);
0188             break;
0189         case CSS_VAL_BEFORE_EDGE:
0190             svgstyle->setAlignmentBaseline(AB_BEFORE_EDGE);
0191             break;
0192         case CSS_VAL_TEXT_BEFORE_EDGE:
0193             svgstyle->setAlignmentBaseline(AB_TEXT_BEFORE_EDGE);
0194             break;
0195         case CSS_VAL_MIDDLE:
0196             svgstyle->setAlignmentBaseline(AB_MIDDLE);
0197             break;
0198         case CSS_VAL_CENTRAL:
0199             svgstyle->setAlignmentBaseline(AB_CENTRAL);
0200             break;
0201         case CSS_VAL_AFTER_EDGE:
0202             svgstyle->setAlignmentBaseline(AB_AFTER_EDGE);
0203             break;
0204         case CSS_VAL_TEXT_AFTER_EDGE:
0205             svgstyle->setAlignmentBaseline(AB_TEXT_AFTER_EDGE);
0206             break;
0207         case CSS_VAL_IDEOGRAPHIC:
0208             svgstyle->setAlignmentBaseline(AB_IDEOGRAPHIC);
0209             break;
0210         case CSS_VAL_ALPHABETIC:
0211             svgstyle->setAlignmentBaseline(AB_ALPHABETIC);
0212             break;
0213         case CSS_VAL_HANGING:
0214             svgstyle->setAlignmentBaseline(AB_HANGING);
0215             break;
0216         case CSS_VAL_MATHEMATICAL:
0217             svgstyle->setAlignmentBaseline(AB_MATHEMATICAL);
0218             break;
0219         default:
0220             break;
0221         }
0222         break;
0223     }
0224     case CSS_PROP_BASELINE_SHIFT: {
0225         HANDLE_INHERIT_AND_INITIAL(baselineShift, BaselineShift);
0226         if (!primitiveValue) {
0227             break;
0228         }
0229
0230         if (primitiveValue->getIdent()) {
0231             switch (primitiveValue->getIdent()) {
0232             case CSS_VAL_BASELINE:
0233                 svgstyle->setBaselineShift(BS_BASELINE);
0234                 break;
0235             case CSS_VAL_SUB:
0236                 svgstyle->setBaselineShift(BS_SUB);
0237                 break;
0238             case CSS_VAL_SUPER:
0239                 svgstyle->setBaselineShift(BS_SUPER);
0240                 break;
0241             default:
0242                 break;
0243             }
0244         } else {
0245             svgstyle->setBaselineShift(BS_LENGTH);
0246             svgstyle->setBaselineShiftValue(primitiveValue);
0247         }
0248
0249         break;
0250     }
0251     case CSS_PROP_KERNING: {
0252         if (isInherit) {
0253             HANDLE_INHERIT_COND(CSS_PROP_KERNING, kerning, Kerning)
0254             return;
0255         } else if (isInitial) {
0256             HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_KERNING, Kerning, Kerning)
0257             return;
0258         }
0259         svgstyle->setKerning(primitiveValue);
0260         break;
0261     }
0262     case CSS_PROP_POINTER_EVENTS: {
0263         HANDLE_INHERIT_AND_INITIAL(pointerEvents, PointerEvents)
0264         if (!primitiveValue) {
0265             break;
0266         }
0267
0268         switch (primitiveValue->getIdent()) {
0269         case CSS_VAL_NONE:
0270             svgstyle->setPointerEvents(PE_NONE);
0271             break;
0272         case CSS_VAL_STROKE:
0273             svgstyle->setPointerEvents(PE_STROKE);
0274             break;
0275         case CSS_VAL_FILL:
0276             svgstyle->setPointerEvents(PE_FILL);
0277             break;
0278         case CSS_VAL_PAINTED:
0279             svgstyle->setPointerEvents(PE_PAINTED);
0280             break;
0281         case CSS_VAL_VISIBLE:
0282             svgstyle->setPointerEvents(PE_VISIBLE);
0283             break;
0284         case CSS_VAL_VISIBLESTROKE:
0285             svgstyle->setPointerEvents(PE_VISIBLE_STROKE);
0286             break;
0287         case CSS_VAL_VISIBLEFILL:
0288             svgstyle->setPointerEvents(PE_VISIBLE_FILL);
0289             break;
0290         case CSS_VAL_VISIBLEPAINTED:
0291             svgstyle->setPointerEvents(PE_VISIBLE_PAINTED);
0292             break;
0293         case CSS_VAL_ALL:
0294             svgstyle->setPointerEvents(PE_ALL);
0295             break;
0296         default:
0297             break;
0298         }
0299         break;
0300     }
0301     case CSS_PROP_DOMINANT_BASELINE: {
0302         HANDLE_INHERIT_AND_INITIAL(dominantBaseline, DominantBaseline)
0303
0304         if (!primitiveValue) {
0305             break;
0306         }
0307
0308         switch (primitiveValue->getIdent()) {
0309         case CSS_VAL_AUTO:
0310             svgstyle->setDominantBaseline(DB_AUTO);
0311             break;
0312         case CSS_VAL_USE_SCRIPT:
0313             svgstyle->setDominantBaseline(DB_USE_SCRIPT);
0314             break;
0315         case CSS_VAL_NO_CHANGE:
0316             svgstyle->setDominantBaseline(DB_NO_CHANGE);
0317             break;
0318         case CSS_VAL_RESET_SIZE:
0319             svgstyle->setDominantBaseline(DB_RESET_SIZE);
0320             break;
0321         case CSS_VAL_IDEOGRAPHIC:
0322             svgstyle->setDominantBaseline(DB_IDEOGRAPHIC);
0323             break;
0324         case CSS_VAL_ALPHABETIC:
0325             svgstyle->setDominantBaseline(DB_ALPHABETIC);
0326             break;
0327         case CSS_VAL_HANGING:
0328             svgstyle->setDominantBaseline(DB_HANGING);
0329             break;
0330         case CSS_VAL_MATHEMATICAL:
0331             svgstyle->setDominantBaseline(DB_MATHEMATICAL);
0332             break;
0333         case CSS_VAL_CENTRAL:
0334             svgstyle->setDominantBaseline(DB_CENTRAL);
0335             break;
0336         case CSS_VAL_MIDDLE:
0337             svgstyle->setDominantBaseline(DB_MIDDLE);
0338             break;
0339         case CSS_VAL_TEXT_AFTER_EDGE:
0340             svgstyle->setDominantBaseline(DB_TEXT_AFTER_EDGE);
0341             break;
0342         case CSS_VAL_TEXT_BEFORE_EDGE:
0343             svgstyle->setDominantBaseline(DB_TEXT_BEFORE_EDGE);
0344             break;
0345         default:
0346             break;
0347         }
0348
0349         break;
0350     }
0351     case CSS_PROP_COLOR_INTERPOLATION: {
0352         HANDLE_INHERIT_AND_INITIAL(colorInterpolation, ColorInterpolation);
0353
0354         svgstyle->setColorInterpolation(colorInterpolationForValue(primitiveValue));
0355         break;
0356     }
0357     case CSS_PROP_COLOR_INTERPOLATION_FILTERS: {
0358         HANDLE_INHERIT_AND_INITIAL(colorInterpolationFilters, ColorInterpolationFilters)
0359
0360         svgstyle->setColorInterpolationFilters(colorInterpolationForValue(primitiveValue));
0361         break;
0362     }
0363     case CSS_PROP_COLOR_RENDERING: {
0364         HANDLE_INHERIT_AND_INITIAL(colorRendering, ColorRendering)
0365         if (!primitiveValue) {
0366             break;
0367         }
0368
0369         switch (primitiveValue->getIdent()) {
0370         case CSS_VAL_AUTO:
0371             svgstyle->setColorRendering(CR_AUTO);
0372             break;
0373         case CSS_VAL_OPTIMIZESPEED:
0374             svgstyle->setColorRendering(CR_OPTIMIZESPEED);
0375             break;
0376         case CSS_VAL_OPTIMIZEQUALITY:
0377             svgstyle->setColorRendering(CR_OPTIMIZEQUALITY);
0378             break;
0379         default:
0380             break;
0381         }
0382         break;
0383     }
0384     case CSS_PROP_CLIP_RULE: {
0385         HANDLE_INHERIT_AND_INITIAL(clipRule, ClipRule)
0386         if (primitiveValue) {
0387             svgstyle->setClipRule((primitiveValue->getIdent() == CSS_VAL_NONZERO) ? RULE_NONZERO : RULE_EVENODD);
0388         }
0389         break;
0390     }
0391     case CSS_PROP_FILL_RULE: {
0392         HANDLE_INHERIT_AND_INITIAL(fillRule, FillRule)
0393         if (primitiveValue) {
0394             svgstyle->setFillRule((primitiveValue->getIdent() == CSS_VAL_NONZERO) ? RULE_NONZERO : RULE_EVENODD);
0395         }
0396         break;
0397     }
0398
0399     case CSS_PROP_STROKE_LINEJOIN: {
0400         HANDLE_INHERIT_AND_INITIAL(joinStyle, JoinStyle)
0401         if (!primitiveValue) {
0402             break;
0403         }
0404
0405         switch (primitiveValue->getIdent()) {
0406         case CSS_VAL_MITER:
0407             svgstyle->setJoinStyle(khtml::MiterJoin);
0408             break;
0409         case CSS_VAL_ROUND:
0410             svgstyle->setJoinStyle(khtml::RoundJoin);
0411             break;
0412         case CSS_VAL_BEVEL:
0413             svgstyle->setJoinStyle(khtml::BevelJoin);
0414             break;
0415         default:
0416             break;
0417         }
0418         break;
0419     }
0420     case CSS_PROP_IMAGE_RENDERING: {
0421         HANDLE_INHERIT_AND_INITIAL(imageRendering, ImageRendering)
0422         if (!primitiveValue) {
0423             break;
0424         }
0425
0426         switch (primitiveValue->getIdent()) {
0427         case CSS_VAL_AUTO:
0428             svgstyle->setImageRendering(IR_AUTO);
0429             break;
0430         case CSS_VAL_OPTIMIZESPEED:
0431             svgstyle->setImageRendering(IR_OPTIMIZESPEED);
0432             break;
0433         case CSS_VAL_OPTIMIZEQUALITY:
0434             svgstyle->setImageRendering(IR_OPTIMIZEQUALITY);
0435             break;
0436         default:
0437             break;
0438         }
0439         break;
0440     }
0441     case CSS_PROP_SHAPE_RENDERING: {
0442         HANDLE_INHERIT_AND_INITIAL(shapeRendering, ShapeRendering)
0443         if (!primitiveValue) {
0444             break;
0445         }
0446
0447         switch (primitiveValue->getIdent()) {
0448         case CSS_VAL_AUTO:
0449             svgstyle->setShapeRendering(SR_AUTO);
0450             break;
0451         case CSS_VAL_OPTIMIZESPEED:
0452             svgstyle->setShapeRendering(SR_OPTIMIZESPEED);
0453             break;
0454         case CSS_VAL_CRISPEDGES:
0455             svgstyle->setShapeRendering(SR_CRISPEDGES);
0456             break;
0457         case CSS_VAL_GEOMETRICPRECISION:
0458             svgstyle->setShapeRendering(SR_GEOMETRICPRECISION);
0459             break;
0460         default:
0461             break;
0462         }
0463         break;
0464     }
0465     case CSS_PROP_TEXT_RENDERING: {
0466         HANDLE_INHERIT_AND_INITIAL(textRendering, TextRendering)
0467         if (!primitiveValue) {
0468             break;
0469         }
0470
0471         switch (primitiveValue->getIdent()) {
0472         case CSS_VAL_AUTO:
0473             svgstyle->setTextRendering(TR_AUTO);
0474             break;
0475         case CSS_VAL_OPTIMIZESPEED:
0476             svgstyle->setTextRendering(TR_OPTIMIZESPEED);
0477             break;
0478         case CSS_VAL_OPTIMIZELEGIBILITY:
0479             svgstyle->setTextRendering(TR_OPTIMIZELEGIBILITY);
0480             break;
0481         case CSS_VAL_GEOMETRICPRECISION:
0482             svgstyle->setTextRendering(TR_GEOMETRICPRECISION);
0483             break;
0484         default:
0485             break;
0486         }
0487
0488         break;
0489     }
0490     // end of ident only properties
0491     case CSS_PROP_FILL: {
0492         HANDLE_INHERIT_AND_INITIAL(fillPaint, FillPaint)
0493         if (SVGPaintImpl *paint = toPaint(value)) {
0494             svgstyle->setFillPaint(paint);
0495         }
0496         break;
0497     }
0498     case CSS_PROP_STROKE: {
0499         HANDLE_INHERIT_AND_INITIAL(strokePaint, StrokePaint)
0500         if (SVGPaintImpl *paint = toPaint(value)) {
0501             svgstyle->setStrokePaint(paint);
0502         }
0503         break;
0504     }
0505     case CSS_PROP_STROKE_WIDTH: {
0506         HANDLE_INHERIT_AND_INITIAL(strokeWidth, StrokeWidth)
0507         if (!primitiveValue) {
0508             return;
0509         }
0510
0511         svgstyle->setStrokeWidth(primitiveValue);
0512         break;
0513     }
0514
0515     case CSS_PROP_STROKE_DASHARRAY: {
0516         HANDLE_INHERIT_AND_INITIAL(strokeDashArray, StrokeDashArray)
0517         if (!primitiveValue && value && value->isValueList()) {
0518             CSSValueListImpl *dashes = static_cast<CSSValueListImpl *>(value);
0519             svgstyle->setStrokeDashArray(dashes);
0520         }
0521         break;
0522     }
0523     case CSS_PROP_STROKE_DASHOFFSET: {
0524         HANDLE_INHERIT_AND_INITIAL(strokeDashOffset, StrokeDashOffset)
0525         if (!primitiveValue) {
0526             return;
0527         }
0528
0529         svgstyle->setStrokeDashOffset(primitiveValue);
0530         break;
0531     }
0532     case CSS_PROP_FILL_OPACITY: {
0533         HANDLE_INHERIT_AND_INITIAL(fillOpacity, FillOpacity)
0534         if (!primitiveValue) {
0535             return;
0536         }
0537
0538         float f = 0.0f;
0539         int type = primitiveValue->primitiveType();
0540         if (type == CSSPrimitiveValue::CSS_PERCENTAGE) {
0541             f = primitiveValue->floatValue() / 100.0f;
0542         } else if (type == CSSPrimitiveValue::CSS_NUMBER) {
0543             f = primitiveValue->floatValue();
0544         } else {
0545             return;
0546         }
0547
0548         svgstyle->setFillOpacity(f);
0549         break;
0550     }
0551     case CSS_PROP_STROKE_OPACITY: {
0552         HANDLE_INHERIT_AND_INITIAL(strokeOpacity, StrokeOpacity)
0553         if (!primitiveValue) {
0554             return;
0555         }
0556
0557         float f = 0.0f;
0558         int type = primitiveValue->primitiveType();
0559         if (type == CSSPrimitiveValue::CSS_PERCENTAGE) {
0560             f = primitiveValue->floatValue() / 100.0f;
0561         } else if (type == CSSPrimitiveValue::CSS_NUMBER) {
0562             f = primitiveValue->floatValue();
0563         } else {
0564             return;
0565         }
0566
0567         svgstyle->setStrokeOpacity(f);
0568         break;
0569     }
0570
0571     case CSS_PROP_STOP_OPACITY: {
0572         HANDLE_INHERIT_AND_INITIAL(stopOpacity, StopOpacity)
0573         if (!primitiveValue) {
0574             return;
0575         }
0576
0577         float f = 0.0f;
0578         int type = primitiveValue->primitiveType();
0579         if (type == CSSPrimitiveValue::CSS_PERCENTAGE) {
0580             f = primitiveValue->floatValue() / 100.0f;
0581         } else if (type == CSSPrimitiveValue::CSS_NUMBER) {
0582             f = primitiveValue->floatValue();
0583         } else {
0584             return;
0585         }
0586
0587         svgstyle->setStopOpacity(f);
0588         break;
0589     }
0590
0591     case CSS_PROP_MARKER_START: {
0592         HANDLE_INHERIT_AND_INITIAL(startMarker, StartMarker)
0593         if (!primitiveValue) {
0594             return;
0595         }
0596
0597         String s;
0598         int type = primitiveValue->primitiveType();
0599         if (type == CSSPrimitiveValue::CSS_URI) {
0600             s = primitiveValue->getStringValue();
0601         } else {
0602             return;
0603         }
0604
0605         svgstyle->setStartMarker(s);
0606         break;
0607     }
0608     case CSS_PROP_MARKER_MID: {
0609         HANDLE_INHERIT_AND_INITIAL(midMarker, MidMarker)
0610         if (!primitiveValue) {
0611             return;
0612         }
0613
0614         String s;
0615         int type = primitiveValue->primitiveType();
0616         if (type == CSSPrimitiveValue::CSS_URI) {
0617             s = primitiveValue->getStringValue();
0618         } else {
0619             return;
0620         }
0621
0622         svgstyle->setMidMarker(s);
0623         break;
0624     }
0625     case CSS_PROP_MARKER_END: {
0626         HANDLE_INHERIT_AND_INITIAL(endMarker, EndMarker)
0627         if (!primitiveValue) {
0628             return;
0629         }
0630
0631         String s;
0632         int type = primitiveValue->primitiveType();
0633         if (type == CSSPrimitiveValue::CSS_URI) {
0634             s = primitiveValue->getStringValue();
0635         } else {
0636             return;
0637         }
0638
0639         svgstyle->setEndMarker(s);
0640         break;
0641     }
0642     case CSS_PROP_STROKE_LINECAP: {
0643         HANDLE_INHERIT_AND_INITIAL(capStyle, CapStyle)
0644         if (!primitiveValue) {
0645             break;
0646         }
0647
0648         switch (primitiveValue->getIdent()) {
0649         case CSS_VAL_BUTT:
0650             svgstyle->setCapStyle(ButtCap);
0651             break;
0652         case CSS_VAL_ROUND:
0653             svgstyle->setCapStyle(RoundCap);
0654             break;
0655         case CSS_VAL_SQUARE:
0656             svgstyle->setCapStyle(SquareCap);
0657             break;
0658         default:
0659             break;
0660         }
0661         break;
0662     }
0663     case CSS_PROP_STROKE_MITERLIMIT: {
0664         HANDLE_INHERIT_AND_INITIAL(strokeMiterLimit, StrokeMiterLimit)
0665         if (!primitiveValue) {
0666             return;
0667         }
0668
0669         float f = 0.0f;
0670         int type = primitiveValue->primitiveType();
0671         if (type == CSSPrimitiveValue::CSS_NUMBER) {
0672             f = primitiveValue->floatValue();
0673         } else {
0674             return;
0675         }
0676
0677         svgstyle->setStrokeMiterLimit(f);
0678         break;
0679     }
0680     case CSS_PROP_FILTER: {
0681         HANDLE_INHERIT_AND_INITIAL(filter, Filter)
0682         if (!primitiveValue) {
0683             return;
0684         }
0685
0686         String s;
0687         int type = primitiveValue->primitiveType();
0688         if (type == CSSPrimitiveValue::CSS_URI) {
0689             s = primitiveValue->getStringValue();
0690         } else {
0691             return;
0692         }
0693         svgstyle->setFilter(s);
0694         break;
0695     }
0696     case CSS_PROP_MASK: {
0697         HANDLE_INHERIT_AND_INITIAL(maskElement, MaskElement)
0698         if (!primitiveValue) {
0699             return;
0700         }
0701
0702         String s;
0703         int type = primitiveValue->primitiveType();
0704         if (type == CSSPrimitiveValue::CSS_URI) {
0705             s = primitiveValue->getStringValue();
0706         } else {
0707             return;
0708         }
0709
0710         svgstyle->setMaskElement(s);
0711         break;
0712     }
0713     case CSS_PROP_CLIP_PATH: {
0714         HANDLE_INHERIT_AND_INITIAL(clipPath, ClipPath)
0715         if (!primitiveValue) {
0716             return;
0717         }
0718
0719         String s;
0720         int type = primitiveValue->primitiveType();
0721         if (type == CSSPrimitiveValue::CSS_URI) {
0722             s = primitiveValue->getStringValue();
0723         } else {
0724             return;
0725         }
0726
0727         svgstyle->setClipPath(s);
0728         break;
0729     }
0730
0731     case CSS_PROP_TEXT_ANCHOR: {
0732         HANDLE_INHERIT_AND_INITIAL(textAnchor, TextAnchor)
0733         if (primitiveValue) {
0734             switch (primitiveValue->getIdent()) {
0735             case CSS_VAL_START:
0736                 svgstyle->setTextAnchor(TA_START);
0737                 break;
0738             case CSS_VAL_MIDDLE:
0739                 svgstyle->setTextAnchor(TA_MIDDLE);
0740                 break;
0741             case CSS_VAL_END:
0742                 svgstyle->setTextAnchor(TA_END);
0743                 break;
0744             }
0745         }
0746         break;
0747     }
0748
0749     case CSS_PROP_WRITING_MODE: {
0750         HANDLE_INHERIT_AND_INITIAL(writingMode, WritingMode)
0751         if (!primitiveValue) {
0752             return;
0753         }
0754
0755         switch (primitiveValue->getIdent()) {
0756         case CSS_VAL_LR_TB:
0757             svgstyle->setWritingMode(WM_LRTB);
0758             break;
0759         case CSS_VAL_LR:
0760             svgstyle->setWritingMode(WM_LR);
0761             break;
0762         case CSS_VAL_RL_TB:
0763             svgstyle->setWritingMode(WM_RLTB);
0764             break;
0765         case CSS_VAL_RL:
0766             svgstyle->setWritingMode(WM_RL);
0767             break;
0768         case CSS_VAL_TB_RL:
0769             svgstyle->setWritingMode(WM_TBRL);
0770             break;
0771         case CSS_VAL_TB:
0772             svgstyle->setWritingMode(WM_TB);
0773             break;
0774         default:
0775             break;
0776         }
0777         break;
0778     }
0779
0780     case CSS_PROP_STOP_COLOR: {
0781         HANDLE_INHERIT_AND_INITIAL(stopColor, StopColor);
0782
0783         SVGColorImpl *c = toColor(value);
0784         if (!c) {
0785             break;
0786         }
0787
0788         QColor col;
0789         if (c->colorType() == SVGColorImpl::SVG_COLORTYPE_CURRENTCOLOR) {
0790             col = style->color();
0791         } else {
0792             col = c->color();
0793         }
0794
0795         svgstyle->setStopColor(col);
0796         break;
0797     }
0798
0799     case CSS_PROP_LIGHTING_COLOR: {
0800         HANDLE_INHERIT_AND_INITIAL(lightingColor, LightingColor);
0801
0802         SVGColorImpl *c = toColor(value);
0803         if (!c) {
0804             break;
0805         }
0806
0807         QColor col;
0808         if (c->colorType() == SVGColorImpl::SVG_COLORTYPE_CURRENTCOLOR) {
0809             col = style->color();
0810         } else {
0811             col = c->color();
0812         }
0813
0814         svgstyle->setLightingColor(col);
0815         break;
0816     }
0817     case CSS_PROP_FLOOD_OPACITY: {
0818         HANDLE_INHERIT_AND_INITIAL(floodOpacity, FloodOpacity)
0819         if (!primitiveValue) {
0820             return;
0821         }
0822
0823         float f = 0.0f;
0824         int type = primitiveValue->primitiveType();
0825         if (type == CSSPrimitiveValue::CSS_PERCENTAGE) {
0826             f = primitiveValue->floatValue() / 100.0f;
0827         } else if (type == CSSPrimitiveValue::CSS_NUMBER) {
0828             f = primitiveValue->floatValue();
0829         } else {
0830             return;
0831         }
0832
0833         svgstyle->setFloodOpacity(f);
0834         break;
0835     }
0836     case CSS_PROP_FLOOD_COLOR: {
0837         QColor col;
0838         if (isInitial) {
0839             col = SVGRenderStyle::initialFloodColor();
0840         } else {
0841             SVGColorImpl *c = toColor(value);
0842             if (!c) {
0843                 break;
0844             }
0845
0846             if (c->colorType() == SVGColorImpl::SVG_COLORTYPE_CURRENTCOLOR) {
0847                 col = style->color();
0848             } else {
0849                 col = c->color();
0850             }
0851         }
0852
0853         svgstyle->setFloodColor(col);
0854         break;
0855     }
0856     case CSS_PROP_GLYPH_ORIENTATION_HORIZONTAL: {
0857         HANDLE_INHERIT_AND_INITIAL(glyphOrientationHorizontal, GlyphOrientationHorizontal)
0858         if (!primitiveValue) {
0859             return;
0860         }
0861
0862         if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_DEG) {
0863             int orientation = angleToGlyphOrientation(primitiveValue->floatValue());
0864             ASSERT(orientation != -1);
0865
0866             svgstyle->setGlyphOrientationHorizontal((EGlyphOrientation) orientation);
0867         }
0868
0869         break;
0870     }
0871     case CSS_PROP_GLYPH_ORIENTATION_VERTICAL: {
0872         HANDLE_INHERIT_AND_INITIAL(glyphOrientationVertical, GlyphOrientationVertical)
0873         if (!primitiveValue) {
0874             return;
0875         }
0876
0877         if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_DEG) {
0878             int orientation = angleToGlyphOrientation(primitiveValue->floatValue());
0879             ASSERT(orientation != -1);
0880
0881             svgstyle->setGlyphOrientationVertical((EGlyphOrientation) orientation);
0882         } else if (primitiveValue->getIdent() == CSS_VAL_AUTO) {
0883             svgstyle->setGlyphOrientationVertical(GO_AUTO);
0884         }
0885
0886         break;
0887     }
0888     case CSS_PROP_ENABLE_BACKGROUND:
0889         // Silently ignoring this property for now
0890         // https://bugs.webkit.org/show_bug.cgi?id=6022
0891         break;
0892     default:
0893         // If you crash here, it's because you added a css property and are not handling it
0894         // in either this switch statement or the one in CSSStyleSelector::applyProperty
0895         qCWarning(KHTML_LOG) << "unimplemented property" << id << getPropertyName(id).string();
0896         return;
0897     }
0898 }
0899
0900 }
0901