CSSValue* valueForBasicShape(const ComputedStyle& style, const BasicShape* basicShape)
{
switch (basicShape->type()) {
case BasicShape::BasicShapeCircleType: {
const BasicShapeCircle* circle = toBasicShapeCircle(basicShape);
CSSBasicShapeCircleValue* circleValue = CSSBasicShapeCircleValue::create();
circleValue->setCenterX(valueForCenterCoordinate(style, circle->centerX(), HORIZONTAL));
circleValue->setCenterY(valueForCenterCoordinate(style, circle->centerY(), VERTICAL));
circleValue->setRadius(basicShapeRadiusToCSSValue(style, circle->radius()));
return circleValue;
}
case BasicShape::BasicShapeEllipseType: {
const BasicShapeEllipse* ellipse = toBasicShapeEllipse(basicShape);
CSSBasicShapeEllipseValue* ellipseValue = CSSBasicShapeEllipseValue::create();
ellipseValue->setCenterX(valueForCenterCoordinate(style, ellipse->centerX(), HORIZONTAL));
ellipseValue->setCenterY(valueForCenterCoordinate(style, ellipse->centerY(), VERTICAL));
ellipseValue->setRadiusX(basicShapeRadiusToCSSValue(style, ellipse->radiusX()));
ellipseValue->setRadiusY(basicShapeRadiusToCSSValue(style, ellipse->radiusY()));
return ellipseValue;
}
case BasicShape::BasicShapePolygonType: {
const BasicShapePolygon* polygon = toBasicShapePolygon(basicShape);
CSSBasicShapePolygonValue* polygonValue = CSSBasicShapePolygonValue::create();
polygonValue->setWindRule(polygon->getWindRule());
const Vector<Length>& values = polygon->values();
for (unsigned i = 0; i < values.size(); i += 2)
polygonValue->appendPoint(CSSPrimitiveValue::create(values.at(i), style), CSSPrimitiveValue::create(values.at(i + 1), style));
return polygonValue;
}
case BasicShape::BasicShapeInsetType: {
const BasicShapeInset* inset = toBasicShapeInset(basicShape);
CSSBasicShapeInsetValue* insetValue = CSSBasicShapeInsetValue::create();
insetValue->setTop(CSSPrimitiveValue::create(inset->top(), style));
insetValue->setRight(CSSPrimitiveValue::create(inset->right(), style));
insetValue->setBottom(CSSPrimitiveValue::create(inset->bottom(), style));
insetValue->setLeft(CSSPrimitiveValue::create(inset->left(), style));
insetValue->setTopLeftRadius(CSSValuePair::create(inset->topLeftRadius(), style));
insetValue->setTopRightRadius(CSSValuePair::create(inset->topRightRadius(), style));
insetValue->setBottomRightRadius(CSSValuePair::create(inset->bottomRightRadius(), style));
insetValue->setBottomLeftRadius(CSSValuePair::create(inset->bottomLeftRadius(), style));
return insetValue;
}
default:
return nullptr;
}
}
PassRefPtr<CSSValue> valueForBasicShape(const RenderStyle& style, const BasicShape* basicShape)
{
CSSValuePool& pool = cssValuePool();
RefPtr<CSSBasicShape> basicShapeValue;
switch (basicShape->type()) {
case BasicShape::BasicShapeRectangleType: {
const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
RefPtr<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);
RefPtr<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);
RefPtr<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);
RefPtr<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);
RefPtr<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);
RefPtr<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);
RefPtr<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);
RefPtr<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());
}
PassRefPtr<CSSValue> valueForBasicShape(const RenderStyle* style, const BasicShape* basicShape)
{
CSSValuePool& pool = cssValuePool();
RefPtr<CSSBasicShape> basicShapeValue;
switch (basicShape->type()) {
case BasicShape::BasicShapeCircleType: {
const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
RefPtr<CSSBasicShapeCircle> circleValue = CSSBasicShapeCircle::create();
circleValue->setCenterX(valueForCenterCoordinate(pool, style, circle->centerX(), HORIZONTAL));
circleValue->setCenterY(valueForCenterCoordinate(pool, style, circle->centerY(), VERTICAL));
circleValue->setRadius(basicShapeRadiusToCSSValue(style, pool, circle->radius()));
basicShapeValue = circleValue.release();
break;
}
case BasicShape::BasicShapeEllipseType: {
const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
RefPtr<CSSBasicShapeEllipse> ellipseValue = CSSBasicShapeEllipse::create();
ellipseValue->setCenterX(valueForCenterCoordinate(pool, style, ellipse->centerX(), HORIZONTAL));
ellipseValue->setCenterY(valueForCenterCoordinate(pool, style, ellipse->centerY(), VERTICAL));
ellipseValue->setRadiusX(basicShapeRadiusToCSSValue(style, pool, ellipse->radiusX()));
ellipseValue->setRadiusY(basicShapeRadiusToCSSValue(style, pool, ellipse->radiusY()));
basicShapeValue = ellipseValue.release();
break;
}
case BasicShape::BasicShapePolygonType: {
const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(basicShape);
RefPtr<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::BasicShapeInsetType: {
const BasicShapeInset* inset = static_cast<const BasicShapeInset*>(basicShape);
RefPtr<CSSBasicShapeInset> insetValue = CSSBasicShapeInset::create();
insetValue->setTop(pool.createValue(inset->top()));
insetValue->setRight(pool.createValue(inset->right()));
insetValue->setBottom(pool.createValue(inset->bottom()));
insetValue->setLeft(pool.createValue(inset->left()));
insetValue->setTopLeftRadius(pool.createValue(inset->topLeftRadius()));
insetValue->setTopRightRadius(pool.createValue(inset->topRightRadius()));
insetValue->setBottomRightRadius(pool.createValue(inset->bottomRightRadius()));
insetValue->setBottomLeftRadius(pool.createValue(inset->bottomLeftRadius()));
basicShapeValue = insetValue.release();
break;
}
default:
break;
}
if (basicShape->referenceBox() != BoxMissing)
basicShapeValue->setReferenceBox(pool.createValue(basicShape->referenceBox()));
return pool.createValue(basicShapeValue.release());
}
