PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, const LayoutSize& logicalBoxSize, WritingMode writingMode, Length margin, Length padding)
{
ASSERT(basicShape);
bool horizontalWritingMode = isHorizontalWritingMode(writingMode);
float boxWidth = horizontalWritingMode ? logicalBoxSize.width() : logicalBoxSize.height();
float boxHeight = horizontalWritingMode ? logicalBoxSize.height() : logicalBoxSize.width();
OwnPtr<ExclusionShape> exclusionShape;
switch (basicShape->type()) {
case BasicShape::BasicShapeRectangleType: {
const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
FloatRect bounds(
floatValueForLength(rectangle->x(), boxWidth),
floatValueForLength(rectangle->y(), boxHeight),
floatValueForLength(rectangle->width(), boxWidth),
floatValueForLength(rectangle->height(), boxHeight));
Length radiusXLength = rectangle->cornerRadiusX();
Length radiusYLength = rectangle->cornerRadiusY();
FloatSize cornerRadii(
radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth),
radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight));
FloatRect logicalBounds = physicalRectToLogical(bounds, logicalBoxSize.height(), writingMode);
exclusionShape = createExclusionRectangle(logicalBounds, physicalSizeToLogical(cornerRadii, writingMode));
break;
}
case BasicShape::BasicShapeCircleType: {
const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
float centerX = floatValueForLength(circle->centerX(), boxWidth);
float centerY = floatValueForLength(circle->centerY(), boxHeight);
float radius = floatValueForLength(circle->radius(), std::min(boxHeight, boxWidth));
FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxSize.height(), writingMode);
exclusionShape = createExclusionCircle(logicalCenter, radius);
break;
}
case BasicShape::BasicShapeEllipseType: {
const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
float centerX = floatValueForLength(ellipse->centerX(), boxWidth);
float centerY = floatValueForLength(ellipse->centerY(), boxHeight);
float radiusX = floatValueForLength(ellipse->radiusX(), boxWidth);
float radiusY = floatValueForLength(ellipse->radiusY(), boxHeight);
FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxSize.height(), writingMode);
FloatSize logicalRadii = physicalSizeToLogical(FloatSize(radiusX, radiusY), writingMode);
exclusionShape = createExclusionEllipse(logicalCenter, logicalRadii);
break;
}
case BasicShape::BasicShapePolygonType: {
const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(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(), writingMode);
}
exclusionShape = createExclusionPolygon(vertices.release(), polygon->windRule());
break;
}
case BasicShape::BasicShapeInsetRectangleType: {
const BasicShapeInsetRectangle* rectangle = static_cast<const BasicShapeInsetRectangle*>(basicShape);
float left = floatValueForLength(rectangle->left(), boxWidth);
float top = floatValueForLength(rectangle->top(), boxHeight);
FloatRect bounds(
left,
top,
boxWidth - left - floatValueForLength(rectangle->right(), boxWidth),
boxHeight - top - floatValueForLength(rectangle->bottom(), boxHeight));
Length radiusXLength = rectangle->cornerRadiusX();
Length radiusYLength = rectangle->cornerRadiusY();
FloatSize cornerRadii(
radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth),
radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight));
FloatRect logicalBounds = physicalRectToLogical(bounds, logicalBoxSize.height(), writingMode);
exclusionShape = createExclusionRectangle(logicalBounds, physicalSizeToLogical(cornerRadii, writingMode));
break;
}
default:
ASSERT_NOT_REACHED();
}
exclusionShape->m_writingMode = writingMode;
exclusionShape->m_margin = floatValueForLength(margin, 0);
exclusionShape->m_padding = floatValueForLength(padding, 0);
return exclusionShape.release();
}
PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, float logicalBoxWidth, float logicalBoxHeight, WritingMode writingMode)
{
if (!basicShape)
return nullptr;
bool horizontalWritingMode = isHorizontalWritingMode(writingMode);
float boxWidth = horizontalWritingMode ? logicalBoxWidth : logicalBoxHeight;
float boxHeight = horizontalWritingMode ? logicalBoxHeight : logicalBoxWidth;
OwnPtr<ExclusionShape> exclusionShape;
switch (basicShape->type()) {
case BasicShape::BASIC_SHAPE_RECTANGLE: {
const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
float x = floatValueForLength(rectangle->x(), boxWidth);
float y = floatValueForLength(rectangle->y(), boxHeight);
float width = floatValueForLength(rectangle->width(), boxWidth);
float height = floatValueForLength(rectangle->height(), boxHeight);
Length radiusXLength = rectangle->cornerRadiusX();
Length radiusYLength = rectangle->cornerRadiusY();
float radiusX = radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth);
float radiusY = radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight);
exclusionShape = horizontalWritingMode
? createExclusionRectangle(FloatRect(x, y, width, height), FloatSize(radiusX, radiusY))
: createExclusionRectangle(FloatRect(y, x, height, width), FloatSize(radiusY, radiusX));
break;
}
case BasicShape::BASIC_SHAPE_CIRCLE: {
const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
float centerX = floatValueForLength(circle->centerX(), boxWidth);
float centerY = floatValueForLength(circle->centerY(), boxHeight);
float radius = floatValueForLength(circle->radius(), std::max(boxHeight, boxWidth));
exclusionShape = horizontalWritingMode
? createExclusionCircle(FloatPoint(centerX, centerY), radius)
: createExclusionCircle(FloatPoint(centerY, centerX), radius);
break;
}
case BasicShape::BASIC_SHAPE_ELLIPSE: {
const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
float centerX = floatValueForLength(ellipse->centerX(), boxWidth);
float centerY = floatValueForLength(ellipse->centerY(), boxHeight);
float radiusX = floatValueForLength(ellipse->radiusX(), boxWidth);
float radiusY = floatValueForLength(ellipse->radiusY(), boxHeight);
exclusionShape = horizontalWritingMode
? createExclusionEllipse(FloatPoint(centerX, centerY), FloatSize(radiusX, radiusY))
: createExclusionEllipse(FloatPoint(centerY, centerX), FloatSize(radiusY, radiusX));
break;
}
case BasicShape::BASIC_SHAPE_POLYGON: {
const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(basicShape);
const Vector<Length>& values = polygon->values();
size_t valuesSize = values.size();
ASSERT(!(valuesSize % 2));
Vector<FloatPoint>* vertices = 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] = horizontalWritingMode ? vertex : vertex.transposedPoint();
}
exclusionShape = createExclusionPolygon(adoptPtr(vertices), polygon->windRule());
break;
}
default:
ASSERT_NOT_REACHED();
}
exclusionShape->m_logicalBoxWidth = logicalBoxWidth;
exclusionShape->m_logicalBoxHeight = logicalBoxHeight;
exclusionShape->m_writingMode = writingMode;
return exclusionShape.release();
}
PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, float logicalBoxWidth, float logicalBoxHeight, WritingMode writingMode)
{
ASSERT(basicShape);
bool horizontalWritingMode = isHorizontalWritingMode(writingMode);
float boxWidth = horizontalWritingMode ? logicalBoxWidth : logicalBoxHeight;
float boxHeight = horizontalWritingMode ? logicalBoxHeight : logicalBoxWidth;
OwnPtr<ExclusionShape> exclusionShape;
switch (basicShape->type()) {
case BasicShape::BASIC_SHAPE_RECTANGLE: {
const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
FloatRect bounds(
floatValueForLength(rectangle->x(), boxWidth),
floatValueForLength(rectangle->y(), boxHeight),
floatValueForLength(rectangle->width(), boxWidth),
floatValueForLength(rectangle->height(), boxHeight));
Length radiusXLength = rectangle->cornerRadiusX();
Length radiusYLength = rectangle->cornerRadiusY();
FloatSize cornerRadii(
radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth),
radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight));
FloatRect logicalBounds = physicalRectToLogical(bounds, logicalBoxHeight, writingMode);
exclusionShape = createExclusionRectangle(logicalBounds, physicalSizeToLogical(cornerRadii, writingMode));
exclusionShape->m_boundingBox = logicalBounds;
break;
}
case BasicShape::BASIC_SHAPE_CIRCLE: {
const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
float centerX = floatValueForLength(circle->centerX(), boxWidth);
float centerY = floatValueForLength(circle->centerY(), boxHeight);
float radius = floatValueForLength(circle->radius(), std::max(boxHeight, boxWidth));
FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxHeight, writingMode);
exclusionShape = createExclusionCircle(logicalCenter, radius);
exclusionShape->m_boundingBox = FloatRect(logicalCenter.x() - radius, logicalCenter.y() - radius, radius * 2, radius * 2);
break;
}
case BasicShape::BASIC_SHAPE_ELLIPSE: {
const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
float centerX = floatValueForLength(ellipse->centerX(), boxWidth);
float centerY = floatValueForLength(ellipse->centerY(), boxHeight);
float radiusX = floatValueForLength(ellipse->radiusX(), boxWidth);
float radiusY = floatValueForLength(ellipse->radiusY(), boxHeight);
FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxHeight, writingMode);
FloatSize logicalRadii = physicalSizeToLogical(FloatSize(radiusX, radiusY), writingMode);
exclusionShape = createExclusionEllipse(logicalCenter, logicalRadii);
exclusionShape->m_boundingBox = FloatRect(logicalCenter - logicalRadii, logicalRadii + logicalRadii);
break;
}
case BasicShape::BASIC_SHAPE_POLYGON: {
const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(basicShape);
const Vector<Length>& values = polygon->values();
size_t valuesSize = values.size();
ASSERT(!(valuesSize % 2));
FloatRect boundingBox;
Vector<FloatPoint>* vertices = 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, logicalBoxHeight, writingMode);
if (!i)
boundingBox.setLocation(vertex);
else
boundingBox.extend(vertex);
}
exclusionShape = createExclusionPolygon(adoptPtr(vertices), polygon->windRule());
exclusionShape->m_boundingBox = boundingBox;
break;
}
default:
ASSERT_NOT_REACHED();
}
exclusionShape->m_logicalBoxWidth = logicalBoxWidth;
exclusionShape->m_logicalBoxHeight = logicalBoxHeight;
exclusionShape->m_writingMode = writingMode;
return exclusionShape.release();
}
PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, float logicalBoxWidth, float logicalBoxHeight, WritingMode writingMode)
{
if (!basicShape)
return nullptr;
bool horizontalWritingMode = isHorizontalWritingMode(writingMode);
float boxWidth = horizontalWritingMode ? logicalBoxWidth : logicalBoxHeight;
float boxHeight = horizontalWritingMode ? logicalBoxHeight : logicalBoxWidth;
OwnPtr<ExclusionShape> exclusionShape;
switch (basicShape->type()) {
case BasicShape::BASIC_SHAPE_RECTANGLE: {
const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
float x = floatValueForLength(rectangle->x(), boxWidth);
float y = floatValueForLength(rectangle->y(), boxHeight);
float width = floatValueForLength(rectangle->width(), boxWidth);
float height = floatValueForLength(rectangle->height(), boxHeight);
Length radiusXLength = rectangle->cornerRadiusX();
Length radiusYLength = rectangle->cornerRadiusY();
float radiusX = radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth);
float radiusY = radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight);
exclusionShape = horizontalWritingMode
? createExclusionRectangle(FloatRect(x, y, width, height), FloatSize(radiusX, radiusY))
: createExclusionRectangle(FloatRect(y, x, height, width), FloatSize(radiusY, radiusX));
break;
}
case BasicShape::BASIC_SHAPE_CIRCLE: {
const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
float centerX = floatValueForLength(circle->centerX(), boxWidth);
float centerY = floatValueForLength(circle->centerY(), boxHeight);
float radius = floatValueForLength(circle->radius(), std::max(boxHeight, boxWidth));
exclusionShape = horizontalWritingMode
? createExclusionCircle(FloatPoint(centerX, centerY), radius)
: createExclusionCircle(FloatPoint(centerY, centerX), radius);
break;
}
case BasicShape::BASIC_SHAPE_ELLIPSE: {
const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
float centerX = floatValueForLength(ellipse->centerX(), boxWidth);
float centerY = floatValueForLength(ellipse->centerY(), boxHeight);
float radiusX = floatValueForLength(ellipse->radiusX(), boxWidth);
float radiusY = floatValueForLength(ellipse->radiusY(), boxHeight);
exclusionShape = horizontalWritingMode
? createExclusionEllipse(FloatPoint(centerX, centerY), FloatSize(radiusX, radiusY))
: createExclusionEllipse(FloatPoint(centerY, centerX), FloatSize(radiusY, radiusX));
break;
}
case BasicShape::BASIC_SHAPE_POLYGON:
notImplemented();
default:
ASSERT_NOT_REACHED();
}
exclusionShape->m_logicalBoxWidth = logicalBoxWidth;
exclusionShape->m_logicalBoxHeight = logicalBoxHeight;
exclusionShape->m_writingMode = writingMode;
return exclusionShape.release();
}
