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 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4184 return nullptr; | 4072 return nullptr; |
4185 } | 4073 } |
4186 } else { | 4074 } else { |
4187 return nullptr; | 4075 return nullptr; |
4188 } | 4076 } |
4189 } | 4077 } |
4190 | 4078 |
4191 return shape; | 4079 return shape; |
4192 } | 4080 } |
4193 | 4081 |
4194 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseDeprecatedBasicSha
peCircle(CSSParserValueList* args) | |
4195 { | |
4196 ASSERT(args); | |
4197 | |
4198 // circle(centerX, centerY, radius) | |
4199 if (args->size() != 5) | |
4200 return nullptr; | |
4201 | |
4202 RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeCircle> shape = CSSDeprecatedBasic
ShapeCircle::create(); | |
4203 | |
4204 unsigned argumentNumber = 0; | |
4205 CSSParserValue* argument = args->current(); | |
4206 while (argument) { | |
4207 Units unitFlags = FLength | FPercent; | |
4208 if (argumentNumber == 2) { | |
4209 // Argument radius cannot be negative. | |
4210 unitFlags = unitFlags | FNonNeg; | |
4211 } | |
4212 | |
4213 if (!validUnit(argument, unitFlags)) | |
4214 return nullptr; | |
4215 | |
4216 RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericVal
ue(argument); | |
4217 ASSERT(argumentNumber < 3); | |
4218 switch (argumentNumber) { | |
4219 case 0: | |
4220 shape->setCenterX(length); | |
4221 break; | |
4222 case 1: | |
4223 shape->setCenterY(length); | |
4224 break; | |
4225 case 2: | |
4226 shape->setRadius(length); | |
4227 break; | |
4228 } | |
4229 | |
4230 argument = args->next(); | |
4231 if (argument) { | |
4232 if (!isComma(argument)) | |
4233 return nullptr; | |
4234 argument = args->next(); | |
4235 } | |
4236 argumentNumber++; | |
4237 } | |
4238 | |
4239 if (argumentNumber < 3) | |
4240 return nullptr; | |
4241 return shape; | |
4242 } | |
4243 | |
4244 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(
CSSParserValueList* args) | 4082 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(
CSSParserValueList* args) |
4245 { | 4083 { |
4246 ASSERT(args); | 4084 ASSERT(args); |
4247 | 4085 |
4248 // ellipse(radiusX) | 4086 // ellipse(radiusX) |
4249 // ellipse(radiusX at <position>) | 4087 // ellipse(radiusX at <position>) |
4250 // ellipse(radiusX radiusY) | 4088 // ellipse(radiusX radiusY) |
4251 // ellipse(radiusX radiusY at <position>) | 4089 // ellipse(radiusX radiusY at <position>) |
4252 // ellipse(at <position>) | 4090 // ellipse(at <position>) |
4253 // where position defines centerX and centerY using a CSS <position> data ty
pe. | 4091 // where position defines centerX and centerY using a CSS <position> data ty
pe. |
(...skipping 28 matching lines...) Expand all Loading... |
4282 | 4120 |
4283 ASSERT(centerX->isPrimitiveValue()); | 4121 ASSERT(centerX->isPrimitiveValue()); |
4284 ASSERT(centerY->isPrimitiveValue()); | 4122 ASSERT(centerY->isPrimitiveValue()); |
4285 shape->setCenterX(toCSSPrimitiveValue(centerX.get())); | 4123 shape->setCenterX(toCSSPrimitiveValue(centerX.get())); |
4286 shape->setCenterY(toCSSPrimitiveValue(centerY.get())); | 4124 shape->setCenterY(toCSSPrimitiveValue(centerY.get())); |
4287 } | 4125 } |
4288 | 4126 |
4289 return shape; | 4127 return shape; |
4290 } | 4128 } |
4291 | 4129 |
4292 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseDeprecatedBasicSha
peEllipse(CSSParserValueList* args) | |
4293 { | |
4294 ASSERT(args); | |
4295 | |
4296 // ellipse(centerX, centerY, radiusX, radiusY) | |
4297 if (args->size() != 7) | |
4298 return nullptr; | |
4299 | |
4300 RefPtrWillBeRawPtr<CSSDeprecatedBasicShapeEllipse> shape = CSSDeprecatedBasi
cShapeEllipse::create(); | |
4301 unsigned argumentNumber = 0; | |
4302 CSSParserValue* argument = args->current(); | |
4303 while (argument) { | |
4304 Units unitFlags = FLength | FPercent; | |
4305 if (argumentNumber > 1) { | |
4306 // Arguments radiusX and radiusY cannot be negative. | |
4307 unitFlags = unitFlags | FNonNeg; | |
4308 } | |
4309 if (!validUnit(argument, unitFlags)) | |
4310 return nullptr; | |
4311 | |
4312 RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericVal
ue(argument); | |
4313 ASSERT(argumentNumber < 4); | |
4314 switch (argumentNumber) { | |
4315 case 0: | |
4316 shape->setCenterX(length); | |
4317 break; | |
4318 case 1: | |
4319 shape->setCenterY(length); | |
4320 break; | |
4321 case 2: | |
4322 shape->setRadiusX(length); | |
4323 break; | |
4324 case 3: | |
4325 shape->setRadiusY(length); | |
4326 break; | |
4327 } | |
4328 | |
4329 argument = args->next(); | |
4330 if (argument) { | |
4331 if (!isComma(argument)) | |
4332 return nullptr; | |
4333 argument = args->next(); | |
4334 } | |
4335 argumentNumber++; | |
4336 } | |
4337 | |
4338 if (argumentNumber < 4) | |
4339 return nullptr; | |
4340 return shape; | |
4341 } | |
4342 | |
4343 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(
CSSParserValueList* args) | 4130 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(
CSSParserValueList* args) |
4344 { | 4131 { |
4345 ASSERT(args); | 4132 ASSERT(args); |
4346 | 4133 |
4347 unsigned size = args->size(); | 4134 unsigned size = args->size(); |
4348 if (!size) | 4135 if (!size) |
4349 return nullptr; | 4136 return nullptr; |
4350 | 4137 |
4351 RefPtrWillBeRawPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::creat
e(); | 4138 RefPtrWillBeRawPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::creat
e(); |
4352 | 4139 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4399 case CSSValueBorderBox: | 4186 case CSSValueBorderBox: |
4400 case CSSValueMarginBox: | 4187 case CSSValueMarginBox: |
4401 return true; | 4188 return true; |
4402 default: | 4189 default: |
4403 break; | 4190 break; |
4404 } | 4191 } |
4405 | 4192 |
4406 return false; | 4193 return false; |
4407 } | 4194 } |
4408 | 4195 |
4409 // FIXME This function is temporary to allow for an orderly transition between | |
4410 // the new CSS Shapes circle and ellipse syntax. It will be removed when the | |
4411 // old syntax is removed. | |
4412 static bool isDeprecatedBasicShape(CSSParserValueList* args) | |
4413 { | |
4414 for (unsigned i = args->currentIndex(); i < args->size(); ++i) { | |
4415 CSSParserValue* value = args->valueAt(i); | |
4416 if (isComma(value)) | |
4417 return true; | |
4418 } | |
4419 | |
4420 return false; | |
4421 } | |
4422 | |
4423 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSProper
tyID propId) | 4196 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSProper
tyID propId) |
4424 { | 4197 { |
4425 if (!RuntimeEnabledFeatures::cssShapesEnabled()) | 4198 if (!RuntimeEnabledFeatures::cssShapesEnabled()) |
4426 return nullptr; | 4199 return nullptr; |
4427 | 4200 |
4428 CSSParserValue* value = m_valueList->current(); | 4201 CSSParserValue* value = m_valueList->current(); |
4429 CSSValueID valueId = value->id; | 4202 CSSValueID valueId = value->id; |
4430 RefPtrWillBeRawPtr<CSSPrimitiveValue> boxValue; | 4203 RefPtrWillBeRawPtr<CSSPrimitiveValue> boxValue; |
4431 RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue; | 4204 RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue; |
4432 | 4205 |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4485 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape() | 4258 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape() |
4486 { | 4259 { |
4487 CSSParserValue* value = m_valueList->current(); | 4260 CSSParserValue* value = m_valueList->current(); |
4488 ASSERT(value->unit == CSSParserValue::Function); | 4261 ASSERT(value->unit == CSSParserValue::Function); |
4489 CSSParserValueList* args = value->function->args.get(); | 4262 CSSParserValueList* args = value->function->args.get(); |
4490 | 4263 |
4491 if (!args) | 4264 if (!args) |
4492 return nullptr; | 4265 return nullptr; |
4493 | 4266 |
4494 RefPtrWillBeRawPtr<CSSBasicShape> shape; | 4267 RefPtrWillBeRawPtr<CSSBasicShape> shape; |
4495 if (equalIgnoringCase(value->function->name, "rectangle(")) | 4268 if (equalIgnoringCase(value->function->name, "circle(")) |
4496 shape = parseBasicShapeRectangle(args); | 4269 shape = parseBasicShapeCircle(args); |
4497 else if (equalIgnoringCase(value->function->name, "circle(")) | |
4498 if (isDeprecatedBasicShape(args)) | |
4499 shape = parseDeprecatedBasicShapeCircle(args); | |
4500 else | |
4501 shape = parseBasicShapeCircle(args); | |
4502 else if (equalIgnoringCase(value->function->name, "ellipse(")) | 4270 else if (equalIgnoringCase(value->function->name, "ellipse(")) |
4503 if (isDeprecatedBasicShape(args)) | 4271 shape = parseBasicShapeEllipse(args); |
4504 shape = parseDeprecatedBasicShapeEllipse(args); | |
4505 else | |
4506 shape = parseBasicShapeEllipse(args); | |
4507 else if (equalIgnoringCase(value->function->name, "polygon(")) | 4272 else if (equalIgnoringCase(value->function->name, "polygon(")) |
4508 shape = parseBasicShapePolygon(args); | 4273 shape = parseBasicShapePolygon(args); |
4509 else if (equalIgnoringCase(value->function->name, "inset-rectangle(")) | |
4510 shape = parseBasicShapeInsetRectangle(args); | |
4511 else if (equalIgnoringCase(value->function->name, "inset(")) | 4274 else if (equalIgnoringCase(value->function->name, "inset(")) |
4512 shape = parseBasicShapeInset(args); | 4275 shape = parseBasicShapeInset(args); |
4513 | 4276 |
4514 if (!shape) | 4277 if (!shape) |
4515 return nullptr; | 4278 return nullptr; |
4516 | 4279 |
4517 m_valueList->next(); | 4280 m_valueList->next(); |
4518 | 4281 |
4519 return cssValuePool().createValue(shape.release()); | 4282 return cssValuePool().createValue(shape.release()); |
4520 } | 4283 } |
(...skipping 3932 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8453 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueFill)); | 8216 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueFill)); |
8454 if (!seenStroke) | 8217 if (!seenStroke) |
8455 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueStroke)
); | 8218 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueStroke)
); |
8456 if (!seenMarkers) | 8219 if (!seenMarkers) |
8457 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueMarkers
)); | 8220 parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueMarkers
)); |
8458 | 8221 |
8459 return parsedValues.release(); | 8222 return parsedValues.release(); |
8460 } | 8223 } |
8461 | 8224 |
8462 } // namespace WebCore | 8225 } // namespace WebCore |
OLD | NEW |