static LengthSize convertToLengthSize(const StyleResolverState& state, CSSValuePair* value)
{
if (!value)
return LengthSize(Length(0, Fixed), Length(0, Fixed));
return LengthSize(convertToLength(state, &toCSSPrimitiveValue(value->first())), convertToLength(state, &toCSSPrimitiveValue(value->second())));
}
static BasicShapeCenterCoordinate convertToCenterCoordinate(const StyleResolverState& state, CSSPrimitiveValue* value)
{
if (Pair* pair = value->getPairValue()) {
BasicShapeCenterCoordinate::Keyword keyword = BasicShapeCenterCoordinate::None;
switch (pair->first()->getValueID()) {
case CSSValueTop:
keyword = BasicShapeCenterCoordinate::Top;
break;
case CSSValueRight:
keyword = BasicShapeCenterCoordinate::Right;
break;
case CSSValueBottom:
keyword = BasicShapeCenterCoordinate::Bottom;
break;
case CSSValueLeft:
keyword = BasicShapeCenterCoordinate::Left;
break;
default:
ASSERT_NOT_REACHED();
break;
}
return BasicShapeCenterCoordinate(keyword, convertToLength(state, pair->second()));
}
return BasicShapeCenterCoordinate(convertToLength(state, value));
}
static LengthSize convertToLengthSize(const StyleResolverState& state, CSSPrimitiveValue* value)
{
if (!value)
return LengthSize(Length(0, Fixed), Length(0, Fixed));
Pair* pair = value->getPairValue();
return LengthSize(convertToLength(state, pair->first()), convertToLength(state, pair->second()));
}
static BasicShapeCenterCoordinate convertToCenterCoordinate(
const StyleResolverState& state,
CSSValue* value) {
BasicShapeCenterCoordinate::Direction direction;
Length offset = Length(0, Fixed);
CSSValueID keyword = CSSValueTop;
if (!value) {
keyword = CSSValueCenter;
} else if (value->isIdentifierValue()) {
keyword = toCSSIdentifierValue(value)->getValueID();
} else if (value->isValuePair()) {
keyword = toCSSIdentifierValue(toCSSValuePair(value)->first()).getValueID();
offset = convertToLength(
state, &toCSSPrimitiveValue(toCSSValuePair(value)->second()));
} else {
offset = convertToLength(state, toCSSPrimitiveValue(value));
}
switch (keyword) {
case CSSValueTop:
case CSSValueLeft:
direction = BasicShapeCenterCoordinate::TopLeft;
break;
case CSSValueRight:
case CSSValueBottom:
direction = BasicShapeCenterCoordinate::BottomRight;
break;
case CSSValueCenter:
direction = BasicShapeCenterCoordinate::TopLeft;
offset = Length(50, Percent);
break;
default:
ASSERT_NOT_REACHED();
direction = BasicShapeCenterCoordinate::TopLeft;
break;
}
return BasicShapeCenterCoordinate(direction, offset);
}
static BasicShapeCenterCoordinate convertToCenterCoordinate(const RenderStyle* style, const RenderStyle* rootStyle, CSSPrimitiveValue* value)
{
BasicShapeCenterCoordinate::Direction direction;
Length offset = Length(0, Fixed);
CSSValueID keyword = CSSValueTop;
if (!value)
keyword = CSSValueCenter;
else if (value->isValueID())
keyword = value->getValueID();
else if (Pair* pair = value->getPairValue()) {
keyword = pair->first()->getValueID();
offset = convertToLength(style, rootStyle, pair->second());
} else
offset = convertToLength(style, rootStyle, value);
switch (keyword) {
case CSSValueTop:
case CSSValueLeft:
direction = BasicShapeCenterCoordinate::TopLeft;
break;
case CSSValueRight:
case CSSValueBottom:
direction = BasicShapeCenterCoordinate::BottomRight;
break;
case CSSValueCenter:
direction = BasicShapeCenterCoordinate::TopLeft;
offset = Length(50, Percent);
break;
default:
ASSERT_NOT_REACHED();
direction = BasicShapeCenterCoordinate::TopLeft;
break;
}
return BasicShapeCenterCoordinate(direction, offset);
}
PassRefPtr<BasicShape> basicShapeForValue(const StyleResolverState& state, const CSSValue& basicShapeValue)
{
RefPtr<BasicShape> basicShape;
if (basicShapeValue.isBasicShapeCircleValue()) {
const CSSBasicShapeCircleValue& circleValue = toCSSBasicShapeCircleValue(basicShapeValue);
RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
circle->setCenterX(convertToCenterCoordinate(state, circleValue.centerX()));
circle->setCenterY(convertToCenterCoordinate(state, circleValue.centerY()));
circle->setRadius(cssValueToBasicShapeRadius(state, circleValue.radius()));
basicShape = circle.release();
} else if (basicShapeValue.isBasicShapeEllipseValue()) {
const CSSBasicShapeEllipseValue& ellipseValue = toCSSBasicShapeEllipseValue(basicShapeValue);
RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
ellipse->setCenterX(convertToCenterCoordinate(state, ellipseValue.centerX()));
ellipse->setCenterY(convertToCenterCoordinate(state, ellipseValue.centerY()));
ellipse->setRadiusX(cssValueToBasicShapeRadius(state, ellipseValue.radiusX()));
ellipse->setRadiusY(cssValueToBasicShapeRadius(state, ellipseValue.radiusY()));
basicShape = ellipse.release();
} else if (basicShapeValue.isBasicShapePolygonValue()) {
const CSSBasicShapePolygonValue& polygonValue = toCSSBasicShapePolygonValue(basicShapeValue);
RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
polygon->setWindRule(polygonValue.getWindRule());
const HeapVector<Member<CSSPrimitiveValue>>& values = polygonValue.values();
for (unsigned i = 0; i < values.size(); i += 2)
polygon->appendPoint(convertToLength(state, values.at(i).get()), convertToLength(state, values.at(i + 1).get()));
basicShape = polygon.release();
} else if (basicShapeValue.isBasicShapeInsetValue()) {
const CSSBasicShapeInsetValue& rectValue = toCSSBasicShapeInsetValue(basicShapeValue);
RefPtr<BasicShapeInset> rect = BasicShapeInset::create();
rect->setTop(convertToLength(state, rectValue.top()));
rect->setRight(convertToLength(state, rectValue.right()));
rect->setBottom(convertToLength(state, rectValue.bottom()));
rect->setLeft(convertToLength(state, rectValue.left()));
rect->setTopLeftRadius(convertToLengthSize(state, rectValue.topLeftRadius()));
rect->setTopRightRadius(convertToLengthSize(state, rectValue.topRightRadius()));
rect->setBottomRightRadius(convertToLengthSize(state, rectValue.bottomRightRadius()));
rect->setBottomLeftRadius(convertToLengthSize(state, rectValue.bottomLeftRadius()));
basicShape = rect.release();
} else {
ASSERT_NOT_REACHED();
}
return basicShape.release();
}
static BasicShapeRadius cssValueToBasicShapeRadius(const StyleResolverState& state, CSSPrimitiveValue* radius)
{
if (!radius)
return BasicShapeRadius(BasicShapeRadius::ClosestSide);
if (radius->isValueID()) {
switch (radius->getValueID()) {
case CSSValueClosestSide:
return BasicShapeRadius(BasicShapeRadius::ClosestSide);
case CSSValueFarthestSide:
return BasicShapeRadius(BasicShapeRadius::FarthestSide);
default:
ASSERT_NOT_REACHED();
break;
}
}
return BasicShapeRadius(convertToLength(state, radius));
}
static BasicShapeRadius cssValueToBasicShapeRadius(const RenderStyle* style, const RenderStyle* rootStyle, PassRefPtr<CSSPrimitiveValue> radius)
{
if (!radius)
return BasicShapeRadius(BasicShapeRadius::ClosestSide);
if (radius->isValueID()) {
switch (radius->getValueID()) {
case CSSValueClosestSide:
return BasicShapeRadius(BasicShapeRadius::ClosestSide);
case CSSValueFarthestSide:
return BasicShapeRadius(BasicShapeRadius::FarthestSide);
default:
ASSERT_NOT_REACHED();
break;
}
}
return BasicShapeRadius(convertToLength(style, rootStyle, radius.get()));
}
PassRefPtr<BasicShape> basicShapeForValue(const StyleResolverState& state, const CSSBasicShape* basicShapeValue)
{
RefPtr<BasicShape> basicShape;
switch (basicShapeValue->type()) {
case CSSBasicShape::CSSBasicShapeRectangleType: {
const CSSBasicShapeRectangle* rectValue = static_cast<const CSSBasicShapeRectangle *>(basicShapeValue);
RefPtr<BasicShapeRectangle> rect = BasicShapeRectangle::create();
rect->setX(convertToLength(state, rectValue->x()));
rect->setY(convertToLength(state, rectValue->y()));
rect->setWidth(convertToLength(state, rectValue->width()));
rect->setHeight(convertToLength(state, rectValue->height()));
if (rectValue->radiusX()) {
Length radiusX = convertToLength(state, rectValue->radiusX());
rect->setCornerRadiusX(radiusX);
if (rectValue->radiusY())
rect->setCornerRadiusY(convertToLength(state, rectValue->radiusY()));
else
rect->setCornerRadiusY(radiusX);
} else {
rect->setCornerRadiusX(Length(0, Fixed));
rect->setCornerRadiusY(Length(0, Fixed));
}
basicShape = rect.release();
break;
}
case CSSBasicShape::CSSDeprecatedBasicShapeCircleType: {
const CSSDeprecatedBasicShapeCircle* circleValue = static_cast<const CSSDeprecatedBasicShapeCircle *>(basicShapeValue);
RefPtr<DeprecatedBasicShapeCircle> circle = DeprecatedBasicShapeCircle::create();
circle->setCenterX(convertToLength(state, circleValue->centerX()));
circle->setCenterY(convertToLength(state, circleValue->centerY()));
circle->setRadius(convertToLength(state, circleValue->radius()));
basicShape = circle.release();
break;
}
case CSSBasicShape::CSSBasicShapeCircleType: {
const CSSBasicShapeCircle* circleValue = static_cast<const CSSBasicShapeCircle *>(basicShapeValue);
RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
if (circleValue->centerX() && circleValue->centerY()) {
circle->setCenterX(convertToCenterCoordinate(state, circleValue->centerX()));
circle->setCenterY(convertToCenterCoordinate(state, circleValue->centerY()));
} else {
circle->setCenterX(BasicShapeCenterCoordinate(Length(50, Percent)));
circle->setCenterY(BasicShapeCenterCoordinate(Length(50, Percent)));
}
circle->setRadius(cssValueToBasicShapeRadius(state, circleValue->radius()));
basicShape = circle.release();
break;
}
case CSSBasicShape::CSSDeprecatedBasicShapeEllipseType: {
const CSSDeprecatedBasicShapeEllipse* ellipseValue = static_cast<const CSSDeprecatedBasicShapeEllipse *>(basicShapeValue);
RefPtr<DeprecatedBasicShapeEllipse> ellipse = DeprecatedBasicShapeEllipse::create();
ellipse->setCenterX(convertToLength(state, ellipseValue->centerX()));
ellipse->setCenterY(convertToLength(state, ellipseValue->centerY()));
ellipse->setRadiusX(convertToLength(state, ellipseValue->radiusX()));
ellipse->setRadiusY(convertToLength(state, ellipseValue->radiusY()));
basicShape = ellipse.release();
break;
}
case CSSBasicShape::CSSBasicShapeEllipseType: {
const CSSBasicShapeEllipse* ellipseValue = static_cast<const CSSBasicShapeEllipse *>(basicShapeValue);
RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
if (ellipseValue->centerX() && ellipseValue->centerY()) {
ellipse->setCenterX(convertToCenterCoordinate(state, ellipseValue->centerX()));
ellipse->setCenterY(convertToCenterCoordinate(state, ellipseValue->centerY()));
} else {
ellipse->setCenterX(BasicShapeCenterCoordinate(Length(50, Percent)));
ellipse->setCenterY(BasicShapeCenterCoordinate(Length(50, Percent)));
}
ellipse->setRadiusX(cssValueToBasicShapeRadius(state, ellipseValue->radiusX()));
ellipse->setRadiusY(cssValueToBasicShapeRadius(state, ellipseValue->radiusY()));
basicShape = ellipse.release();
break;
}
case CSSBasicShape::CSSBasicShapePolygonType: {
const CSSBasicShapePolygon* polygonValue = static_cast<const CSSBasicShapePolygon *>(basicShapeValue);
RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
polygon->setWindRule(polygonValue->windRule());
const Vector<RefPtr<CSSPrimitiveValue> >& values = polygonValue->values();
for (unsigned i = 0; i < values.size(); i += 2)
polygon->appendPoint(convertToLength(state, values.at(i).get()), convertToLength(state, values.at(i + 1).get()));
basicShape = polygon.release();
break;
}
case CSSBasicShape::CSSBasicShapeInsetRectangleType: {
const CSSBasicShapeInsetRectangle* rectValue = static_cast<const CSSBasicShapeInsetRectangle *>(basicShapeValue);
RefPtr<BasicShapeInsetRectangle> rect = BasicShapeInsetRectangle::create();
rect->setTop(convertToLength(state, rectValue->top()));
rect->setRight(convertToLength(state, rectValue->right()));
rect->setBottom(convertToLength(state, rectValue->bottom()));
rect->setLeft(convertToLength(state, rectValue->left()));
if (rectValue->radiusX()) {
Length radiusX = convertToLength(state, rectValue->radiusX());
rect->setCornerRadiusX(radiusX);
if (rectValue->radiusY())
rect->setCornerRadiusY(convertToLength(state, rectValue->radiusY()));
else
rect->setCornerRadiusY(radiusX);
} else {
rect->setCornerRadiusX(Length(0, Fixed));
rect->setCornerRadiusY(Length(0, Fixed));
}
basicShape = rect.release();
break;
}
case CSSBasicShape::CSSBasicShapeInsetType: {
const CSSBasicShapeInset* rectValue = static_cast<const CSSBasicShapeInset* >(basicShapeValue);
RefPtr<BasicShapeInset> rect = BasicShapeInset::create();
rect->setTop(convertToLength(state, rectValue->top()));
rect->setRight(convertToLength(state, rectValue->right()));
rect->setBottom(convertToLength(state, rectValue->bottom()));
rect->setLeft(convertToLength(state, rectValue->left()));
rect->setTopLeftRadius(convertToLengthSize(state, rectValue->topLeftRadius()));
rect->setTopRightRadius(convertToLengthSize(state, rectValue->topRightRadius()));
rect->setBottomRightRadius(convertToLengthSize(state, rectValue->bottomRightRadius()));
rect->setBottomLeftRadius(convertToLengthSize(state, rectValue->bottomLeftRadius()));
basicShape = rect.release();
break;
}
default:
break;
}
if (basicShapeValue->layoutBox())
basicShape->setLayoutBox(LayoutBox(*basicShapeValue->layoutBox()));
return basicShape.release();
}
PassRefPtr<BasicShape> basicShapeForValue(const RenderStyle* style, const RenderStyle* rootStyle, const CSSBasicShape* basicShapeValue)
{
RefPtr<BasicShape> basicShape;
switch (basicShapeValue->type()) {
case CSSBasicShape::CSSBasicShapeCircleType: {
const CSSBasicShapeCircle* circleValue = static_cast<const CSSBasicShapeCircle *>(basicShapeValue);
RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
circle->setCenterX(convertToCenterCoordinate(style, rootStyle, circleValue->centerX()));
circle->setCenterY(convertToCenterCoordinate(style, rootStyle, circleValue->centerY()));
circle->setRadius(cssValueToBasicShapeRadius(style, rootStyle, circleValue->radius()));
basicShape = circle.release();
break;
}
case CSSBasicShape::CSSBasicShapeEllipseType: {
const CSSBasicShapeEllipse* ellipseValue = static_cast<const CSSBasicShapeEllipse *>(basicShapeValue);
RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
ellipse->setCenterX(convertToCenterCoordinate(style, rootStyle, ellipseValue->centerX()));
ellipse->setCenterY(convertToCenterCoordinate(style, rootStyle, ellipseValue->centerY()));
ellipse->setRadiusX(cssValueToBasicShapeRadius(style, rootStyle, ellipseValue->radiusX()));
ellipse->setRadiusY(cssValueToBasicShapeRadius(style, rootStyle, ellipseValue->radiusY()));
basicShape = ellipse.release();
break;
}
case CSSBasicShape::CSSBasicShapePolygonType: {
const CSSBasicShapePolygon* polygonValue = static_cast<const CSSBasicShapePolygon *>(basicShapeValue);
RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
polygon->setWindRule(polygonValue->windRule());
const Vector<RefPtr<CSSPrimitiveValue>>& values = polygonValue->values();
for (unsigned i = 0; i < values.size(); i += 2)
polygon->appendPoint(convertToLength(style, rootStyle, values.at(i).get()), convertToLength(style, rootStyle, values.at(i + 1).get()));
basicShape = polygon.release();
break;
}
case CSSBasicShape::CSSBasicShapeInsetType: {
const CSSBasicShapeInset* rectValue = static_cast<const CSSBasicShapeInset* >(basicShapeValue);
RefPtr<BasicShapeInset> rect = BasicShapeInset::create();
rect->setTop(convertToLength(style, rootStyle, rectValue->top()));
rect->setRight(convertToLength(style, rootStyle, rectValue->right()));
rect->setBottom(convertToLength(style, rootStyle, rectValue->bottom()));
rect->setLeft(convertToLength(style, rootStyle, rectValue->left()));
rect->setTopLeftRadius(convertToLengthSize(style, rootStyle, rectValue->topLeftRadius()));
rect->setTopRightRadius(convertToLengthSize(style, rootStyle, rectValue->topRightRadius()));
rect->setBottomRightRadius(convertToLengthSize(style, rootStyle, rectValue->bottomRightRadius()));
rect->setBottomLeftRadius(convertToLengthSize(style, rootStyle, rectValue->bottomLeftRadius()));
basicShape = rect.release();
break;
}
default:
break;
}
if (basicShapeValue->referenceBox())
basicShape->setReferenceBox(CSSBoxType(*basicShapeValue->referenceBox()));
return basicShape.release();
}
