WebCore/css/SVGCSSStyleSelector.cpp

   1 /*
   2     Copyright (C) 2005 Apple Computer, Inc.
   3     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
   4                   2004, 2005, 2008 Rob Buis <buis@kde.org>
   5     Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
   6
   7     Based on khtml css code by:
   8     Copyright(C) 1999-2003 Lars Knoll(knoll@kde.org)
   9              (C) 2003 Apple Computer, Inc.
  10              (C) 2004 Allan Sandfeld Jensen(kde@carewolf.com)
  11              (C) 2004 Germain Garand(germain@ebooksfrance.org)
  12
  13     This library is free software; you can redistribute it and/or
  14     modify it under the terms of the GNU Library General Public
  15     License as published by the Free Software Foundation; either
  16     version 2 of the License, or (at your option) any later version.
  17
  18     This library is distributed in the hope that it will be useful,
  19     but WITHOUT ANY WARRANTY; without even the implied warranty of
  20     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21     Library General Public License for more details.
  22
  23     You should have received a copy of the GNU Library General Public License
  24     along with this library; see the file COPYING.LIB.  If not, write to
  25     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  26     Boston, MA 02110-1301, USA.
  27 */
  28
  29 #include "config.h"
  30
  31 #if ENABLE(SVG)
  32 #include "CSSStyleSelector.h"
  33
  34 #include "CSSPrimitiveValueMappings.h"
  35 #include "CSSPropertyNames.h"
  36 #include "CSSValueList.h"
  37 #include "Document.h"
  38 #include "ShadowValue.h"
  39 #include "SVGColor.h"
  40 #include "SVGNames.h"
  41 #include "SVGPaint.h"
  42 #include "SVGRenderStyle.h"
  43 #include "SVGRenderStyleDefs.h"
  44 #include "SVGStyledElement.h"
  45 #include "SVGURIReference.h"
  46 #include <stdlib.h>
  47 #include <wtf/MathExtras.h>
  48
  49 #define HANDLE_INHERIT(prop, Prop) \
  50 if (isInherit) \
  51 {\
  52     svgstyle->set##Prop(m_parentStyle->svgStyle()->prop());\
  53     return;\
  54 }
  55
  56 #define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
  57 HANDLE_INHERIT(prop, Prop) \
  58 else if (isInitial) \
  59     svgstyle->set##Prop(SVGRenderStyle::initial##Prop());
  60
  61
  62 namespace WebCore {
  63
  64 static float roundToNearestGlyphOrientationAngle(float angle)
  65 {
  66     angle = fabsf(fmodf(angle, 360.0f));
  67
  68     if (angle <= 45.0f || angle > 315.0f)
  69         return 0.0f;
  70     else if (angle > 45.0f && angle <= 135.0f)
  71         return 90.0f;
  72     else if (angle > 135.0f && angle <= 225.0f)
  73         return 180.0f;
  74
  75     return 270.0f;
  76 }
  77
  78 static int angleToGlyphOrientation(float angle)
  79 {
  80     angle = roundToNearestGlyphOrientationAngle(angle);
  81
  82     if (angle == 0.0f)
  83         return GO_0DEG;
  84     else if (angle == 90.0f)
  85         return GO_90DEG;
  86     else if (angle == 180.0f)
  87         return GO_180DEG;
  88     else if (angle == 270.0f)
  89         return GO_270DEG;
  90
  91     return -1;
  92 }
  93
  94 static Color colorFromSVGColorCSSValue(CSSValue* value, RenderStyle* style)
  95 {
  96     ASSERT(value->isSVGColor());
  97     SVGColor* c = static_cast<SVGColor*>(value);
  98     Color color;
  99     if (c->colorType() == SVGColor::SVG_COLORTYPE_CURRENTCOLOR)
 100         color = style->color();
 101     else
 102         color = c->color();
 103     return color;
 104 }
 105
 106 void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
 107 {
 108     ASSERT(value);
 109     CSSPrimitiveValue* primitiveValue = 0;
 110     if (value->isPrimitiveValue())
 111         primitiveValue = static_cast<CSSPrimitiveValue*>(value);
 112
 113     SVGRenderStyle* svgstyle = m_style->accessSVGStyle();
 114     unsigned short valueType = value->cssValueType();
 115
 116     bool isInherit = m_parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT;
 117     bool isInitial = valueType == CSSPrimitiveValue::CSS_INITIAL || (!m_parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT);
 118
 119     // What follows is a list that maps the CSS properties into their
 120     // corresponding front-end RenderStyle values. Shorthands(e.g. border,
 121     // background) occur in this list as well and are only hit when mapping
 122     // "inherit" or "initial" into front-end values.
 123     switch (id)
 124     {
 125         // ident only properties
 126         case CSSPropertyAlignmentBaseline:
 127         {
 128             HANDLE_INHERIT_AND_INITIAL(alignmentBaseline, AlignmentBaseline)
 129             if (!primitiveValue)
 130                 break;
 131
 132             svgstyle->setAlignmentBaseline(*primitiveValue);
 133             break;
 134         }
 135         case CSSPropertyBaselineShift:
 136         {
 137             HANDLE_INHERIT_AND_INITIAL(baselineShift, BaselineShift);
 138             if (!primitiveValue)
 139                 break;
 140
 141             if (primitiveValue->getIdent()) {
 142                 switch (primitiveValue->getIdent()) {
 143                 case CSSValueBaseline:
 144                     svgstyle->setBaselineShift(BS_BASELINE);
 145                     break;
 146                 case CSSValueSub:
 147                     svgstyle->setBaselineShift(BS_SUB);
 148                     break;
 149                 case CSSValueSuper:
 150                     svgstyle->setBaselineShift(BS_SUPER);
 151                     break;
 152                 default:
 153                     break;
 154                 }
 155             } else {
 156                 svgstyle->setBaselineShift(BS_LENGTH);
 157                 svgstyle->setBaselineShiftValue(primitiveValue);
 158             }
 159
 160             break;
 161         }
 162         case CSSPropertyKerning:
 163         {
 164             HANDLE_INHERIT_AND_INITIAL(kerning, Kerning);
 165             svgstyle->setKerning(primitiveValue);
 166             break;
 167         }
 168         case CSSPropertyDominantBaseline:
 169         {
 170             HANDLE_INHERIT_AND_INITIAL(dominantBaseline, DominantBaseline)
 171             if (primitiveValue)
 172                 svgstyle->setDominantBaseline(*primitiveValue);
 173             break;
 174         }
 175         case CSSPropertyColorInterpolation:
 176         {
 177             HANDLE_INHERIT_AND_INITIAL(colorInterpolation, ColorInterpolation)
 178             if (primitiveValue)
 179                 svgstyle->setColorInterpolation(*primitiveValue);
 180             break;
 181         }
 182         case CSSPropertyColorInterpolationFilters:
 183         {
 184             HANDLE_INHERIT_AND_INITIAL(colorInterpolationFilters, ColorInterpolationFilters)
 185             if (primitiveValue)
 186                 svgstyle->setColorInterpolationFilters(*primitiveValue);
 187             break;
 188         }
 189         case CSSPropertyColorRendering:
 190         {
 191             HANDLE_INHERIT_AND_INITIAL(colorRendering, ColorRendering)
 192             if (primitiveValue)
 193                 svgstyle->setColorRendering(*primitiveValue);
 194             break;
 195         }
 196         case CSSPropertyClipRule:
 197         {
 198             HANDLE_INHERIT_AND_INITIAL(clipRule, ClipRule)
 199             if (primitiveValue)
 200                 svgstyle->setClipRule(*primitiveValue);
 201             break;
 202         }
 203         case CSSPropertyFillRule:
 204         {
 205             HANDLE_INHERIT_AND_INITIAL(fillRule, FillRule)
 206             if (primitiveValue)
 207                 svgstyle->setFillRule(*primitiveValue);
 208             break;
 209         }
 210         case CSSPropertyStrokeLinejoin:
 211         {
 212             HANDLE_INHERIT_AND_INITIAL(joinStyle, JoinStyle)
 213             if (primitiveValue)
 214                 svgstyle->setJoinStyle(*primitiveValue);
 215             break;
 216         }
 217         case CSSPropertyImageRendering:
 218         {
 219             HANDLE_INHERIT_AND_INITIAL(imageRendering, ImageRendering)
 220             if (primitiveValue)
 221                 svgstyle->setImageRendering(*primitiveValue);
 222             break;
 223         }
 224         case CSSPropertyShapeRendering:
 225         {
 226             HANDLE_INHERIT_AND_INITIAL(shapeRendering, ShapeRendering)
 227             if (primitiveValue)
 228                 svgstyle->setShapeRendering(*primitiveValue);
 229             break;
 230         }
 231         // end of ident only properties
 232         case CSSPropertyFill:
 233         {
 234             HANDLE_INHERIT_AND_INITIAL(fillPaint, FillPaint)
 235             if (value->isSVGPaint())
 236                 svgstyle->setFillPaint(static_cast<SVGPaint*>(value));
 237             break;
 238         }
 239         case CSSPropertyStroke:
 240         {
 241             HANDLE_INHERIT_AND_INITIAL(strokePaint, StrokePaint)
 242             if (value->isSVGPaint())
 243                 svgstyle->setStrokePaint(static_cast<SVGPaint*>(value));
 244
 245             break;
 246         }
 247         case CSSPropertyStrokeWidth:
 248         {
 249             HANDLE_INHERIT_AND_INITIAL(strokeWidth, StrokeWidth)
 250             if (primitiveValue)
 251                 svgstyle->setStrokeWidth(primitiveValue);
 252             break;
 253         }
 254         case CSSPropertyStrokeDasharray:
 255         {
 256             HANDLE_INHERIT_AND_INITIAL(strokeDashArray, StrokeDashArray)
 257             if (value->isValueList())
 258                 svgstyle->setStrokeDashArray(static_cast<CSSValueList*>(value));
 259             break;
 260         }
 261         case CSSPropertyStrokeDashoffset:
 262         {
 263             HANDLE_INHERIT_AND_INITIAL(strokeDashOffset, StrokeDashOffset)
 264             if (primitiveValue)
 265                 svgstyle->setStrokeDashOffset(primitiveValue);
 266             break;
 267         }
 268         case CSSPropertyFillOpacity:
 269         {
 270             HANDLE_INHERIT_AND_INITIAL(fillOpacity, FillOpacity)
 271             if (!primitiveValue)
 272                 return;
 273
 274             float f = 0.0f;
 275             int type = primitiveValue->primitiveType();
 276             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
 277                 f = primitiveValue->getFloatValue() / 100.0f;
 278             else if (type == CSSPrimitiveValue::CSS_NUMBER)
 279                 f = primitiveValue->getFloatValue();
 280             else
 281                 return;
 282
 283             svgstyle->setFillOpacity(f);
 284             break;
 285         }
 286         case CSSPropertyStrokeOpacity:
 287         {
 288             HANDLE_INHERIT_AND_INITIAL(strokeOpacity, StrokeOpacity)
 289             if (!primitiveValue)
 290                 return;
 291
 292             float f = 0.0f;
 293             int type = primitiveValue->primitiveType();
 294             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
 295                 f = primitiveValue->getFloatValue() / 100.0f;
 296             else if (type == CSSPrimitiveValue::CSS_NUMBER)
 297                 f = primitiveValue->getFloatValue();
 298             else
 299                 return;
 300
 301             svgstyle->setStrokeOpacity(f);
 302             break;
 303         }
 304         case CSSPropertyStopOpacity:
 305         {
 306             HANDLE_INHERIT_AND_INITIAL(stopOpacity, StopOpacity)
 307             if (!primitiveValue)
 308                 return;
 309
 310             float f = 0.0f;
 311             int type = primitiveValue->primitiveType();
 312             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
 313                 f = primitiveValue->getFloatValue() / 100.0f;
 314             else if (type == CSSPrimitiveValue::CSS_NUMBER)
 315                 f = primitiveValue->getFloatValue();
 316             else
 317                 return;
 318
 319             svgstyle->setStopOpacity(f);
 320             break;
 321         }
 322         case CSSPropertyMarkerStart:
 323         {
 324             HANDLE_INHERIT_AND_INITIAL(startMarker, StartMarker)
 325             if (!primitiveValue)
 326                 return;
 327
 328             String s;
 329             int type = primitiveValue->primitiveType();
 330             if (type == CSSPrimitiveValue::CSS_URI)
 331                 s = primitiveValue->getStringValue();
 332             else
 333                 return;
 334
 335             svgstyle->setStartMarker(SVGURIReference::getTarget(s));
 336             break;
 337         }
 338         case CSSPropertyMarkerMid:
 339         {
 340             HANDLE_INHERIT_AND_INITIAL(midMarker, MidMarker)
 341             if (!primitiveValue)
 342                 return;
 343
 344             String s;
 345             int type = primitiveValue->primitiveType();
 346             if (type == CSSPrimitiveValue::CSS_URI)
 347                 s = primitiveValue->getStringValue();
 348             else
 349                 return;
 350
 351             svgstyle->setMidMarker(SVGURIReference::getTarget(s));
 352             break;
 353         }
 354         case CSSPropertyMarkerEnd:
 355         {
 356             HANDLE_INHERIT_AND_INITIAL(endMarker, EndMarker)
 357             if (!primitiveValue)
 358                 return;
 359
 360             String s;
 361             int type = primitiveValue->primitiveType();
 362             if (type == CSSPrimitiveValue::CSS_URI)
 363                 s = primitiveValue->getStringValue();
 364             else
 365                 return;
 366
 367             svgstyle->setEndMarker(SVGURIReference::getTarget(s));
 368             break;
 369         }
 370         case CSSPropertyStrokeLinecap:
 371         {
 372             HANDLE_INHERIT_AND_INITIAL(capStyle, CapStyle)
 373             if (primitiveValue)
 374                 svgstyle->setCapStyle(*primitiveValue);
 375             break;
 376         }
 377         case CSSPropertyStrokeMiterlimit:
 378         {
 379             HANDLE_INHERIT_AND_INITIAL(strokeMiterLimit, StrokeMiterLimit)
 380             if (!primitiveValue)
 381                 return;
 382
 383             float f = 0.0f;
 384             int type = primitiveValue->primitiveType();
 385             if (type == CSSPrimitiveValue::CSS_NUMBER)
 386                 f = primitiveValue->getFloatValue();
 387             else
 388                 return;
 389
 390             svgstyle->setStrokeMiterLimit(f);
 391             break;
 392         }
 393         case CSSPropertyFilter:
 394         {
 395             HANDLE_INHERIT_AND_INITIAL(filter, Filter)
 396             if (!primitiveValue)
 397                 return;
 398
 399             String s;
 400             int type = primitiveValue->primitiveType();
 401             if (type == CSSPrimitiveValue::CSS_URI)
 402                 s = primitiveValue->getStringValue();
 403             else
 404                 return;
 405             svgstyle->setFilter(SVGURIReference::getTarget(s));
 406             break;
 407         }
 408         case CSSPropertyMask:
 409         {
 410             HANDLE_INHERIT_AND_INITIAL(maskElement, MaskElement)
 411             if (!primitiveValue)
 412                 return;
 413
 414             String s;
 415             int type = primitiveValue->primitiveType();
 416             if (type == CSSPrimitiveValue::CSS_URI)
 417                 s = primitiveValue->getStringValue();
 418             else
 419                 return;
 420
 421             svgstyle->setMaskElement(SVGURIReference::getTarget(s));
 422             break;
 423         }
 424         case CSSPropertyClipPath:
 425         {
 426             HANDLE_INHERIT_AND_INITIAL(clipPath, ClipPath)
 427             if (!primitiveValue)
 428                 return;
 429
 430             String s;
 431             int type = primitiveValue->primitiveType();
 432             if (type == CSSPrimitiveValue::CSS_URI)
 433                 s = primitiveValue->getStringValue();
 434             else
 435                 return;
 436
 437             svgstyle->setClipPath(SVGURIReference::getTarget(s));
 438             break;
 439         }
 440         case CSSPropertyTextAnchor:
 441         {
 442             HANDLE_INHERIT_AND_INITIAL(textAnchor, TextAnchor)
 443             if (primitiveValue)
 444                 svgstyle->setTextAnchor(*primitiveValue);
 445             break;
 446         }
 447         case CSSPropertyWritingMode:
 448         {
 449             HANDLE_INHERIT_AND_INITIAL(writingMode, WritingMode)
 450             if (primitiveValue)
 451                 svgstyle->setWritingMode(*primitiveValue);
 452             break;
 453         }
 454         case CSSPropertyStopColor:
 455         {
 456             HANDLE_INHERIT_AND_INITIAL(stopColor, StopColor);
 457             svgstyle->setStopColor(colorFromSVGColorCSSValue(value, m_style.get()));
 458             break;
 459         }
 460        case CSSPropertyLightingColor:
 461         {
 462             HANDLE_INHERIT_AND_INITIAL(lightingColor, LightingColor);
 463             svgstyle->setLightingColor(colorFromSVGColorCSSValue(value, m_style.get()));
 464             break;
 465         }
 466         case CSSPropertyFloodOpacity:
 467         {
 468             HANDLE_INHERIT_AND_INITIAL(floodOpacity, FloodOpacity)
 469             if (!primitiveValue)
 470                 return;
 471
 472             float f = 0.0f;
 473             int type = primitiveValue->primitiveType();
 474             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
 475                 f = primitiveValue->getFloatValue() / 100.0f;
 476             else if (type == CSSPrimitiveValue::CSS_NUMBER)
 477                 f = primitiveValue->getFloatValue();
 478             else
 479                 return;
 480
 481             svgstyle->setFloodOpacity(f);
 482             break;
 483         }
 484         case CSSPropertyFloodColor:
 485         {
 486             if (isInitial) {
 487                 svgstyle->setFloodColor(SVGRenderStyle::initialFloodColor());
 488                 return;
 489             }
 490             svgstyle->setFloodColor(colorFromSVGColorCSSValue(value, m_style.get()));
 491             break;
 492         }
 493         case CSSPropertyGlyphOrientationHorizontal:
 494         {
 495             HANDLE_INHERIT_AND_INITIAL(glyphOrientationHorizontal, GlyphOrientationHorizontal)
 496             if (!primitiveValue)
 497                 return;
 498
 499             if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_DEG) {
 500                 int orientation = angleToGlyphOrientation(primitiveValue->getFloatValue());
 501                 ASSERT(orientation != -1);
 502
 503                 svgstyle->setGlyphOrientationHorizontal((EGlyphOrientation) orientation);
 504             }
 505
 506             break;
 507         }
 508         case CSSPropertyGlyphOrientationVertical:
 509         {
 510             HANDLE_INHERIT_AND_INITIAL(glyphOrientationVertical, GlyphOrientationVertical)
 511             if (!primitiveValue)
 512                 return;
 513
 514             if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_DEG) {
 515                 int orientation = angleToGlyphOrientation(primitiveValue->getFloatValue());
 516                 ASSERT(orientation != -1);
 517
 518                 svgstyle->setGlyphOrientationVertical((EGlyphOrientation) orientation);
 519             } else if (primitiveValue->getIdent() == CSSValueAuto)
 520                 svgstyle->setGlyphOrientationVertical(GO_AUTO);
 521
 522             break;
 523         }
 524         case CSSPropertyEnableBackground:
 525             // Silently ignoring this property for now
 526             // http://bugs.webkit.org/show_bug.cgi?id=6022
 527             break;
 528         case CSSPropertyWebkitShadow: {
 529             if (isInherit)
 530                 return svgstyle->setShadow(m_parentStyle->svgStyle()->shadow() ? new ShadowData(*m_parentStyle->svgStyle()->shadow()) : 0);
 531             if (isInitial || primitiveValue) // initial | none
 532                 return svgstyle->setShadow(0);
 533
 534             if (!value->isValueList())
 535                 return;
 536
 537             float zoomFactor = m_style->effectiveZoom();
 538
 539             CSSValueList *list = static_cast<CSSValueList*>(value);
 540             ASSERT(list->length() == 1);
 541             ShadowValue* item = static_cast<ShadowValue*>(list->itemWithoutBoundsCheck(0));
 542             int x = item->x->computeLengthInt(style(), m_rootElementStyle, zoomFactor);
 543             int y = item->y->computeLengthInt(style(), m_rootElementStyle, zoomFactor);
 544             int blur = item->blur ? item->blur->computeLengthInt(style(), m_rootElementStyle, zoomFactor) : 0;
 545             Color color;
 546             if (item->color)
 547                 color = getColorFromPrimitiveValue(item->color.get());
 548
 549             // -webkit-shadow does should not have a spread or style
 550             ASSERT(!item->spread);
 551             ASSERT(!item->style);
 552
 553             ShadowData* shadowData = new ShadowData(x, y, blur, 0, Normal, color.isValid() ? color : Color::transparent);
 554             svgstyle->setShadow(shadowData);
 555             return;
 556         }
 557         default:
 558             // If you crash here, it's because you added a css property and are not handling it
 559             // in either this switch statement or the one in CSSStyleSelector::applyProperty
 560             ASSERT_WITH_MESSAGE(0, "unimplemented propertyID: %d", id);
 561             return;
 562     }
 563 }
 564
 565 }
 566
 567 // vim:ts=4:noet
 568 #endif // ENABLE(SVG)