src/third_party/WebKit/Source/core/css/CSSBasicShapes.cpp

   1 /*
   2  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above
   9  *    copyright notice, this list of conditions and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above
  12  *    copyright notice, this list of conditions and the following
  13  *    disclaimer in the documentation and/or other materials
  14  *    provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include "config.h"
  31 #include "core/css/CSSBasicShapes.h"
  32
  33 #include "core/css/CSSValuePool.h"
  34 #include "core/css/Pair.h"
  35 #include "platform/Length.h"
  36 #include "wtf/text/StringBuilder.h"
  37
  38 using namespace WTF;
  39
  40 namespace blink {
  41
  42 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CSSBasicShape)
  43
  44 static String buildCircleString(const String& radius, const String& centerX, const String& centerY, const String& box)
  45 {
  46     char at[] = "at";
  47     char separator[] = " ";
  48     StringBuilder result;
  49     result.appendLiteral("circle(");
  50     if (!radius.isNull())
  51         result.append(radius);
  52
  53     if (!centerX.isNull() || !centerY.isNull()) {
  54         if (!radius.isNull())
  55             result.appendLiteral(separator);
  56         result.append(at);
  57         result.appendLiteral(separator);
  58         result.append(centerX);
  59         result.appendLiteral(separator);
  60         result.append(centerY);
  61     }
  62     result.append(")");
  63     if (box.length()) {
  64         result.appendLiteral(separator);
  65         result.append(box);
  66     }
  67     return result.toString();
  68 }
  69
  70 static String serializePositionOffset(const Pair& offset, const Pair& other)
  71 {
  72     if ((offset.first()->getValueID() == CSSValueLeft && other.first()->getValueID() == CSSValueTop)
  73         || (offset.first()->getValueID() == CSSValueTop && other.first()->getValueID() == CSSValueLeft))
  74         return offset.second()->cssText();
  75     return offset.cssText();
  76 }
  77
  78 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> buildSerializablePositionOffset(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> offset, CSSValueID defaultSide)
  79 {
  80     CSSValueID side = defaultSide;
  81     RefPtrWillBeRawPtr<CSSPrimitiveValue> amount = nullptr;
  82
  83     if (!offset) {
  84         side = CSSValueCenter;
  85     } else if (offset->isValueID()) {
  86         side = offset->getValueID();
  87     } else if (Pair* pair = offset->getPairValue()) {
  88         side = pair->first()->getValueID();
  89         amount = pair->second();
  90     } else {
  91         amount = offset;
  92     }
  93
  94     if (side == CSSValueCenter) {
  95         side = defaultSide;
  96         amount = cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
  97     } else if ((side == CSSValueRight || side == CSSValueBottom)
  98         && amount->isPercentage()) {
  99         side = defaultSide;
 100         amount = cssValuePool().createValue(100 - amount->getFloatValue(), CSSPrimitiveValue::CSS_PERCENTAGE);
 101     } else if (amount->isLength() && !amount->getFloatValue()) {
 102         if (side == CSSValueRight || side == CSSValueBottom)
 103             amount = cssValuePool().createValue(100, CSSPrimitiveValue::CSS_PERCENTAGE);
 104         else
 105             amount = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PERCENTAGE);
 106         side = defaultSide;
 107     }
 108
 109     return cssValuePool().createValue(Pair::create(cssValuePool().createValue(side), amount.release(), Pair::KeepIdenticalValues));
 110 }
 111
 112 String CSSBasicShapeCircle::cssText() const
 113 {
 114     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
 115     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 116
 117     String radius;
 118     if (m_radius && m_radius->getValueID() != CSSValueClosestSide)
 119         radius = m_radius->cssText();
 120
 121     return buildCircleString(radius,
 122         serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
 123         serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()),
 124         m_referenceBox ? m_referenceBox->cssText() : String());
 125 }
 126
 127 bool CSSBasicShapeCircle::equals(const CSSBasicShape& shape) const
 128 {
 129     if (shape.type() != CSSBasicShapeCircleType)
 130         return false;
 131
 132     const CSSBasicShapeCircle& other = static_cast<const CSSBasicShapeCircle&>(shape);
 133     return compareCSSValuePtr(m_centerX, other.m_centerX)
 134         && compareCSSValuePtr(m_centerY, other.m_centerY)
 135         && compareCSSValuePtr(m_radius, other.m_radius)
 136         && compareCSSValuePtr(m_referenceBox, other.m_referenceBox);
 137 }
 138
 139 void CSSBasicShapeCircle::trace(Visitor* visitor)
 140 {
 141     visitor->trace(m_centerX);
 142     visitor->trace(m_centerY);
 143     visitor->trace(m_radius);
 144     CSSBasicShape::trace(visitor);
 145 }
 146
 147 static String buildEllipseString(const String& radiusX, const String& radiusY, const String& centerX, const String& centerY, const String& box)
 148 {
 149     char at[] = "at";
 150     char separator[] = " ";
 151     StringBuilder result;
 152     result.appendLiteral("ellipse(");
 153     bool needsSeparator = false;
 154     if (!radiusX.isNull()) {
 155         result.append(radiusX);
 156         needsSeparator = true;
 157     }
 158     if (!radiusY.isNull()) {
 159         if (needsSeparator)
 160             result.appendLiteral(separator);
 161         result.append(radiusY);
 162         needsSeparator = true;
 163     }
 164
 165     if (!centerX.isNull() || !centerY.isNull()) {
 166         if (needsSeparator)
 167             result.appendLiteral(separator);
 168         result.appendLiteral(at);
 169         result.appendLiteral(separator);
 170         result.append(centerX);
 171         result.appendLiteral(separator);
 172         result.append(centerY);
 173     }
 174     result.append(")");
 175     if (box.length()) {
 176         result.appendLiteral(separator);
 177         result.append(box);
 178     }
 179     return result.toString();
 180 }
 181
 182 String CSSBasicShapeEllipse::cssText() const
 183 {
 184     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
 185     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 186
 187     String radiusX;
 188     String radiusY;
 189     if (m_radiusX) {
 190         bool shouldSerializeRadiusXValue = m_radiusX->getValueID() != CSSValueClosestSide;
 191         bool shouldSerializeRadiusYValue = false;
 192
 193         if (m_radiusY) {
 194             shouldSerializeRadiusYValue = m_radiusY->getValueID() != CSSValueClosestSide;
 195             if (shouldSerializeRadiusYValue)
 196                 radiusY = m_radiusY->cssText();
 197         }
 198         if (shouldSerializeRadiusXValue || (!shouldSerializeRadiusXValue && shouldSerializeRadiusYValue))
 199             radiusX = m_radiusX->cssText();
 200     }
 201
 202     return buildEllipseString(radiusX, radiusY,
 203         serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
 204         serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()),
 205         m_referenceBox ? m_referenceBox->cssText() : String());
 206 }
 207
 208 bool CSSBasicShapeEllipse::equals(const CSSBasicShape& shape) const
 209 {
 210     if (shape.type() != CSSBasicShapeEllipseType)
 211         return false;
 212
 213     const CSSBasicShapeEllipse& other = static_cast<const CSSBasicShapeEllipse&>(shape);
 214     return compareCSSValuePtr(m_centerX, other.m_centerX)
 215         && compareCSSValuePtr(m_centerY, other.m_centerY)
 216         && compareCSSValuePtr(m_radiusX, other.m_radiusX)
 217         && compareCSSValuePtr(m_radiusY, other.m_radiusY)
 218         && compareCSSValuePtr(m_referenceBox, other.m_referenceBox);
 219 }
 220
 221 void CSSBasicShapeEllipse::trace(Visitor* visitor)
 222 {
 223     visitor->trace(m_centerX);
 224     visitor->trace(m_centerY);
 225     visitor->trace(m_radiusX);
 226     visitor->trace(m_radiusY);
 227     CSSBasicShape::trace(visitor);
 228 }
 229
 230 static String buildPolygonString(const WindRule& windRule, const Vector<String>& points, const String& box)
 231 {
 232     ASSERT(!(points.size() % 2));
 233
 234     StringBuilder result;
 235     const char evenOddOpening[] = "polygon(evenodd, ";
 236     const char nonZeroOpening[] = "polygon(";
 237     const char commaSeparator[] = ", ";
 238     COMPILE_ASSERT(sizeof(evenOddOpening) > sizeof(nonZeroOpening), polygon_string_openings_have_same_length);
 239
 240     // Compute the required capacity in advance to reduce allocations.
 241     size_t length = sizeof(evenOddOpening) - 1;
 242     for (size_t i = 0; i < points.size(); i += 2) {
 243         if (i)
 244             length += (sizeof(commaSeparator) - 1);
 245         // add length of two strings, plus one for the space separator.
 246         length += points[i].length() + 1 + points[i + 1].length();
 247     }
 248     if (!box.isEmpty())
 249         length += box.length() + 1;
 250     result.reserveCapacity(length);
 251
 252     if (windRule == RULE_EVENODD)
 253         result.appendLiteral(evenOddOpening);
 254     else
 255         result.appendLiteral(nonZeroOpening);
 256
 257     for (size_t i = 0; i < points.size(); i += 2) {
 258         if (i)
 259             result.appendLiteral(commaSeparator);
 260         result.append(points[i]);
 261         result.append(' ');
 262         result.append(points[i + 1]);
 263     }
 264
 265     result.append(')');
 266
 267     if (!box.isEmpty()) {
 268         result.append(' ');
 269         result.append(box);
 270     }
 271
 272     return result.toString();
 273 }
 274
 275 String CSSBasicShapePolygon::cssText() const
 276 {
 277     Vector<String> points;
 278     points.reserveInitialCapacity(m_values.size());
 279
 280     for (size_t i = 0; i < m_values.size(); ++i)
 281         points.append(m_values.at(i)->cssText());
 282
 283     return buildPolygonString(m_windRule, points, m_referenceBox ? m_referenceBox->cssText() : String());
 284 }
 285
 286 bool CSSBasicShapePolygon::equals(const CSSBasicShape& shape) const
 287 {
 288     if (shape.type() != CSSBasicShapePolygonType)
 289         return false;
 290
 291     const CSSBasicShapePolygon& rhs = static_cast<const CSSBasicShapePolygon&>(shape);
 292
 293     if (!compareCSSValuePtr(m_referenceBox, rhs.m_referenceBox))
 294         return false;
 295
 296     return compareCSSValueVector(m_values, rhs.m_values);
 297 }
 298
 299 void CSSBasicShapePolygon::trace(Visitor* visitor)
 300 {
 301     visitor->trace(m_values);
 302     CSSBasicShape::trace(visitor);
 303 }
 304
 305 static bool buildInsetRadii(Vector<String> &radii, const String& topLeftRadius, const String& topRightRadius, const String& bottomRightRadius, const String& bottomLeftRadius)
 306 {
 307     bool showBottomLeft = topRightRadius != bottomLeftRadius;
 308     bool showBottomRight = showBottomLeft || (bottomRightRadius != topLeftRadius);
 309     bool showTopRight = showBottomRight || (topRightRadius != topLeftRadius);
 310
 311     radii.append(topLeftRadius);
 312     if (showTopRight)
 313         radii.append(topRightRadius);
 314     if (showBottomRight)
 315         radii.append(bottomRightRadius);
 316     if (showBottomLeft)
 317         radii.append(bottomLeftRadius);
 318
 319     return radii.size() == 1 && radii[0] == "0px";
 320 }
 321
 322 static String buildInsetString(const String& top, const String& right, const String& bottom, const String& left,
 323     const String& topLeftRadiusWidth, const String& topLeftRadiusHeight,
 324     const String& topRightRadiusWidth, const String& topRightRadiusHeight,
 325     const String& bottomRightRadiusWidth, const String& bottomRightRadiusHeight,
 326     const String& bottomLeftRadiusWidth, const String& bottomLeftRadiusHeight)
 327 {
 328     char opening[] = "inset(";
 329     char separator[] = " ";
 330     char cornersSeparator[] = "round";
 331     StringBuilder result;
 332     result.appendLiteral(opening);
 333     result.append(top);
 334     bool showLeftArg = !left.isNull() && left != right;
 335     bool showBottomArg = !bottom.isNull() && (bottom != top || showLeftArg);
 336     bool showRightArg = !right.isNull() && (right != top || showBottomArg);
 337     if (showRightArg) {
 338         result.appendLiteral(separator);
 339         result.append(right);
 340     }
 341     if (showBottomArg) {
 342         result.appendLiteral(separator);
 343         result.append(bottom);
 344     }
 345     if (showLeftArg) {
 346         result.appendLiteral(separator);
 347         result.append(left);
 348     }
 349
 350     if (!topLeftRadiusWidth.isNull() && !topLeftRadiusHeight.isNull()) {
 351         Vector<String> horizontalRadii;
 352         bool areDefaultCornerRadii = buildInsetRadii(horizontalRadii, topLeftRadiusWidth, topRightRadiusWidth, bottomRightRadiusWidth, bottomLeftRadiusWidth);
 353
 354         Vector<String> verticalRadii;
 355         areDefaultCornerRadii &= buildInsetRadii(verticalRadii, topLeftRadiusHeight, topRightRadiusHeight, bottomRightRadiusHeight, bottomLeftRadiusHeight);
 356
 357         if (!areDefaultCornerRadii) {
 358             result.appendLiteral(separator);
 359             result.appendLiteral(cornersSeparator);
 360
 361             for (size_t i = 0; i < horizontalRadii.size(); ++i) {
 362                 result.appendLiteral(separator);
 363                 result.append(horizontalRadii[i]);
 364             }
 365             if (horizontalRadii != verticalRadii) {
 366                 result.appendLiteral(separator);
 367                 result.appendLiteral("/");
 368
 369                 for (size_t i = 0; i < verticalRadii.size(); ++i) {
 370                     result.appendLiteral(separator);
 371                     result.append(verticalRadii[i]);
 372                 }
 373             }
 374         }
 375     }
 376     result.append(')');
 377
 378     return result.toString();
 379 }
 380
 381 static inline void updateCornerRadiusWidthAndHeight(CSSPrimitiveValue* corner, String& width, String& height)
 382 {
 383     if (!corner)
 384         return;
 385
 386     Pair* radius = corner->getPairValue();
 387     width = radius->first() ? radius->first()->cssText() : String("0");
 388     if (radius->second())
 389         height = radius->second()->cssText();
 390 }
 391
 392 String CSSBasicShapeInset::cssText() const
 393 {
 394     String topLeftRadiusWidth;
 395     String topLeftRadiusHeight;
 396     String topRightRadiusWidth;
 397     String topRightRadiusHeight;
 398     String bottomRightRadiusWidth;
 399     String bottomRightRadiusHeight;
 400     String bottomLeftRadiusWidth;
 401     String bottomLeftRadiusHeight;
 402
 403     updateCornerRadiusWidthAndHeight(topLeftRadius(), topLeftRadiusWidth, topLeftRadiusHeight);
 404     updateCornerRadiusWidthAndHeight(topRightRadius(), topRightRadiusWidth, topRightRadiusHeight);
 405     updateCornerRadiusWidthAndHeight(bottomRightRadius(), bottomRightRadiusWidth, bottomRightRadiusHeight);
 406     updateCornerRadiusWidthAndHeight(bottomLeftRadius(), bottomLeftRadiusWidth, bottomLeftRadiusHeight);
 407
 408     return buildInsetString(m_top ? m_top->cssText() : String(),
 409         m_right ? m_right->cssText() : String(),
 410         m_bottom ? m_bottom->cssText() : String(),
 411         m_left ? m_left->cssText() : String(),
 412         topLeftRadiusWidth,
 413         topLeftRadiusHeight,
 414         topRightRadiusWidth,
 415         topRightRadiusHeight,
 416         bottomRightRadiusWidth,
 417         bottomRightRadiusHeight,
 418         bottomLeftRadiusWidth,
 419         bottomLeftRadiusHeight);
 420 }
 421
 422 bool CSSBasicShapeInset::equals(const CSSBasicShape& shape) const
 423 {
 424     if (shape.type() != CSSBasicShapeInsetType)
 425         return false;
 426
 427     const CSSBasicShapeInset& other = static_cast<const CSSBasicShapeInset&>(shape);
 428     return compareCSSValuePtr(m_top, other.m_top)
 429         && compareCSSValuePtr(m_right, other.m_right)
 430         && compareCSSValuePtr(m_bottom, other.m_bottom)
 431         && compareCSSValuePtr(m_left, other.m_left)
 432         && compareCSSValuePtr(m_topLeftRadius, other.m_topLeftRadius)
 433         && compareCSSValuePtr(m_topRightRadius, other.m_topRightRadius)
 434         && compareCSSValuePtr(m_bottomRightRadius, other.m_bottomRightRadius)
 435         && compareCSSValuePtr(m_bottomLeftRadius, other.m_bottomLeftRadius);
 436 }
 437
 438 void CSSBasicShapeInset::trace(Visitor* visitor)
 439 {
 440     visitor->trace(m_top);
 441     visitor->trace(m_right);
 442     visitor->trace(m_bottom);
 443     visitor->trace(m_left);
 444     visitor->trace(m_topLeftRadius);
 445     visitor->trace(m_topRightRadius);
 446     visitor->trace(m_bottomRightRadius);
 447     visitor->trace(m_bottomLeftRadius);
 448     CSSBasicShape::trace(visitor);
 449 }
 450
 451 } // namespace blink
 452