OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2003 Lars Knoll (knoll@kde.org) | 2 * Copyright (C) 2003 Lars Knoll (knoll@kde.org) |
3 * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) | 3 * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) |
4 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
All rights reserved. | 4 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
All rights reserved. |
5 * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com> | 5 * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com> |
6 * Copyright (C) 2008 Eric Seidel <eric@webkit.org> | 6 * Copyright (C) 2008 Eric Seidel <eric@webkit.org> |
7 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmo
bile.com/) | 7 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmo
bile.com/) |
8 * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved. | 8 * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved. |
9 * Copyright (C) 2012 Intel Corporation. All rights reserved. | 9 * Copyright (C) 2012 Intel Corporation. All rights reserved. |
10 * | 10 * |
(...skipping 4004 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4015 | 4015 |
4016 ASSERT(position); | 4016 ASSERT(position); |
4017 if (overflowAlignmentKeyword) | 4017 if (overflowAlignmentKeyword) |
4018 addProperty(propId, createPrimitiveValuePair(position, overflowAlignment
Keyword), important); | 4018 addProperty(propId, createPrimitiveValuePair(position, overflowAlignment
Keyword), important); |
4019 else | 4019 else |
4020 addProperty(propId, position.release(), important); | 4020 addProperty(propId, position.release(), important); |
4021 | 4021 |
4022 return true; | 4022 return true; |
4023 } | 4023 } |
4024 | 4024 |
4025 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeRectangl
e(CSSParserValueList* args) | |
4026 { | |
4027 ASSERT(args); | |
4028 | |
4029 // rect(x, y, width, height, [[rx], ry]) | |
4030 if (args->size() != 7 && args->size() != 9 && args->size() != 11) | |
4031 return nullptr; | |
4032 | |
4033 RefPtrWillBeRawPtr<CSSBasicShapeRectangle> shape = CSSBasicShapeRectangle::c
reate(); | |
4034 | |
4035 unsigned argumentNumber = 0; | |
4036 CSSParserValue* argument = args->current(); | |
4037 while (argument) { | |
4038 Units unitFlags = FLength | FPercent; | |
4039 if (argumentNumber > 1) { | |
4040 // Arguments width, height, rx, and ry cannot be negative. | |
4041 unitFlags = unitFlags | FNonNeg; | |
4042 } | |
4043 if (!validUnit(argument, unitFlags)) | |
4044 return nullptr; | |
4045 | |
4046 RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericVal
ue(argument); | |
4047 ASSERT(argumentNumber < 6); | |
4048 switch (argumentNumber) { | |
4049 case 0: | |
4050 shape->setX(length); | |
4051 break; | |
4052 case 1: | |
4053 shape->setY(length); | |
4054 break; | |
4055 case 2: | |
4056 shape->setWidth(length); | |
4057 break; | |
4058 case 3: | |
4059 shape->setHeight(length); | |
4060 break; | |
4061 case 4: | |
4062 shape->setRadiusX(length); | |
4063 break; | |
4064 case 5: | |
4065 shape->setRadiusY(length); | |
4066 break; | |
4067 } | |
4068 argument = args->next(); | |
4069 if (argument) { | |
4070 if (!isComma(argument)) | |
4071 return nullptr; | |
4072 | |
4073 argument = args->next(); | |
4074 } | |
4075 argumentNumber++; | |
4076 } | |
4077 | |
4078 if (argumentNumber < 4) | |
4079 return nullptr; | |
4080 return shape; | |
4081 } | |
4082 | |
4083 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeInsetRec
tangle(CSSParserValueList* args) | |
4084 { | |
4085 ASSERT(args); | |
4086 | |
4087 // inset-rectangle(top, right, bottom, left, [[rx], ry]) | |
4088 if (args->size() != 7 && args->size() != 9 && args->size() != 11) | |
4089 return nullptr; | |
4090 | |
4091 RefPtrWillBeRawPtr<CSSBasicShapeInsetRectangle> shape = CSSBasicShapeInsetRe
ctangle::create(); | |
4092 | |
4093 unsigned argumentNumber = 0; | |
4094 CSSParserValue* argument = args->current(); | |
4095 while (argument) { | |
4096 Units unitFlags = FLength | FPercent | FNonNeg; | |
4097 if (!validUnit(argument, unitFlags)) | |
4098 return nullptr; | |
4099 | |
4100 RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericVal
ue(argument); | |
4101 ASSERT(argumentNumber < 6); | |
4102 switch (argumentNumber) { | |
4103 case 0: | |
4104 shape->setTop(length); | |
4105 break; | |
4106 case 1: | |
4107 shape->setRight(length); | |
4108 break; | |
4109 case 2: | |
4110 shape->setBottom(length); | |
4111 break; | |
4112 case 3: | |
4113 shape->setLeft(length); | |
4114 break; | |
4115 case 4: | |
4116 shape->setRadiusX(length); | |
4117 break; | |
4118 case 5: | |
4119 shape->setRadiusY(length); | |
4120 break; | |
4121 } | |
4122 argument = args->next(); | |
4123 if (argument) { | |
4124 if (!isComma(argument)) | |
4125 return nullptr; | |
4126 | |
4127 argument = args->next(); | |
4128 } | |
4129 argumentNumber++; | |
4130 } | |
4131 | |
4132 if (argumentNumber < 4) | |
4133 return nullptr; | |
4134 return shape; | |
4135 } | |
4136 | |
4137 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CS
SParserValue* value) | 4025 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CS
SParserValue* value) |
4138 { | 4026 { |
4139 if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide) | 4027 if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide) |
4140 return cssValuePool().createIdentifierValue(value->id); | 4028 return cssValuePool().createIdentifierValue(value->id); |
4141 | 4029 |
4142 if (!validUnit(value, FLength | FPercent | FNonNeg)) | 4030 if (!validUnit(value, FLength | FPercent | FNonNeg)) |
4143 return nullptr; | 4031 return nullptr; |
4144 | 4032 |
4145 return createPrimitiveNumericValue(value); | 4033 return createPrimitiveNumericValue(value); |
4146 } | 4034 } |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4185 return nullptr; | 4073 return nullptr; |
4186 } | 4074 } |
4187 } else { | 4075 } else { |
4188 return nullptr; | 4076 return nullptr; |
4189 } | 4077 } |
4190 } | 4078 } |
4191 | 4079 |
4192 return shape; | 4080 return shape; |
4193 } | 4081 } |
4194 | 4082 |
4195 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseDeprecatedBasicSha
peCircle(CSSParserValueList* args) | |
4196 { | |
4197 ASSERT(args); | |
4198 | |
4199 // circle(centerX, centerY, radius) | |
4200 if (args->size() != 5) | |
4201 return nullptr; | |
4202 | |
4203 RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeCircle> shape = CSSDeprecatedBasic
ShapeCircle::create(); | |
4204 | |
4205 unsigned argumentNumber = 0; | |
4206 CSSParserValue* argument = args->current(); | |
4207 while (argument) { | |
4208 Units unitFlags = FLength | FPercent; | |
4209 if (argumentNumber == 2) { | |
4210 // Argument radius cannot be negative. | |
4211 unitFlags = unitFlags | FNonNeg; | |
4212 } | |
4213 | |
4214 if (!validUnit(argument, unitFlags)) | |
4215 return nullptr; | |
4216 | |
4217 RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericVal
ue(argument); | |
4218 ASSERT(argumentNumber < 3); | |
4219 switch (argumentNumber) { | |
4220 case 0: | |
4221 shape->setCenterX(length); | |
4222 break; | |
4223 case 1: | |
4224 shape->setCenterY(length); | |
4225 break; | |
4226 case 2: | |
4227 shape->setRadius(length); | |
4228 break; | |
4229 } | |
4230 | |
4231 argument = args->next(); | |
4232 if (argument) { | |
4233 if (!isComma(argument)) | |
4234 return nullptr; | |
4235 argument = args->next(); | |
4236 } | |
4237 argumentNumber++; | |
4238 } | |
4239 | |
4240 if (argumentNumber < 3) | |
4241 return nullptr; | |
4242 return shape; | |
4243 } | |
4244 | |
4245 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(
CSSParserValueList* args) | 4083 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(
CSSParserValueList* args) |
4246 { | 4084 { |
4247 ASSERT(args); | 4085 ASSERT(args); |
4248 | 4086 |
4249 // ellipse(radiusX) | 4087 // ellipse(radiusX) |
4250 // ellipse(radiusX at <position> | 4088 // ellipse(radiusX at <position> |
4251 // ellipse(radiusX radiusY) | 4089 // ellipse(radiusX radiusY) |
4252 // ellipse(radiusX radiusY at <position> | 4090 // ellipse(radiusX radiusY at <position> |
4253 // ellipse(at <position>) | 4091 // ellipse(at <position>) |
4254 // where position defines centerX and centerY using a CSS <position> data ty
pe. | 4092 // where position defines centerX and centerY using a CSS <position> data ty
pe. |
(...skipping 29 matching lines...) Expand all Loading... |
4284 | 4122 |
4285 ASSERT(centerX->isPrimitiveValue()); | 4123 ASSERT(centerX->isPrimitiveValue()); |
4286 ASSERT(centerY->isPrimitiveValue()); | 4124 ASSERT(centerY->isPrimitiveValue()); |
4287 shape->setCenterX(toCSSPrimitiveValue(centerX.get())); | 4125 shape->setCenterX(toCSSPrimitiveValue(centerX.get())); |
4288 shape->setCenterY(toCSSPrimitiveValue(centerY.get())); | 4126 shape->setCenterY(toCSSPrimitiveValue(centerY.get())); |
4289 } | 4127 } |
4290 | 4128 |
4291 return shape; | 4129 return shape; |
4292 } | 4130 } |
4293 | 4131 |
4294 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseDeprecatedBasicSha
peEllipse(CSSParserValueList* args) | |
4295 { | |
4296 ASSERT(args); | |
4297 | |
4298 // ellipse(centerX, centerY, radiusX, radiusY) | |
4299 if (args->size() != 7) | |
4300 return nullptr; | |
4301 | |
4302 RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeEllipse> shape = CSSDeprecatedBasi
cShapeEllipse::create(); | |
4303 unsigned argumentNumber = 0; | |
4304 CSSParserValue* argument = args->current(); | |
4305 while (argument) { | |
4306 Units unitFlags = FLength | FPercent; | |
4307 if (argumentNumber > 1) { | |
4308 // Arguments radiusX and radiusY cannot be negative. | |
4309 unitFlags = unitFlags | FNonNeg; | |
4310 } | |
4311 if (!validUnit(argument, unitFlags)) | |
4312 return nullptr; | |
4313 | |
4314 RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericVal
ue(argument); | |
4315 ASSERT(argumentNumber < 4); | |
4316 switch (argumentNumber) { | |
4317 case 0: | |
4318 shape->setCenterX(length); | |
4319 break; | |
4320 case 1: | |
4321 shape->setCenterY(length); | |
4322 break; | |
4323 case 2: | |
4324 shape->setRadiusX(length); | |
4325 break; | |
4326 case 3: | |
4327 shape->setRadiusY(length); | |
4328 break; | |
4329 } | |
4330 | |
4331 argument = args->next(); | |
4332 if (argument) { | |
4333 if (!isComma(argument)) | |
4334 return nullptr; | |
4335 argument = args->next(); | |
4336 } | |
4337 argumentNumber++; | |
4338 } | |
4339 | |
4340 if (argumentNumber < 4) | |
4341 return nullptr; | |
4342 return shape; | |
4343 } | |
4344 | |
4345 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(
CSSParserValueList* args) | 4132 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(
CSSParserValueList* args) |
4346 { | 4133 { |
4347 ASSERT(args); | 4134 ASSERT(args); |
4348 | 4135 |
4349 unsigned size = args->size(); | 4136 unsigned size = args->size(); |
4350 if (!size) | 4137 if (!size) |
4351 return nullptr; | 4138 return nullptr; |
4352 | 4139 |
4353 RefPtrWillBeRawPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::creat
e(); | 4140 RefPtrWillBeRawPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::creat
e(); |
4354 | 4141 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4401 case CSSValueBorderBox: | 4188 case CSSValueBorderBox: |
4402 case CSSValueMarginBox: | 4189 case CSSValueMarginBox: |
4403 return true; | 4190 return true; |
4404 default: | 4191 default: |
4405 break; | 4192 break; |
4406 } | 4193 } |
4407 | 4194 |
4408 return false; | 4195 return false; |
4409 } | 4196 } |
4410 | 4197 |
4411 // FIXME This function is temporary to allow for an orderly transition between | |
4412 // the new CSS Shapes circle and ellipse syntax. It will be removed when the | |
4413 // old syntax is removed. | |
4414 static bool isDeprecatedBasicShape(CSSParserValueList* args) | |
4415 { | |
4416 for (unsigned i = args->currentIndex(); i < args->size(); ++i) { | |
4417 CSSParserValue* value = args->valueAt(i); | |
4418 if (isComma(value)) | |
4419 return true; | |
4420 } | |
4421 | |
4422 return false; | |
4423 } | |
4424 | |
4425 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSProper
tyID propId) | 4198 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSProper
tyID propId) |
4426 { | 4199 { |
4427 if (!RuntimeEnabledFeatures::cssShapesEnabled()) | 4200 if (!RuntimeEnabledFeatures::cssShapesEnabled()) |
4428 return nullptr; | 4201 return nullptr; |
4429 | 4202 |
4430 CSSParserValue* value = m_valueList->current(); | 4203 CSSParserValue* value = m_valueList->current(); |
4431 CSSValueID valueId = value->id; | 4204 CSSValueID valueId = value->id; |
4432 RefPtrWillBeRawPtr<CSSPrimitiveValue> boxValue; | 4205 RefPtrWillBeRawPtr<CSSPrimitiveValue> boxValue; |
4433 RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue; | 4206 RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue; |
4434 | 4207 |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4487 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape() | 4260 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape() |
4488 { | 4261 { |
4489 CSSParserValue* value = m_valueList->current(); | 4262 CSSParserValue* value = m_valueList->current(); |
4490 ASSERT(value->unit == CSSParserValue::Function); | 4263 ASSERT(value->unit == CSSParserValue::Function); |
4491 CSSParserValueList* args = value->function->args.get(); | 4264 CSSParserValueList* args = value->function->args.get(); |
4492 | 4265 |
4493 if (!args) | 4266 if (!args) |
4494 return nullptr; | 4267 return nullptr; |
4495 | 4268 |
4496 RefPtrWillBeRawPtr<CSSBasicShape> shape; | 4269 RefPtrWillBeRawPtr<CSSBasicShape> shape; |
4497 if (equalIgnoringCase(value->function->name, "rectangle(")) | 4270 if (equalIgnoringCase(value->function->name, "circle(")) |
4498 shape = parseBasicShapeRectangle(args); | 4271 shape = parseBasicShapeCircle(args); |
4499 else if (equalIgnoringCase(value->function->name, "circle(")) | |
4500 if (isDeprecatedBasicShape(args)) | |
4501 shape = parseDeprecatedBasicShapeCircle(args); | |
4502 else | |
4503 shape = parseBasicShapeCircle(args); | |
4504 else if (equalIgnoringCase(value->function->name, "ellipse(")) | 4272 else if (equalIgnoringCase(value->function->name, "ellipse(")) |
4505 if (isDeprecatedBasicShape(args)) | 4273 shape = parseBasicShapeEllipse(args); |
4506 shape = parseDeprecatedBasicShapeEllipse(args); | |
4507 else | |
4508 shape = parseBasicShapeEllipse(args); | |
4509 else if (equalIgnoringCase(value->function->name, "polygon(")) | 4274 else if (equalIgnoringCase(value->function->name, "polygon(")) |
4510 shape = parseBasicShapePolygon(args); | 4275 shape = parseBasicShapePolygon(args); |
4511 else if (equalIgnoringCase(value->function->name, "inset-rectangle(")) | |
4512 shape = parseBasicShapeInsetRectangle(args); | |
4513 else if (equalIgnoringCase(value->function->name, "inset(")) | 4276 else if (equalIgnoringCase(value->function->name, "inset(")) |
4514 shape = parseBasicShapeInset(args); | 4277 shape = parseBasicShapeInset(args); |
4515 | 4278 |
4516 if (!shape) | 4279 if (!shape) |
4517 return nullptr; | 4280 return nullptr; |
4518 | 4281 |
4519 m_valueList->next(); | 4282 m_valueList->next(); |
4520 | 4283 |
4521 return cssValuePool().createValue(shape.release()); | 4284 return cssValuePool().createValue(shape.release()); |
4522 } | 4285 } |
(...skipping 3932 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8455 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueFill)); | 8218 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueFill)); |
8456 if (!seenStroke) | 8219 if (!seenStroke) |
8457 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueStroke)
); | 8220 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueStroke)
); |
8458 if (!seenMarkers) | 8221 if (!seenMarkers) |
8459 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueMarkers
)); | 8222 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueMarkers
)); |
8460 | 8223 |
8461 return parsedValues.release(); | 8224 return parsedValues.release(); |
8462 } | 8225 } |
8463 | 8226 |
8464 } // namespace WebCore | 8227 } // namespace WebCore |
OLD | NEW |