void CSSToStyleMap::mapNinePieceImageSlice(StyleResolverState&, const CSSValue& value, NinePieceImage& image)
{
if (!value.isBorderImageSliceValue())
return;
// Retrieve the border image value.
const CSSBorderImageSliceValue& borderImageSlice = toCSSBorderImageSliceValue(value);
// Set up a length box to represent our image slices.
LengthBox box;
CSSQuadValue* slices = borderImageSlice.slices();
if (slices->top()->isPercentage())
box.m_top = Length(slices->top()->getDoubleValue(), Percent);
else
box.m_top = Length(slices->top()->getIntValue(), Fixed);
if (slices->bottom()->isPercentage())
box.m_bottom = Length(slices->bottom()->getDoubleValue(), Percent);
else
box.m_bottom = Length(slices->bottom()->getIntValue(), Fixed);
if (slices->left()->isPercentage())
box.m_left = Length(slices->left()->getDoubleValue(), Percent);
else
box.m_left = Length(slices->left()->getIntValue(), Fixed);
if (slices->right()->isPercentage())
box.m_right = Length(slices->right()->getDoubleValue(), Percent);
else
box.m_right = Length(slices->right()->getIntValue(), Fixed);
image.setImageSlices(box);
// Set our fill mode.
image.setFill(borderImageSlice.m_fill);
}
void CSSToStyleMap::mapNinePieceImageSlice(StyleResolverState&, CSSValue* value, NinePieceImage& image)
{
if (!value || !value->isBorderImageSliceValue())
return;
// Retrieve the border image value.
CSSBorderImageSliceValue* borderImageSlice = toCSSBorderImageSliceValue(value);
// Set up a length box to represent our image slices.
LengthBox box;
Quad* slices = borderImageSlice->slices();
if (slices->top()->isPercentage())
box.m_top = Length(slices->top()->getDoubleValue(), Percent);
else
box.m_top = Length(slices->top()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->bottom()->isPercentage())
box.m_bottom = Length(slices->bottom()->getDoubleValue(), Percent);
else
box.m_bottom = Length((int)slices->bottom()->getFloatValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->left()->isPercentage())
box.m_left = Length(slices->left()->getDoubleValue(), Percent);
else
box.m_left = Length(slices->left()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->right()->isPercentage())
box.m_right = Length(slices->right()->getDoubleValue(), Percent);
else
box.m_right = Length(slices->right()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
image.setImageSlices(box);
// Set our fill mode.
image.setFill(borderImageSlice->m_fill);
}
void CSSToStyleMap::mapNinePieceImageSlice(CSSValue& value, NinePieceImage& image)
{
if (!is<CSSBorderImageSliceValue>(value))
return;
// Retrieve the border image value.
auto& borderImageSlice = downcast<CSSBorderImageSliceValue>(value);
// Set up a length box to represent our image slices.
LengthBox box;
Quad* slices = borderImageSlice.slices();
if (slices->top()->isPercentage())
box.top() = Length(slices->top()->getDoubleValue(), Percent);
else
box.top() = Length(slices->top()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->bottom()->isPercentage())
box.bottom() = Length(slices->bottom()->getDoubleValue(), Percent);
else
box.bottom() = Length((int)slices->bottom()->getFloatValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->left()->isPercentage())
box.left() = Length(slices->left()->getDoubleValue(), Percent);
else
box.left() = Length(slices->left()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->right()->isPercentage())
box.right() = Length(slices->right()->getDoubleValue(), Percent);
else
box.right() = Length(slices->right()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
image.setImageSlices(box);
// Set our fill mode.
image.setFill(borderImageSlice.m_fill);
}
void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, CSSValue* value, NinePieceImage& image)
{
if (!value || !value->isPrimitiveValue())
return;
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
Pair* pair = primitiveValue->getPairValue();
if (!pair || !pair->first() || !pair->second())
return;
CSSValueID firstIdentifier = pair->first()->getValueID();
CSSValueID secondIdentifier = pair->second()->getValueID();
ENinePieceImageRule horizontalRule;
switch (firstIdentifier) {
case CSSValueStretch:
horizontalRule = StretchImageRule;
break;
case CSSValueRound:
horizontalRule = RoundImageRule;
break;
case CSSValueSpace:
horizontalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
horizontalRule = RepeatImageRule;
break;
}
image.setHorizontalRule(horizontalRule);
ENinePieceImageRule verticalRule;
switch (secondIdentifier) {
case CSSValueStretch:
verticalRule = StretchImageRule;
break;
case CSSValueRound:
verticalRule = RoundImageRule;
break;
case CSSValueSpace:
verticalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
verticalRule = RepeatImageRule;
break;
}
image.setVerticalRule(verticalRule);
}
PassRefPtr<StyleReflection> StyleBuilderConverter::convertBoxReflect(StyleResolverState& state, CSSValue* value)
{
if (value->isPrimitiveValue()) {
ASSERT(toCSSPrimitiveValue(value)->getValueID() == CSSValueNone);
return RenderStyle::initialBoxReflect();
}
CSSReflectValue* reflectValue = toCSSReflectValue(value);
RefPtr<StyleReflection> reflection = StyleReflection::create();
reflection->setDirection(*reflectValue->direction());
if (reflectValue->offset())
reflection->setOffset(reflectValue->offset()->convertToLength<FixedConversion | PercentConversion>(state.cssToLengthConversionData()));
NinePieceImage mask;
mask.setMaskDefaults();
state.styleMap().mapNinePieceImage(state.style(), CSSPropertyWebkitBoxReflect, reflectValue->mask(), mask);
reflection->setMask(mask);
return reflection.release();
}
void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, const CSSValue& value, NinePieceImage& image)
{
if (!value.isValuePair())
return;
const CSSValuePair& pair = toCSSValuePair(value);
CSSValueID firstIdentifier = toCSSPrimitiveValue(pair.first()).getValueID();
CSSValueID secondIdentifier = toCSSPrimitiveValue(pair.second()).getValueID();
ENinePieceImageRule horizontalRule;
switch (firstIdentifier) {
case CSSValueStretch:
horizontalRule = StretchImageRule;
break;
case CSSValueRound:
horizontalRule = RoundImageRule;
break;
case CSSValueSpace:
horizontalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
horizontalRule = RepeatImageRule;
break;
}
image.setHorizontalRule(horizontalRule);
ENinePieceImageRule verticalRule;
switch (secondIdentifier) {
case CSSValueStretch:
verticalRule = StretchImageRule;
break;
case CSSValueRound:
verticalRule = RoundImageRule;
break;
case CSSValueSpace:
verticalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
verticalRule = RepeatImageRule;
break;
}
image.setVerticalRule(verticalRule);
}
void CSSToStyleMap::mapNinePieceImageSlice(StyleResolverState&, const CSSValue& value, NinePieceImage& image)
{
if (!value.isBorderImageSliceValue())
return;
// Retrieve the border image value.
const CSSBorderImageSliceValue& borderImageSlice = toCSSBorderImageSliceValue(value);
// Set up a length box to represent our image slices.
LengthBox box;
CSSQuadValue* slices = borderImageSlice.slices();
box.m_top = convertBorderImageSliceSide(*slices->top());
box.m_bottom = convertBorderImageSliceSide(*slices->bottom());
box.m_left = convertBorderImageSliceSide(*slices->left());
box.m_right = convertBorderImageSliceSide(*slices->right());
image.setImageSlices(box);
// Set our fill mode.
image.setFill(borderImageSlice.m_fill);
}
void CSSToStyleMap::mapNinePieceImage(StyleResolverState& state, CSSPropertyID property, CSSValue* value, NinePieceImage& image)
{
// If we're not a value list, then we are "none" and don't need to alter the empty image at all.
if (!value || !value->isValueList())
return;
// Retrieve the border image value.
CSSValueList* borderImage = toCSSValueList(value);
// Set the image (this kicks off the load).
CSSPropertyID imageProperty;
if (property == CSSPropertyWebkitBorderImage)
imageProperty = CSSPropertyBorderImageSource;
else if (property == CSSPropertyWebkitMaskBoxImage)
imageProperty = CSSPropertyWebkitMaskBoxImageSource;
else
imageProperty = property;
for (unsigned i = 0 ; i < borderImage->length() ; ++i) {
CSSValue* current = borderImage->item(i);
if (current->isImageValue() || current->isImageGeneratorValue() || current->isImageSetValue())
image.setImage(state.styleImage(imageProperty, current));
else if (current->isBorderImageSliceValue())
mapNinePieceImageSlice(state, current, image);
else if (current->isValueList()) {
CSSValueList* slashList = toCSSValueList(current);
size_t length = slashList->length();
// Map in the image slices.
if (length && slashList->item(0)->isBorderImageSliceValue())
mapNinePieceImageSlice(state, slashList->item(0), image);
// Map in the border slices.
if (length > 1)
image.setBorderSlices(mapNinePieceImageQuad(state, slashList->item(1)));
// Map in the outset.
if (length > 2)
image.setOutset(mapNinePieceImageQuad(state, slashList->item(2)));
} else if (current->isPrimitiveValue()) {
// Set the appropriate rules for stretch/round/repeat of the slices.
mapNinePieceImageRepeat(state, current, image);
}
}
if (property == CSSPropertyWebkitBorderImage) {
// We have to preserve the legacy behavior of -webkit-border-image and make the border slices
// also set the border widths. We don't need to worry about percentages, since we don't even support
// those on real borders yet.
if (image.borderSlices().top().isLength() && image.borderSlices().top().length().isFixed())
state.style()->setBorderTopWidth(image.borderSlices().top().length().value());
if (image.borderSlices().right().isLength() && image.borderSlices().right().length().isFixed())
state.style()->setBorderRightWidth(image.borderSlices().right().length().value());
if (image.borderSlices().bottom().isLength() && image.borderSlices().bottom().length().isFixed())
state.style()->setBorderBottomWidth(image.borderSlices().bottom().length().value());
if (image.borderSlices().left().isLength() && image.borderSlices().left().length().isFixed())
state.style()->setBorderLeftWidth(image.borderSlices().left().length().value());
}
}
void CSSToStyleMap::mapNinePieceImage(CSSPropertyID property, CSSValue* value, NinePieceImage& image)
{
// If we're not a value list, then we are "none" and don't need to alter the empty image at all.
if (!is<CSSValueList>(value))
return;
// Retrieve the border image value.
CSSValueList& borderImage = downcast<CSSValueList>(*value);
// Set the image (this kicks off the load).
CSSPropertyID imageProperty;
if (property == CSSPropertyWebkitBorderImage)
imageProperty = CSSPropertyBorderImageSource;
else if (property == CSSPropertyWebkitMaskBoxImage)
imageProperty = CSSPropertyWebkitMaskBoxImageSource;
else
imageProperty = property;
for (auto& current : borderImage) {
if (is<CSSImageValue>(current.get()) || is<CSSImageGeneratorValue>(current.get())
#if ENABLE(CSS_IMAGE_SET)
|| is<CSSImageSetValue>(current.get())
#endif
)
image.setImage(styleImage(imageProperty, current.get()));
else if (is<CSSBorderImageSliceValue>(current.get()))
mapNinePieceImageSlice(current, image);
else if (is<CSSValueList>(current.get())) {
CSSValueList& slashList = downcast<CSSValueList>(current.get());
// Map in the image slices.
if (is<CSSBorderImageSliceValue>(slashList.item(0)))
mapNinePieceImageSlice(*slashList.item(0), image);
// Map in the border slices.
if (slashList.item(1))
image.setBorderSlices(mapNinePieceImageQuad(*slashList.item(1)));
// Map in the outset.
if (slashList.item(2))
image.setOutset(mapNinePieceImageQuad(*slashList.item(2)));
} else if (is<CSSPrimitiveValue>(current.get())) {
// Set the appropriate rules for stretch/round/repeat of the slices.
mapNinePieceImageRepeat(current, image);
}
}
if (property == CSSPropertyWebkitBorderImage) {
// We have to preserve the legacy behavior of -webkit-border-image and make the border slices
// also set the border widths. We don't need to worry about percentages, since we don't even support
// those on real borders yet.
if (image.borderSlices().top().isFixed())
style()->setBorderTopWidth(image.borderSlices().top().value());
if (image.borderSlices().right().isFixed())
style()->setBorderRightWidth(image.borderSlices().right().value());
if (image.borderSlices().bottom().isFixed())
style()->setBorderBottomWidth(image.borderSlices().bottom().value());
if (image.borderSlices().left().isFixed())
style()->setBorderLeftWidth(image.borderSlices().left().value());
}
}
NinePieceImageGrid::NinePieceImageGrid(const NinePieceImage& ninePieceImage, IntSize imageSize, IntRect borderImageArea,
const IntRectOutsets& borderWidths)
: m_borderImageArea(borderImageArea)
, m_imageSize(imageSize)
, m_horizontalTileRule((Image::TileRule)ninePieceImage.horizontalRule())
, m_verticalTileRule((Image::TileRule)ninePieceImage.verticalRule())
, m_fill(ninePieceImage.fill())
{
StyleImage* styleImage = ninePieceImage.image();
ASSERT(styleImage);
float imageScaleFactor = styleImage->imageScaleFactor();
m_top.slice = computeEdgeSlice(ninePieceImage.imageSlices().top(), imageSize.height()) * imageScaleFactor;
m_right.slice = computeEdgeSlice(ninePieceImage.imageSlices().right(), imageSize.width()) * imageScaleFactor;
m_bottom.slice = computeEdgeSlice(ninePieceImage.imageSlices().bottom(), imageSize.height()) * imageScaleFactor;
m_left.slice = computeEdgeSlice(ninePieceImage.imageSlices().left(), imageSize.width()) * imageScaleFactor;
m_top.width = computeEdgeWidth(ninePieceImage.borderSlices().top(), borderWidths.top(), m_top.slice,
borderImageArea.height());
m_right.width = computeEdgeWidth(ninePieceImage.borderSlices().right(), borderWidths.right(), m_right.slice,
borderImageArea.width());
m_bottom.width = computeEdgeWidth(ninePieceImage.borderSlices().bottom(), borderWidths.bottom(), m_bottom.slice,
borderImageArea.height());
m_left.width = computeEdgeWidth(ninePieceImage.borderSlices().left(), borderWidths.left(), m_left.slice,
borderImageArea.width());
// The spec says: Given Lwidth as the width of the border image area, Lheight as its height, and Wside as the border
// image width offset for the side, let f = min(Lwidth/(Wleft+Wright), Lheight/(Wtop+Wbottom)). If f < 1, then all W
// are reduced by multiplying them by f.
int borderSideWidth = std::max(1, m_left.width + m_right.width);
int borderSideHeight = std::max(1, m_top.width + m_bottom.width);
float borderSideScaleFactor = std::min((float)borderImageArea.width() / borderSideWidth,
(float)borderImageArea.height() / borderSideHeight);
if (borderSideScaleFactor < 1) {
m_top.width *= borderSideScaleFactor;
m_right.width *= borderSideScaleFactor;
m_bottom.width *= borderSideScaleFactor;
m_left.width *= borderSideScaleFactor;
}
}
