Source/WebCore/svg/SVGLength.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
   4  * Copyright (C) 2007 Apple Inc. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #if ENABLE(SVG)
  25 #include "SVGLength.h"
  26
  27 #include "CSSHelper.h"
  28 #include "FloatConversion.h"
  29 #include "FrameView.h"
  30 #include "RenderObject.h"
  31 #include "RenderView.h"
  32 #include "SVGNames.h"
  33 #include "SVGParserUtilities.h"
  34 #include "SVGSVGElement.h"
  35
  36 #include <wtf/MathExtras.h>
  37 #include <wtf/text/StringConcatenate.h>
  38
  39 namespace WebCore {
  40
  41 // Helper functions
  42 static inline unsigned int storeUnit(SVGLengthMode mode, SVGLengthType type)
  43 {
  44     return (mode << 4) | type;
  45 }
  46
  47 static inline SVGLengthMode extractMode(unsigned int unit)
  48 {
  49     unsigned int mode = unit >> 4;
  50     return static_cast<SVGLengthMode>(mode);
  51 }
  52
  53 static inline SVGLengthType extractType(unsigned int unit)
  54 {
  55     unsigned int mode = unit >> 4;
  56     unsigned int type = unit ^ (mode << 4);
  57     return static_cast<SVGLengthType>(type);
  58 }
  59
  60 static inline String lengthTypeToString(SVGLengthType type)
  61 {
  62     switch (type) {
  63     case LengthTypeUnknown:
  64     case LengthTypeNumber:
  65         return "";
  66     case LengthTypePercentage:
  67         return "%";
  68     case LengthTypeEMS:
  69         return "em";
  70     case LengthTypeEXS:
  71         return "ex";
  72     case LengthTypePX:
  73         return "px";
  74     case LengthTypeCM:
  75         return "cm";
  76     case LengthTypeMM:
  77         return "mm";
  78     case LengthTypeIN:
  79         return "in";
  80     case LengthTypePT:
  81         return "pt";
  82     case LengthTypePC:
  83         return "pc";
  84     }
  85
  86     ASSERT_NOT_REACHED();
  87     return String();
  88 }
  89
  90 inline SVGLengthType stringToLengthType(const UChar*& ptr, const UChar* end)
  91 {
  92     if (ptr == end)
  93         return LengthTypeNumber;
  94
  95     const UChar firstChar = *ptr;
  96
  97     if (++ptr == end)
  98         return firstChar == '%' ? LengthTypePercentage : LengthTypeUnknown;
  99
 100     const UChar secondChar = *ptr;
 101
 102     if (++ptr != end)
 103         return LengthTypeUnknown;
 104
 105     if (firstChar == 'e' && secondChar == 'm')
 106         return LengthTypeEMS;
 107     if (firstChar == 'e' && secondChar == 'x')
 108         return LengthTypeEXS;
 109     if (firstChar == 'p' && secondChar == 'x')
 110         return LengthTypePX;
 111     if (firstChar == 'c' && secondChar == 'm')
 112         return LengthTypeCM;
 113     if (firstChar == 'm' && secondChar == 'm')
 114         return LengthTypeMM;
 115     if (firstChar == 'i' && secondChar == 'n')
 116         return LengthTypeIN;
 117     if (firstChar == 'p' && secondChar == 't')
 118         return LengthTypePT;
 119     if (firstChar == 'p' && secondChar == 'c')
 120         return LengthTypePC;
 121
 122     return LengthTypeUnknown;
 123 }
 124
 125 SVGLength::SVGLength(SVGLengthMode mode, const String& valueAsString)
 126     : m_valueInSpecifiedUnits(0)
 127     , m_unit(storeUnit(mode, LengthTypeNumber))
 128 {
 129     ExceptionCode ec = 0;
 130     setValueAsString(valueAsString, ec);
 131 }
 132
 133 SVGLength::SVGLength(const SVGLength& other)
 134     : m_valueInSpecifiedUnits(other.m_valueInSpecifiedUnits)
 135     , m_unit(other.m_unit)
 136 {
 137 }
 138
 139 bool SVGLength::operator==(const SVGLength& other) const
 140 {
 141     return m_unit == other.m_unit
 142         && m_valueInSpecifiedUnits == other.m_valueInSpecifiedUnits;
 143 }
 144
 145 bool SVGLength::operator!=(const SVGLength& other) const
 146 {
 147     return !operator==(other);
 148 }
 149
 150 SVGLengthType SVGLength::unitType() const
 151 {
 152     return extractType(m_unit);
 153 }
 154
 155 float SVGLength::value(const SVGElement* context) const
 156 {
 157     ExceptionCode ec = 0;
 158     return value(context, ec);
 159 }
 160
 161 float SVGLength::value(const SVGElement* context, ExceptionCode& ec) const
 162 {
 163     switch (extractType(m_unit)) {
 164     case LengthTypeUnknown:
 165         ec = NOT_SUPPORTED_ERR;
 166         return 0;
 167     case LengthTypeNumber:
 168         return m_valueInSpecifiedUnits;
 169     case LengthTypePercentage:
 170         return convertValueFromPercentageToUserUnits(m_valueInSpecifiedUnits / 100, context, ec);
 171     case LengthTypeEMS:
 172         return convertValueFromEMSToUserUnits(m_valueInSpecifiedUnits, context, ec);
 173     case LengthTypeEXS:
 174         return convertValueFromEXSToUserUnits(m_valueInSpecifiedUnits, context, ec);
 175     case LengthTypePX:
 176         return m_valueInSpecifiedUnits;
 177     case LengthTypeCM:
 178         return m_valueInSpecifiedUnits / 2.54f * cssPixelsPerInch;
 179     case LengthTypeMM:
 180         return m_valueInSpecifiedUnits / 25.4f * cssPixelsPerInch;
 181     case LengthTypeIN:
 182         return m_valueInSpecifiedUnits * cssPixelsPerInch;
 183     case LengthTypePT:
 184         return m_valueInSpecifiedUnits / 72 * cssPixelsPerInch;
 185     case LengthTypePC:
 186         return m_valueInSpecifiedUnits / 6 * cssPixelsPerInch;
 187     }
 188
 189     ASSERT_NOT_REACHED();
 190     return 0;
 191 }
 192
 193 void SVGLength::setValue(float value, const SVGElement* context, ExceptionCode& ec)
 194 {
 195     switch (extractType(m_unit)) {
 196     case LengthTypeUnknown:
 197         ec = NOT_SUPPORTED_ERR;
 198         break;
 199     case LengthTypeNumber:
 200         m_valueInSpecifiedUnits = value;
 201         break;
 202     case LengthTypePercentage: {
 203         float result = convertValueFromUserUnitsToPercentage(value, context, ec);
 204         if (!ec)
 205             m_valueInSpecifiedUnits = result;
 206         break;
 207     }
 208     case LengthTypeEMS: {
 209         float result = convertValueFromUserUnitsToEMS(value, context, ec);
 210         if (!ec)
 211             m_valueInSpecifiedUnits = result;
 212         break;
 213     }
 214     case LengthTypeEXS: {
 215         float result = convertValueFromUserUnitsToEXS(value, context, ec);
 216         if (!ec)
 217             m_valueInSpecifiedUnits = result;
 218         break;
 219     }
 220     case LengthTypePX:
 221         m_valueInSpecifiedUnits = value;
 222         break;
 223     case LengthTypeCM:
 224         m_valueInSpecifiedUnits = value * 2.54f / cssPixelsPerInch;
 225         break;
 226     case LengthTypeMM:
 227         m_valueInSpecifiedUnits = value * 25.4f / cssPixelsPerInch;
 228         break;
 229     case LengthTypeIN:
 230         m_valueInSpecifiedUnits = value / cssPixelsPerInch;
 231         break;
 232     case LengthTypePT:
 233         m_valueInSpecifiedUnits = value * 72 / cssPixelsPerInch;
 234         break;
 235     case LengthTypePC:
 236         m_valueInSpecifiedUnits = value * 6 / cssPixelsPerInch;
 237         break;
 238     }
 239 }
 240
 241 float SVGLength::valueAsPercentage() const
 242 {
 243     // 100% = 100.0 instead of 1.0 for historical reasons, this could eventually be changed
 244     if (extractType(m_unit) == LengthTypePercentage)
 245         return m_valueInSpecifiedUnits / 100;
 246
 247     return m_valueInSpecifiedUnits;
 248 }
 249
 250 void SVGLength::setValueAsString(const String& string, ExceptionCode& ec)
 251 {
 252     if (string.isEmpty())
 253         return;
 254
 255     float convertedNumber = 0;
 256     const UChar* ptr = string.characters();
 257     const UChar* end = ptr + string.length();
 258
 259     if (!parseNumber(ptr, end, convertedNumber, false)) {
 260         ec = SYNTAX_ERR;
 261         return;
 262     }
 263
 264     SVGLengthType type = stringToLengthType(ptr, end);
 265     ASSERT(ptr <= end);
 266     if (type == LengthTypeUnknown) {
 267         ec = SYNTAX_ERR;
 268         return;
 269     }
 270
 271     m_unit = storeUnit(extractMode(m_unit), type);
 272     m_valueInSpecifiedUnits = convertedNumber;
 273 }
 274
 275 String SVGLength::valueAsString() const
 276 {
 277     return makeString(String::number(m_valueInSpecifiedUnits), lengthTypeToString(extractType(m_unit)));
 278 }
 279
 280 void SVGLength::newValueSpecifiedUnits(unsigned short type, float value, ExceptionCode& ec)
 281 {
 282     if (type == LengthTypeUnknown || type > LengthTypePC) {
 283         ec = NOT_SUPPORTED_ERR;
 284         return;
 285     }
 286
 287     m_unit = storeUnit(extractMode(m_unit), static_cast<SVGLengthType>(type));
 288     m_valueInSpecifiedUnits = value;
 289 }
 290
 291 void SVGLength::convertToSpecifiedUnits(unsigned short type, const SVGElement* context, ExceptionCode& ec)
 292 {
 293     if (type == LengthTypeUnknown || type > LengthTypePC) {
 294         ec = NOT_SUPPORTED_ERR;
 295         return;
 296     }
 297
 298     float valueInUserUnits = value(context, ec);
 299     if (ec)
 300         return;
 301
 302     unsigned int originalUnitAndType = m_unit;
 303     m_unit = storeUnit(extractMode(m_unit), static_cast<SVGLengthType>(type));
 304     setValue(valueInUserUnits, context, ec);
 305     if (!ec)
 306         return;
 307
 308     // Eventually restore old unit and type
 309     m_unit = originalUnitAndType;
 310 }
 311
 312 bool SVGLength::determineViewport(const SVGElement* context, float& width, float& height) const
 313 {
 314     if (!context)
 315         return false;
 316
 317     // Take size from outermost <svg> element.
 318     Document* document = context->document();
 319     if (document->documentElement() == context) {
 320         if (RenderView* view = toRenderView(document->renderer())) {
 321             width = view->viewWidth();
 322             height = view->viewHeight();
 323             return true;
 324         }
 325
 326         return false;
 327     }
 328
 329     // Resolve value against nearest viewport element (common case: inner <svg> elements)
 330     SVGElement* viewportElement = context->viewportElement();
 331     if (viewportElement && viewportElement->isSVG()) {
 332         const SVGSVGElement* svg = static_cast<const SVGSVGElement*>(viewportElement);
 333         if (svg->hasAttribute(SVGNames::viewBoxAttr)) {
 334             width = svg->viewBox().width();
 335             height = svg->viewBox().height();
 336         } else {
 337             width = svg->width().value(svg);
 338             height = svg->height().value(svg);
 339         }
 340
 341         return true;
 342     }
 343
 344     // Resolve value against enclosing non-SVG RenderBox
 345     if (!context->parentNode() || context->parentNode()->isSVGElement())
 346         return false;
 347
 348     RenderObject* renderer = context->renderer();
 349     if (!renderer || !renderer->isBox())
 350         return false;
 351
 352     RenderBox* box = toRenderBox(renderer);
 353     width = box->width();
 354     height = box->height();
 355     return true;
 356 }
 357
 358 float SVGLength::convertValueFromUserUnitsToPercentage(float value, const SVGElement* context, ExceptionCode& ec) const
 359 {
 360     float width = 0;
 361     float height = 0;
 362     if (!determineViewport(context, width, height)) {
 363         ec = NOT_SUPPORTED_ERR;
 364         return 0;
 365     }
 366
 367     switch (extractMode(m_unit)) {
 368     case LengthModeWidth:
 369         return value / width * 100;
 370     case LengthModeHeight:
 371         return value / height * 100;
 372     case LengthModeOther:
 373         return value / (sqrtf((width * width + height * height) / 2)) * 100;
 374     };
 375
 376     ASSERT_NOT_REACHED();
 377     return 0;
 378 }
 379
 380 float SVGLength::convertValueFromPercentageToUserUnits(float value, const SVGElement* context, ExceptionCode& ec) const
 381 {
 382     float width = 0;
 383     float height = 0;
 384     if (!determineViewport(context, width, height)) {
 385         ec = NOT_SUPPORTED_ERR;
 386         return 0;
 387     }
 388
 389     switch (extractMode(m_unit)) {
 390     case LengthModeWidth:
 391         return value * width;
 392     case LengthModeHeight:
 393         return value * height;
 394     case LengthModeOther:
 395         return value * sqrtf((width * width + height * height) / 2);
 396     };
 397
 398     ASSERT_NOT_REACHED();
 399     return 0;
 400 }
 401
 402 float SVGLength::convertValueFromUserUnitsToEMS(float value, const SVGElement* context, ExceptionCode& ec) const
 403 {
 404     if (!context || !context->renderer() || !context->renderer()->style()) {
 405         ec = NOT_SUPPORTED_ERR;
 406         return 0;
 407     }
 408
 409     RenderStyle* style = context->renderer()->style();
 410     float fontSize = style->fontSize();
 411     if (!fontSize) {
 412         ec = NOT_SUPPORTED_ERR;
 413         return 0;
 414     }
 415
 416     return value / fontSize;
 417 }
 418
 419 float SVGLength::convertValueFromEMSToUserUnits(float value, const SVGElement* context, ExceptionCode& ec) const
 420 {
 421     if (!context || !context->renderer() || !context->renderer()->style()) {
 422         ec = NOT_SUPPORTED_ERR;
 423         return 0;
 424     }
 425
 426     RenderStyle* style = context->renderer()->style();
 427     return value * style->fontSize();
 428 }
 429
 430 float SVGLength::convertValueFromUserUnitsToEXS(float value, const SVGElement* context, ExceptionCode& ec) const
 431 {
 432     if (!context || !context->renderer() || !context->renderer()->style()) {
 433         ec = NOT_SUPPORTED_ERR;
 434         return 0;
 435     }
 436
 437     RenderStyle* style = context->renderer()->style();
 438
 439     // Use of ceil allows a pixel match to the W3Cs expected output of coords-units-03-b.svg
 440     // if this causes problems in real world cases maybe it would be best to remove this
 441     float xHeight = ceilf(style->fontMetrics().xHeight());
 442     if (!xHeight) {
 443         ec = NOT_SUPPORTED_ERR;
 444         return 0;
 445     }
 446
 447     return value / xHeight;
 448 }
 449
 450 float SVGLength::convertValueFromEXSToUserUnits(float value, const SVGElement* context, ExceptionCode& ec) const
 451 {
 452     if (!context || !context->renderer() || !context->renderer()->style()) {
 453         ec = NOT_SUPPORTED_ERR;
 454         return 0;
 455     }
 456
 457     RenderStyle* style = context->renderer()->style();
 458     // Use of ceil allows a pixel match to the W3Cs expected output of coords-units-03-b.svg
 459     // if this causes problems in real world cases maybe it would be best to remove this
 460     return value * ceilf(style->fontMetrics().xHeight());
 461 }
 462
 463 SVGLength SVGLength::fromCSSPrimitiveValue(CSSPrimitiveValue* value)
 464 {
 465     ASSERT(value);
 466
 467     SVGLengthType svgType;
 468     switch (value->primitiveType()) {
 469     case CSSPrimitiveValue::CSS_NUMBER:
 470         svgType = LengthTypeNumber;
 471         break;
 472     case CSSPrimitiveValue::CSS_PERCENTAGE:
 473         svgType = LengthTypePercentage;
 474         break;
 475     case CSSPrimitiveValue::CSS_EMS:
 476         svgType = LengthTypeEMS;
 477         break;
 478     case CSSPrimitiveValue::CSS_EXS:
 479         svgType = LengthTypeEXS;
 480         break;
 481     case CSSPrimitiveValue::CSS_PX:
 482         svgType = LengthTypePX;
 483         break;
 484     case CSSPrimitiveValue::CSS_CM:
 485         svgType = LengthTypeCM;
 486         break;
 487     case CSSPrimitiveValue::CSS_MM:
 488         svgType = LengthTypeMM;
 489         break;
 490     case CSSPrimitiveValue::CSS_IN:
 491         svgType = LengthTypeIN;
 492         break;
 493     case CSSPrimitiveValue::CSS_PT:
 494         svgType = LengthTypePT;
 495         break;
 496     case CSSPrimitiveValue::CSS_PC:
 497         svgType = LengthTypePC;
 498         break;
 499     case CSSPrimitiveValue::CSS_UNKNOWN:
 500     default:
 501         svgType = LengthTypeUnknown;
 502         break;
 503     };
 504
 505     if (svgType == LengthTypeUnknown)
 506         return SVGLength();
 507
 508     ExceptionCode ec = 0;
 509     SVGLength length;
 510     length.newValueSpecifiedUnits(svgType, value->getFloatValue(), ec);
 511     if (ec)
 512         return SVGLength();
 513
 514     return length;
 515 }
 516
 517 PassRefPtr<CSSPrimitiveValue> SVGLength::toCSSPrimitiveValue(const SVGLength& length)
 518 {
 519     CSSPrimitiveValue::UnitTypes cssType = CSSPrimitiveValue::CSS_UNKNOWN;
 520     switch (length.unitType()) {
 521     case LengthTypeUnknown:
 522         break;
 523     case LengthTypeNumber:
 524         cssType = CSSPrimitiveValue::CSS_NUMBER;
 525         break;
 526     case LengthTypePercentage:
 527         cssType = CSSPrimitiveValue::CSS_PERCENTAGE;
 528         break;
 529     case LengthTypeEMS:
 530         cssType = CSSPrimitiveValue::CSS_EMS;
 531         break;
 532     case LengthTypeEXS:
 533         cssType = CSSPrimitiveValue::CSS_EXS;
 534         break;
 535     case LengthTypePX:
 536         cssType = CSSPrimitiveValue::CSS_PX;
 537         break;
 538     case LengthTypeCM:
 539         cssType = CSSPrimitiveValue::CSS_CM;
 540         break;
 541     case LengthTypeMM:
 542         cssType = CSSPrimitiveValue::CSS_MM;
 543         break;
 544     case LengthTypeIN:
 545         cssType = CSSPrimitiveValue::CSS_IN;
 546         break;
 547     case LengthTypePT:
 548         cssType = CSSPrimitiveValue::CSS_PT;
 549         break;
 550     case LengthTypePC:
 551         cssType = CSSPrimitiveValue::CSS_PC;
 552         break;
 553     };
 554
 555     return CSSPrimitiveValue::create(length.valueInSpecifiedUnits(), cssType);
 556 }
 557
 558 }
 559
 560 #endif