bool TransformBuilder::createTransformOperations(CSSValue* inValue, RenderStyle* style, RenderStyle* rootStyle, TransformOperations& outOperations)
{
if (!inValue || !inValue->isValueList()) {
outOperations.clear();
return false;
}
float zoomFactor = style ? style->effectiveZoom() : 1;
TransformOperations operations;
for (CSSValueListIterator i = inValue; i.hasMore(); i.advance()) {
CSSValue* currValue = i.value();
if (!currValue->isCSSTransformValue())
continue;
CSSTransformValue* transformValue = static_cast<CSSTransformValue*>(i.value());
if (!transformValue->length())
continue;
bool haveNonPrimitiveValue = false;
for (unsigned j = 0; j < transformValue->length(); ++j) {
if (!transformValue->itemWithoutBoundsCheck(j)->isPrimitiveValue()) {
haveNonPrimitiveValue = true;
break;
}
}
if (haveNonPrimitiveValue)
continue;
CSSPrimitiveValue* firstValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(0));
switch (transformValue->operationType()) {
case CSSTransformValue::ScaleTransformOperation:
case CSSTransformValue::ScaleXTransformOperation:
case CSSTransformValue::ScaleYTransformOperation: {
double sx = 1.0;
double sy = 1.0;
if (transformValue->operationType() == CSSTransformValue::ScaleYTransformOperation)
sy = firstValue->getDoubleValue();
else {
sx = firstValue->getDoubleValue();
if (transformValue->operationType() != CSSTransformValue::ScaleXTransformOperation) {
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
sy = secondValue->getDoubleValue();
} else
sy = sx;
}
}
operations.operations().append(ScaleTransformOperation::create(sx, sy, 1.0, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::ScaleZTransformOperation:
case CSSTransformValue::Scale3DTransformOperation: {
double sx = 1.0;
double sy = 1.0;
double sz = 1.0;
if (transformValue->operationType() == CSSTransformValue::ScaleZTransformOperation)
sz = firstValue->getDoubleValue();
else if (transformValue->operationType() == CSSTransformValue::ScaleYTransformOperation)
sy = firstValue->getDoubleValue();
else {
sx = firstValue->getDoubleValue();
if (transformValue->operationType() != CSSTransformValue::ScaleXTransformOperation) {
if (transformValue->length() > 2) {
CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
sz = thirdValue->getDoubleValue();
}
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
sy = secondValue->getDoubleValue();
} else
sy = sx;
}
}
operations.operations().append(ScaleTransformOperation::create(sx, sy, sz, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::TranslateTransformOperation:
case CSSTransformValue::TranslateXTransformOperation:
case CSSTransformValue::TranslateYTransformOperation: {
Length tx = Length(0, Fixed);
Length ty = Length(0, Fixed);
if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
else {
tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
ty = convertToFloatLength(secondValue, style, rootStyle, zoomFactor);
}
}
}
if (tx.isUndefined() || ty.isUndefined())
return false;
operations.operations().append(TranslateTransformOperation::create(tx, ty, Length(0, Fixed), getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::TranslateZTransformOperation:
case CSSTransformValue::Translate3DTransformOperation: {
Length tx = Length(0, Fixed);
Length ty = Length(0, Fixed);
Length tz = Length(0, Fixed);
if (transformValue->operationType() == CSSTransformValue::TranslateZTransformOperation)
tz = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
else if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
else {
tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
if (transformValue->length() > 2) {
CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
tz = convertToFloatLength(thirdValue, style, rootStyle, zoomFactor);
}
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
ty = convertToFloatLength(secondValue, style, rootStyle, zoomFactor);
}
}
}
if (tx.isUndefined() || ty.isUndefined() || tz.isUndefined())
return false;
operations.operations().append(TranslateTransformOperation::create(tx, ty, tz, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::RotateTransformOperation: {
double angle = firstValue->computeDegrees();
operations.operations().append(RotateTransformOperation::create(0, 0, 1, angle, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::RotateXTransformOperation:
case CSSTransformValue::RotateYTransformOperation:
case CSSTransformValue::RotateZTransformOperation: {
double x = 0;
double y = 0;
double z = 0;
double angle = firstValue->computeDegrees();
if (transformValue->operationType() == CSSTransformValue::RotateXTransformOperation)
x = 1;
else if (transformValue->operationType() == CSSTransformValue::RotateYTransformOperation)
y = 1;
else
z = 1;
operations.operations().append(RotateTransformOperation::create(x, y, z, angle, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::Rotate3DTransformOperation: {
if (transformValue->length() < 4)
break;
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
CSSPrimitiveValue* fourthValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3));
double x = firstValue->getDoubleValue();
double y = secondValue->getDoubleValue();
double z = thirdValue->getDoubleValue();
double angle = fourthValue->computeDegrees();
operations.operations().append(RotateTransformOperation::create(x, y, z, angle, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::SkewTransformOperation:
case CSSTransformValue::SkewXTransformOperation:
case CSSTransformValue::SkewYTransformOperation: {
double angleX = 0;
double angleY = 0;
double angle = firstValue->computeDegrees();
if (transformValue->operationType() == CSSTransformValue::SkewYTransformOperation)
angleY = angle;
else {
angleX = angle;
if (transformValue->operationType() == CSSTransformValue::SkewTransformOperation) {
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
angleY = secondValue->computeDegrees();
}
}
}
operations.operations().append(SkewTransformOperation::create(angleX, angleY, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::MatrixTransformOperation: {
if (transformValue->length() < 6)
break;
double a = firstValue->getDoubleValue();
double b = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1))->getDoubleValue();
double c = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2))->getDoubleValue();
double d = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3))->getDoubleValue();
double e = zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(4))->getDoubleValue();
double f = zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(5))->getDoubleValue();
operations.operations().append(MatrixTransformOperation::create(a, b, c, d, e, f));
break;
}
case CSSTransformValue::Matrix3DTransformOperation: {
if (transformValue->length() < 16)
break;
TransformationMatrix matrix(toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(0))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(4))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(5))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(6))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(7))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(8))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(9))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(10))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(11))->getDoubleValue(),
zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(12))->getDoubleValue(),
zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(13))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(14))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(15))->getDoubleValue());
operations.operations().append(Matrix3DTransformOperation::create(matrix));
break;
}
case CSSTransformValue::PerspectiveTransformOperation: {
Length p = Length(0, Fixed);
if (firstValue->isLength())
p = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
else {
// This is a quirk that should go away when 3d transforms are finalized.
double val = firstValue->getDoubleValue();
p = val >= 0 ? Length(clampToPositiveInteger(val), Fixed) : Length(Undefined);
}
if (p.isUndefined())
return false;
operations.operations().append(PerspectiveTransformOperation::create(p));
break;
}
case CSSTransformValue::UnknownTransformOperation:
ASSERT_NOT_REACHED();
break;
}
}
outOperations = operations;
return true;
}
TransformOperations TransformBuilder::createTransformOperations(
const CSSValue& inValue,
const CSSToLengthConversionData& conversionData) {
TransformOperations operations;
if (!inValue.isValueList()) {
DCHECK_EQ(toCSSIdentifierValue(inValue).getValueID(), CSSValueNone);
return operations;
}
float zoomFactor = conversionData.zoom();
for (auto& value : toCSSValueList(inValue)) {
const CSSFunctionValue* transformValue = toCSSFunctionValue(value.get());
TransformOperation::OperationType transformType =
getTransformOperationType(transformValue->functionType());
const CSSPrimitiveValue& firstValue =
toCSSPrimitiveValue(transformValue->item(0));
switch (transformType) {
case TransformOperation::Scale:
case TransformOperation::ScaleX:
case TransformOperation::ScaleY: {
double sx = 1.0;
double sy = 1.0;
if (transformType == TransformOperation::ScaleY) {
sy = firstValue.getDoubleValue();
} else {
sx = firstValue.getDoubleValue();
if (transformType != TransformOperation::ScaleX) {
if (transformValue->length() > 1) {
const CSSPrimitiveValue& secondValue =
toCSSPrimitiveValue(transformValue->item(1));
sy = secondValue.getDoubleValue();
} else {
sy = sx;
}
}
}
operations.operations().append(
ScaleTransformOperation::create(sx, sy, 1.0, transformType));
break;
}
case TransformOperation::ScaleZ:
case TransformOperation::Scale3D: {
double sx = 1.0;
double sy = 1.0;
double sz = 1.0;
if (transformType == TransformOperation::ScaleZ) {
sz = firstValue.getDoubleValue();
} else {
sx = firstValue.getDoubleValue();
sy = toCSSPrimitiveValue(transformValue->item(1)).getDoubleValue();
sz = toCSSPrimitiveValue(transformValue->item(2)).getDoubleValue();
}
operations.operations().append(
ScaleTransformOperation::create(sx, sy, sz, transformType));
break;
}
case TransformOperation::Translate:
case TransformOperation::TranslateX:
case TransformOperation::TranslateY: {
Length tx = Length(0, Fixed);
Length ty = Length(0, Fixed);
if (transformType == TransformOperation::TranslateY)
ty = convertToFloatLength(firstValue, conversionData);
else {
tx = convertToFloatLength(firstValue, conversionData);
if (transformType != TransformOperation::TranslateX) {
if (transformValue->length() > 1) {
const CSSPrimitiveValue& secondValue =
toCSSPrimitiveValue(transformValue->item(1));
ty = convertToFloatLength(secondValue, conversionData);
}
}
}
operations.operations().append(
TranslateTransformOperation::create(tx, ty, 0, transformType));
break;
}
case TransformOperation::TranslateZ:
case TransformOperation::Translate3D: {
Length tx = Length(0, Fixed);
Length ty = Length(0, Fixed);
double tz = 0;
if (transformType == TransformOperation::TranslateZ) {
tz = firstValue.computeLength<double>(conversionData);
} else {
tx = convertToFloatLength(firstValue, conversionData);
ty = convertToFloatLength(
toCSSPrimitiveValue(transformValue->item(1)), conversionData);
tz = toCSSPrimitiveValue(transformValue->item(2))
.computeLength<double>(conversionData);
}
operations.operations().append(
TranslateTransformOperation::create(tx, ty, tz, transformType));
break;
}
case TransformOperation::RotateX:
case TransformOperation::RotateY:
case TransformOperation::RotateZ: {
double angle = firstValue.computeDegrees();
if (transformValue->length() == 1) {
double x = transformType == TransformOperation::RotateX;
double y = transformType == TransformOperation::RotateY;
double z = transformType == TransformOperation::RotateZ;
operations.operations().append(
RotateTransformOperation::create(x, y, z, angle, transformType));
} else {
// For SVG 'transform' attributes we generate 3-argument rotate()
// functions.
DCHECK_EQ(transformValue->length(), 3u);
const CSSPrimitiveValue& secondValue =
toCSSPrimitiveValue(transformValue->item(1));
const CSSPrimitiveValue& thirdValue =
toCSSPrimitiveValue(transformValue->item(2));
operations.operations().append(
RotateAroundOriginTransformOperation::create(
angle, secondValue.computeLength<double>(conversionData),
thirdValue.computeLength<double>(conversionData)));
}
break;
}
case TransformOperation::Rotate3D: {
const CSSPrimitiveValue& secondValue =
toCSSPrimitiveValue(transformValue->item(1));
const CSSPrimitiveValue& thirdValue =
toCSSPrimitiveValue(transformValue->item(2));
const CSSPrimitiveValue& fourthValue =
toCSSPrimitiveValue(transformValue->item(3));
double x = firstValue.getDoubleValue();
double y = secondValue.getDoubleValue();
double z = thirdValue.getDoubleValue();
double angle = fourthValue.computeDegrees();
operations.operations().append(
RotateTransformOperation::create(x, y, z, angle, transformType));
break;
}
case TransformOperation::Skew:
case TransformOperation::SkewX:
case TransformOperation::SkewY: {
double angleX = 0;
double angleY = 0;
double angle = firstValue.computeDegrees();
if (transformType == TransformOperation::SkewY)
angleY = angle;
else {
angleX = angle;
if (transformType == TransformOperation::Skew) {
if (transformValue->length() > 1) {
const CSSPrimitiveValue& secondValue =
toCSSPrimitiveValue(transformValue->item(1));
angleY = secondValue.computeDegrees();
}
}
}
operations.operations().append(
SkewTransformOperation::create(angleX, angleY, transformType));
break;
}
case TransformOperation::Matrix: {
double a = firstValue.getDoubleValue();
double b =
toCSSPrimitiveValue(transformValue->item(1)).getDoubleValue();
double c =
toCSSPrimitiveValue(transformValue->item(2)).getDoubleValue();
double d =
toCSSPrimitiveValue(transformValue->item(3)).getDoubleValue();
double e =
zoomFactor *
toCSSPrimitiveValue(transformValue->item(4)).getDoubleValue();
double f =
zoomFactor *
toCSSPrimitiveValue(transformValue->item(5)).getDoubleValue();
operations.operations().append(
MatrixTransformOperation::create(a, b, c, d, e, f));
break;
}
case TransformOperation::Matrix3D: {
TransformationMatrix matrix(
toCSSPrimitiveValue(transformValue->item(0)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(1)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(2)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(3)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(4)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(5)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(6)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(7)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(8)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(9)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(10)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(11)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(12)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(13)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(14)).getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(15)).getDoubleValue());
matrix.zoom(zoomFactor);
operations.operations().append(
Matrix3DTransformOperation::create(matrix));
break;
}
case TransformOperation::Perspective: {
double p = firstValue.computeLength<double>(conversionData);
ASSERT(p >= 0);
operations.operations().append(
PerspectiveTransformOperation::create(p));
break;
}
default:
ASSERT_NOT_REACHED();
break;
}
}
return operations;
}
bool TransformBuilder::createTransformOperations(CSSValue* inValue, const CSSToLengthConversionData& conversionData, TransformOperations& outOperations)
{
if (!inValue || !inValue->isValueList()) {
outOperations.clear();
return false;
}
TransformOperations operations;
for (CSSValueListIterator i = inValue; i.hasMore(); i.advance()) {
CSSValue* currValue = i.value();
if (!currValue->isTransformValue())
continue;
CSSTransformValue* transformValue = toCSSTransformValue(i.value());
if (!transformValue->length())
continue;
bool haveNonPrimitiveValue = false;
for (unsigned j = 0; j < transformValue->length(); ++j) {
if (!transformValue->item(j)->isPrimitiveValue()) {
haveNonPrimitiveValue = true;
break;
}
}
if (haveNonPrimitiveValue)
continue;
CSSPrimitiveValue* firstValue = toCSSPrimitiveValue(transformValue->item(0));
switch (transformValue->operationType()) {
case CSSTransformValue::ScaleTransformOperation:
case CSSTransformValue::ScaleXTransformOperation:
case CSSTransformValue::ScaleYTransformOperation: {
double sx = 1.0;
double sy = 1.0;
if (transformValue->operationType() == CSSTransformValue::ScaleYTransformOperation)
sy = firstValue->getDoubleValue();
else {
sx = firstValue->getDoubleValue();
if (transformValue->operationType() != CSSTransformValue::ScaleXTransformOperation) {
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
sy = secondValue->getDoubleValue();
} else
sy = sx;
}
}
operations.operations().append(ScaleTransformOperation::create(sx, sy, 1.0, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::ScaleZTransformOperation:
case CSSTransformValue::Scale3DTransformOperation: {
double sx = 1.0;
double sy = 1.0;
double sz = 1.0;
if (transformValue->operationType() == CSSTransformValue::ScaleZTransformOperation)
sz = firstValue->getDoubleValue();
else if (transformValue->operationType() == CSSTransformValue::ScaleYTransformOperation)
sy = firstValue->getDoubleValue();
else {
sx = firstValue->getDoubleValue();
if (transformValue->operationType() != CSSTransformValue::ScaleXTransformOperation) {
if (transformValue->length() > 2) {
CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->item(2));
sz = thirdValue->getDoubleValue();
}
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
sy = secondValue->getDoubleValue();
} else
sy = sx;
}
}
operations.operations().append(ScaleTransformOperation::create(sx, sy, sz, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::TranslateTransformOperation:
case CSSTransformValue::TranslateXTransformOperation:
case CSSTransformValue::TranslateYTransformOperation: {
Length tx = Length(0, Fixed);
Length ty = Length(0, Fixed);
if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
ty = convertToFloatLength(firstValue, conversionData);
else {
tx = convertToFloatLength(firstValue, conversionData);
if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
ty = convertToFloatLength(secondValue, conversionData);
}
}
}
operations.operations().append(TranslateTransformOperation::create(tx, ty, 0, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::TranslateZTransformOperation:
case CSSTransformValue::Translate3DTransformOperation: {
Length tx = Length(0, Fixed);
Length ty = Length(0, Fixed);
double tz = 0;
if (transformValue->operationType() == CSSTransformValue::TranslateZTransformOperation)
tz = firstValue->computeLength<double>(conversionData);
else if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
ty = convertToFloatLength(firstValue, conversionData);
else {
tx = convertToFloatLength(firstValue, conversionData);
if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
if (transformValue->length() > 2) {
CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->item(2));
tz = thirdValue->computeLength<double>(conversionData);
}
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
ty = convertToFloatLength(secondValue, conversionData);
}
}
}
operations.operations().append(TranslateTransformOperation::create(tx, ty, tz, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::RotateTransformOperation: {
double angle = firstValue->computeDegrees();
operations.operations().append(RotateTransformOperation::create(0, 0, 1, angle, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::RotateXTransformOperation:
case CSSTransformValue::RotateYTransformOperation:
case CSSTransformValue::RotateZTransformOperation: {
double x = 0;
double y = 0;
double z = 0;
double angle = firstValue->computeDegrees();
if (transformValue->operationType() == CSSTransformValue::RotateXTransformOperation)
x = 1;
else if (transformValue->operationType() == CSSTransformValue::RotateYTransformOperation)
y = 1;
else
z = 1;
operations.operations().append(RotateTransformOperation::create(x, y, z, angle, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::Rotate3DTransformOperation: {
if (transformValue->length() < 4)
break;
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->item(2));
CSSPrimitiveValue* fourthValue = toCSSPrimitiveValue(transformValue->item(3));
double x = firstValue->getDoubleValue();
double y = secondValue->getDoubleValue();
double z = thirdValue->getDoubleValue();
double angle = fourthValue->computeDegrees();
operations.operations().append(RotateTransformOperation::create(x, y, z, angle, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::SkewTransformOperation:
case CSSTransformValue::SkewXTransformOperation:
case CSSTransformValue::SkewYTransformOperation: {
double angleX = 0;
double angleY = 0;
double angle = firstValue->computeDegrees();
if (transformValue->operationType() == CSSTransformValue::SkewYTransformOperation)
angleY = angle;
else {
angleX = angle;
if (transformValue->operationType() == CSSTransformValue::SkewTransformOperation) {
if (transformValue->length() > 1) {
CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
angleY = secondValue->computeDegrees();
}
}
}
operations.operations().append(SkewTransformOperation::create(angleX, angleY, getTransformOperationType(transformValue->operationType())));
break;
}
case CSSTransformValue::MatrixTransformOperation: {
if (transformValue->length() < 6)
break;
double a = firstValue->getDoubleValue();
double b = toCSSPrimitiveValue(transformValue->item(1))->getDoubleValue();
double c = toCSSPrimitiveValue(transformValue->item(2))->getDoubleValue();
double d = toCSSPrimitiveValue(transformValue->item(3))->getDoubleValue();
double e = toCSSPrimitiveValue(transformValue->item(4))->getDoubleValue();
double f = toCSSPrimitiveValue(transformValue->item(5))->getDoubleValue();
operations.operations().append(MatrixTransformOperation::create(a, b, c, d, e, f));
break;
}
case CSSTransformValue::Matrix3DTransformOperation: {
if (transformValue->length() < 16)
break;
TransformationMatrix matrix(toCSSPrimitiveValue(transformValue->item(0))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(1))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(2))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(3))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(4))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(5))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(6))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(7))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(8))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(9))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(10))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(11))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(12))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(13))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(14))->getDoubleValue(),
toCSSPrimitiveValue(transformValue->item(15))->getDoubleValue());
operations.operations().append(Matrix3DTransformOperation::create(matrix));
break;
}
case CSSTransformValue::PerspectiveTransformOperation: {
double p;
if (firstValue->isLength())
p = firstValue->computeLength<double>(conversionData);
else {
// This is a quirk that should go away when 3d transforms are finalized.
double val = firstValue->getDoubleValue();
if (val < 0)
return false;
p = clampToPositiveInteger(val);
}
operations.operations().append(PerspectiveTransformOperation::create(p));
break;
}
case CSSTransformValue::UnknownTransformOperation:
ASSERT_NOT_REACHED();
break;
}
}
outOperations = operations;
return true;
}
