PassRefPtrWillBeRawPtr<CSSValue> valueForBasicShape(const RenderStyle& style, const BasicShape* basicShape)
{
CSSValuePool& pool = cssValuePool();
RefPtrWillBeRawPtr<CSSBasicShape> basicShapeValue;
switch (basicShape->type()) {
case BasicShape::BasicShapeRectangleType: {
const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
RefPtrWillBeRawPtr<CSSBasicShapeRectangle> rectangleValue = CSSBasicShapeRectangle::create();
rectangleValue->setX(pool.createValue(rectangle->x(), style));
rectangleValue->setY(pool.createValue(rectangle->y(), style));
rectangleValue->setWidth(pool.createValue(rectangle->width(), style));
rectangleValue->setHeight(pool.createValue(rectangle->height(), style));
rectangleValue->setRadiusX(pool.createValue(rectangle->cornerRadiusX(), style));
rectangleValue->setRadiusY(pool.createValue(rectangle->cornerRadiusY(), style));
basicShapeValue = rectangleValue.release();
break;
}
case BasicShape::DeprecatedBasicShapeCircleType: {
const DeprecatedBasicShapeCircle* circle = static_cast<const DeprecatedBasicShapeCircle*>(basicShape);
RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeCircle> circleValue = CSSDeprecatedBasicShapeCircle::create();
circleValue->setCenterX(pool.createValue(circle->centerX(), style));
circleValue->setCenterY(pool.createValue(circle->centerY(), style));
circleValue->setRadius(pool.createValue(circle->radius(), style));
basicShapeValue = circleValue.release();
break;
}
case BasicShape::BasicShapeCircleType: {
const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
RefPtrWillBeRawPtr<CSSBasicShapeCircle> circleValue = CSSBasicShapeCircle::create();
circleValue->setCenterX(valueForCenterCoordinate(pool, style, circle->centerX()));
circleValue->setCenterY(valueForCenterCoordinate(pool, style, circle->centerY()));
circleValue->setRadius(basicShapeRadiusToCSSValue(pool, style, circle->radius()));
basicShapeValue = circleValue.release();
break;
}
case BasicShape::DeprecatedBasicShapeEllipseType: {
const DeprecatedBasicShapeEllipse* ellipse = static_cast<const DeprecatedBasicShapeEllipse*>(basicShape);
RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeEllipse> ellipseValue = CSSDeprecatedBasicShapeEllipse::create();
ellipseValue->setCenterX(pool.createValue(ellipse->centerX(), style));
ellipseValue->setCenterY(pool.createValue(ellipse->centerY(), style));
ellipseValue->setRadiusX(pool.createValue(ellipse->radiusX(), style));
ellipseValue->setRadiusY(pool.createValue(ellipse->radiusY(), style));
basicShapeValue = ellipseValue.release();
break;
}
case BasicShape::BasicShapeEllipseType: {
const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
RefPtrWillBeRawPtr<CSSBasicShapeEllipse> ellipseValue = CSSBasicShapeEllipse::create();
ellipseValue->setCenterX(valueForCenterCoordinate(pool, style, ellipse->centerX()));
ellipseValue->setCenterY(valueForCenterCoordinate(pool, style, ellipse->centerY()));
ellipseValue->setRadiusX(basicShapeRadiusToCSSValue(pool, style, ellipse->radiusX()));
ellipseValue->setRadiusY(basicShapeRadiusToCSSValue(pool, style, ellipse->radiusY()));
basicShapeValue = ellipseValue.release();
break;
}
case BasicShape::BasicShapePolygonType: {
const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(basicShape);
RefPtrWillBeRawPtr<CSSBasicShapePolygon> polygonValue = CSSBasicShapePolygon::create();
polygonValue->setWindRule(polygon->windRule());
const Vector<Length>& values = polygon->values();
for (unsigned i = 0; i < values.size(); i += 2)
polygonValue->appendPoint(pool.createValue(values.at(i), style), pool.createValue(values.at(i + 1), style));
basicShapeValue = polygonValue.release();
break;
}
case BasicShape::BasicShapeInsetRectangleType: {
const BasicShapeInsetRectangle* rectangle = static_cast<const BasicShapeInsetRectangle*>(basicShape);
RefPtrWillBeRawPtr<CSSBasicShapeInsetRectangle> rectangleValue = CSSBasicShapeInsetRectangle::create();
rectangleValue->setTop(cssValuePool().createValue(rectangle->top()));
rectangleValue->setRight(cssValuePool().createValue(rectangle->right()));
rectangleValue->setBottom(cssValuePool().createValue(rectangle->bottom()));
rectangleValue->setLeft(cssValuePool().createValue(rectangle->left()));
rectangleValue->setRadiusX(cssValuePool().createValue(rectangle->cornerRadiusX()));
rectangleValue->setRadiusY(cssValuePool().createValue(rectangle->cornerRadiusY()));
basicShapeValue = rectangleValue.release();
break;
}
case BasicShape::BasicShapeInsetType: {
const BasicShapeInset* inset = static_cast<const BasicShapeInset*>(basicShape);
RefPtrWillBeRawPtr<CSSBasicShapeInset> insetValue = CSSBasicShapeInset::create();
insetValue->setTop(CSSPrimitiveValue::create(inset->top()));
insetValue->setRight(CSSPrimitiveValue::create(inset->right()));
insetValue->setBottom(CSSPrimitiveValue::create(inset->bottom()));
insetValue->setLeft(CSSPrimitiveValue::create(inset->left()));
insetValue->setTopLeftRadius(CSSPrimitiveValue::create(inset->topLeftRadius()));
insetValue->setTopRightRadius(CSSPrimitiveValue::create(inset->topRightRadius()));
insetValue->setBottomRightRadius(CSSPrimitiveValue::create(inset->bottomRightRadius()));
insetValue->setBottomLeftRadius(CSSPrimitiveValue::create(inset->bottomLeftRadius()));
basicShapeValue = insetValue.release();
break;
}
default:
break;
}
if (basicShape->layoutBox() != BoxMissing)
basicShapeValue->setLayoutBox(pool.createValue(basicShape->layoutBox()));
return pool.createValue(basicShapeValue.release());
}
