void BasicShapeCircle::path(Path& path, const FloatRect& boundingBox)
{
ASSERT(path.isEmpty());
FloatPoint center = floatPointForCenterCoordinate(m_centerX, m_centerY, boundingBox.size());
float radius = floatValueForRadiusInBox(boundingBox.size());
path.addEllipse(FloatRect(
center.x() - radius + boundingBox.x(),
center.y() - radius + boundingBox.y(),
radius * 2,
radius * 2
));
}
void BasicShapeEllipse::path(Path& path, const FloatRect& boundingBox)
{
ASSERT(path.isEmpty());
FloatPoint center = floatPointForCenterCoordinate(m_centerX, m_centerY, boundingBox.size());
float radiusX = floatValueForRadiusInBox(m_radiusX, center.x(), boundingBox.width());
float radiusY = floatValueForRadiusInBox(m_radiusY, center.y(), boundingBox.height());
path.addEllipse(FloatRect(
center.x() - radiusX + boundingBox.x(),
center.y() - radiusY + boundingBox.y(),
radiusX * 2,
radiusY * 2
));
}
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);
float widthDelta = std::abs(boxSize.width() - center.x());
float heightDelta = std::abs(boxSize.height() - center.y());
if (m_radius.type() == BasicShapeRadius::ClosestSide)
return std::min(std::min(std::abs(center.x()), widthDelta), std::min(std::abs(center.y()), heightDelta));
// If radius.type() == BasicShapeRadius::FarthestSide.
return std::max(std::max(center.x(), widthDelta), std::max(center.y(), heightDelta));
}
PassOwnPtr<Shape> Shape::createShape(const BasicShape* basicShape, const LayoutSize& logicalBoxSize, WritingMode writingMode, float margin)
{
ASSERT(basicShape);
bool horizontalWritingMode = isHorizontalWritingMode(writingMode);
float boxWidth = horizontalWritingMode ? logicalBoxSize.width().toFloat() : logicalBoxSize.height().toFloat();
float boxHeight = horizontalWritingMode ? logicalBoxSize.height().toFloat() : logicalBoxSize.width().toFloat();
OwnPtr<Shape> shape;
switch (basicShape->type()) {
case BasicShape::BasicShapeCircleType: {
const BasicShapeCircle* circle = toBasicShapeCircle(basicShape);
FloatPoint center = floatPointForCenterCoordinate(circle->centerX(), circle->centerY(), FloatSize(boxWidth, boxHeight));
float radius = circle->floatValueForRadiusInBox(FloatSize(boxWidth, boxHeight));
FloatPoint logicalCenter = physicalPointToLogical(center, logicalBoxSize.height().toFloat(), writingMode);
shape = createCircleShape(logicalCenter, radius);
break;
}
case BasicShape::BasicShapeEllipseType: {
const BasicShapeEllipse* ellipse = toBasicShapeEllipse(basicShape);
FloatPoint center = floatPointForCenterCoordinate(ellipse->centerX(), ellipse->centerY(), FloatSize(boxWidth, boxHeight));
float radiusX = ellipse->floatValueForRadiusInBox(ellipse->radiusX(), center.x(), boxWidth);
float radiusY = ellipse->floatValueForRadiusInBox(ellipse->radiusY(), center.y(), boxHeight);
FloatPoint logicalCenter = physicalPointToLogical(center, logicalBoxSize.height().toFloat(), writingMode);
shape = createEllipseShape(logicalCenter, FloatSize(radiusX, radiusY));
break;
}
case BasicShape::BasicShapePolygonType: {
const BasicShapePolygon* polygon = toBasicShapePolygon(basicShape);
const Vector<Length>& values = polygon->values();
size_t valuesSize = values.size();
ASSERT(!(valuesSize % 2));
OwnPtr<Vector<FloatPoint>> vertices = adoptPtr(new Vector<FloatPoint>(valuesSize / 2));
for (unsigned i = 0; i < valuesSize; i += 2) {
FloatPoint vertex(
floatValueForLength(values.at(i), boxWidth),
floatValueForLength(values.at(i + 1), boxHeight));
(*vertices)[i / 2] = physicalPointToLogical(vertex, logicalBoxSize.height().toFloat(), writingMode);
}
shape = createPolygonShape(vertices.release(), polygon->windRule());
break;
}
case BasicShape::BasicShapeInsetType: {
const BasicShapeInset& inset = *toBasicShapeInset(basicShape);
float left = floatValueForLength(inset.left(), boxWidth);
float top = floatValueForLength(inset.top(), boxHeight);
float right = floatValueForLength(inset.right(), boxWidth);
float bottom = floatValueForLength(inset.bottom(), boxHeight);
FloatRect rect(left, top, std::max<float>(boxWidth - left - right, 0), std::max<float>(boxHeight - top - bottom, 0));
FloatRect logicalRect = physicalRectToLogical(rect, logicalBoxSize.height().toFloat(), writingMode);
FloatSize boxSize(boxWidth, boxHeight);
FloatSize topLeftRadius = physicalSizeToLogical(floatSizeForLengthSize(inset.topLeftRadius(), boxSize), writingMode);
FloatSize topRightRadius = physicalSizeToLogical(floatSizeForLengthSize(inset.topRightRadius(), boxSize), writingMode);
FloatSize bottomLeftRadius = physicalSizeToLogical(floatSizeForLengthSize(inset.bottomLeftRadius(), boxSize), writingMode);
FloatSize bottomRightRadius = physicalSizeToLogical(floatSizeForLengthSize(inset.bottomRightRadius(), boxSize), writingMode);
FloatRoundedRect::Radii cornerRadii(topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius);
FloatRoundedRect finalRect(logicalRect, cornerRadii);
finalRect.constrainRadii();
shape = createInsetShape(finalRect);
break;
}
default:
ASSERT_NOT_REACHED();
}
shape->m_writingMode = writingMode;
shape->m_margin = margin;
return shape.release();
}
