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(); }