Layout support for new circle shape syntax

Source/core/rendering/style/BasicShapes.cpp

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 10 matching lines @@
  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include "config.h"
+#include "core/rendering/style/BasicShapes.h"
 
-#include "core/rendering/style/BasicShapes.h"
+#include "core/css/BasicShapeFunctions.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/Path.h"
 
 namespace WebCore {
 
 bool BasicShape::canBlend(const BasicShape* other) const
 {
     // FIXME: Support animations between different shapes in the future.
     if (!other || !isSameType(*other))
         return false;
 
     // Just polygons with same number of vertices can be animated.
     if (type() == BasicShape::BasicShapePolygonType
         && static_cast<const BasicShapePolygon*>(this)->values().size() != static_cast<const BasicShapePolygon*>(other)->values().size())
         return false;
 
+    // Circles with keywords for radii or center coordinates cannot be animated.
+    if (type() == BasicShape::BasicShapeCircleType) {
+        const BasicShapeCircle* thisCircle = static_cast<const BasicShapeCircle*>(this);
+        const BasicShapeCircle* otherCircle = static_cast<const BasicShapeCircle*>(other);
+        if (!thisCircle->radius().canBlend(otherCircle->radius())
+            || !thisCircle->centerX().canBlend(otherCircle->centerX())
+            || !thisCircle->centerY().canBlend(otherCircle->centerY()))
+            return false;
+    }
+
     return true;
 }
 
 void BasicShapeRectangle::path(Path& path, const FloatRect& boundingBox)
 {
     ASSERT(path.isEmpty());
     path.addRoundedRect(
         FloatRect(
             floatValueForLength(m_x, boundingBox.width()) + boundingBox.x(),
             floatValueForLength(m_y, boundingBox.height()) + boundingBox.y(),
@@ skipping 34 matching lines @@
 {
     if (!isSameType(o))
         return false;
     const DeprecatedBasicShapeCircle& other = toDeprecatedBasicShapeCircle(o);
     return m_centerX == other.m_centerX && m_centerY == other.m_centerY && m_radius == other.m_radius;
 }
 
 void DeprecatedBasicShapeCircle::path(Path& path, const FloatRect& boundingBox)
 {
     ASSERT(path.isEmpty());
-    float diagonal = sqrtf((boundingBox.width() * boundingBox.width() + boundingBox.height() * boundingBox.height()) / 2);
+    float diagonal = hypotf(boundingBox.width(), boundingBox.height()) / sqrtf(2);
     float centerX = floatValueForLength(m_centerX, boundingBox.width());
     float centerY = floatValueForLength(m_centerY, boundingBox.height());
     float radius = floatValueForLength(m_radius, diagonal);
     path.addEllipse(FloatRect(
         centerX - radius + boundingBox.x(),
         centerY - radius + boundingBox.y(),
         radius * 2,
         radius * 2
     ));
 }
@@ skipping 11 matching lines @@
 }
 
 bool BasicShapeCircle::operator==(const BasicShape& o) const
 {
     if (!isSameType(o))
         return false;
     const BasicShapeCircle& other = toBasicShapeCircle(o);
     return m_centerX == other.m_centerX && m_centerY == other.m_centerY && m_radius == other.m_radius;
 }
 
+float BasicShapeCircle::floatValueForRadiusInBox(FloatSize boxSize) const
+{
+    if (m_radius.type() == BasicShapeRadius::Value)
+        return floatValueForLength(m_radius.value(), hypotf(boxSize.width(), boxSize.height()) / sqrtf(2));
+
+    FloatPoint center = floatPointForCenterCoordinate(m_centerX, m_centerY, boxSize);
+
+    if (m_radius.type() == BasicShapeRadius::ClosestSide)
+        return std::min(std::min(center.x(), boxSize.width() - center.x()), std::min(center.y(), boxSize.height() - center.y()));
+
+    // If radius.type() == BasicShapeRadius::FarthestSide.
+    return std::max(std::max(center.x(), boxSize.width() - center.x()), std::max(center.y(), boxSize.height() - center.y()));
+}
+
 void BasicShapeCircle::path(Path& path, const FloatRect& boundingBox)
 {
     ASSERT(path.isEmpty());
-    // FIXME Complete implementation of path.
-    // Compute closest-side and farthest-side from boundingBox.
-    // Compute top, left, bottom, right from boundingBox.
-    if (m_radius.type() != BasicShapeRadius::Value)
-        return;
-    if (m_centerX.keyword() != BasicShapeCenterCoordinate::None || m_centerY.keyword() != BasicShapeCenterCoordinate::None)
-        return;
-
-    float diagonal = sqrtf((boundingBox.width() * boundingBox.width() + boundingBox.height() * boundingBox.height()) / 2);
-    float centerX = floatValueForLength(m_centerX.length(), boundingBox.width());
-    float centerY = floatValueForLength(m_centerY.length(), boundingBox.height());
-    float radius = floatValueForLength(m_radius.value(), diagonal);
+    FloatPoint center = floatPointForCenterCoordinate(m_centerX, m_centerY, boundingBox.size());
+    float radius = floatValueForRadiusInBox(boundingBox.size());
     path.addEllipse(FloatRect(
-        centerX - radius + boundingBox.x(),
-        centerY - radius + boundingBox.y(),
+        center.x() - radius + boundingBox.x(),
+        center.y() - radius + boundingBox.y(),
         radius * 2,
         radius * 2
     ));
 }
 
 PassRefPtr<BasicShape> BasicShapeCircle::blend(const BasicShape* other, double progress) const
 {
     ASSERT(type() == other->type());
     const BasicShapeCircle* o = static_cast<const BasicShapeCircle*>(other);
     RefPtr<BasicShapeCircle> result =  BasicShapeCircle::create();
 
-    if (m_radius.type() != BasicShapeRadius::Value || o->radius().type() != BasicShapeRadius::Value) {
-        result->setCenterX(o->centerX());
-        result->setCenterY(o->centerY());
-        result->setRadius(o->radius());
-        return result;
-    }
-
     result->setCenterX(m_centerX.blend(o->centerX(), progress));
     result->setCenterY(m_centerY.blend(o->centerY(), progress));
     result->setRadius(m_radius.blend(o->radius(), progress));
     return result.release();
 }
 
 void DeprecatedBasicShapeEllipse::path(Path& path, const FloatRect& boundingBox)
 {
     ASSERT(path.isEmpty());
     float centerX = floatValueForLength(m_centerX, boundingBox.width());
@@ skipping 41 matching lines @@
 {
     ASSERT(path.isEmpty());
     // FIXME Complete implementation of path. Bug 124619.
     // Compute closest-side and farthest-side from boundingBox.
     // Compute top, left, bottom, right from boundingBox.
     if (m_radiusX.type() != BasicShapeRadius::Value || m_radiusY.type() != BasicShapeRadius::Value)
         return;
     if (m_centerX.keyword() != BasicShapeCenterCoordinate::None || m_centerY.keyword() != BasicShapeCenterCoordinate::None)
         return;
 
-    float diagonal = sqrtf((boundingBox.width() * boundingBox.width() + boundingBox.height() * boundingBox.height()) / 2);
+    float diagonal = hypotf(boundingBox.width(), boundingBox.height()) / sqrtf(2);
     float centerX = floatValueForLength(m_centerX.length(), boundingBox.width());
     float centerY = floatValueForLength(m_centerY.length(), boundingBox.height());
     float radiusX = floatValueForLength(m_radiusX.value(), diagonal);
     float radiusY = floatValueForLength(m_radiusY.value(), diagonal);
     path.addEllipse(FloatRect(
         centerX - radiusX + boundingBox.x(),
         centerY - radiusY + boundingBox.y(),
         radiusX * 2,
         radiusY * 2
     ));
@@ skipping 105 matching lines @@
 }
 
 bool BasicShapeInsetRectangle::operator==(const BasicShape& o) const
 {
     if (!isSameType(o))
         return false;
     const BasicShapeInsetRectangle& other = toBasicShapeInsetRectangle(o);
     return m_right == other.m_right && m_top == other.m_top && m_bottom == other.m_bottom && m_left == other.m_left && m_cornerRadiusX == other.m_cornerRadiusX && m_cornerRadiusY == other.m_cornerRadiusY;
 }
 }