| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "content/shell/renderer/test_runner/mock_web_theme_engine.h" | |
| 6 | |
| 7 #if !defined(OS_MACOSX) | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "skia/ext/platform_canvas.h" | |
| 11 #include "third_party/WebKit/public/platform/WebRect.h" | |
| 12 #include "third_party/WebKit/public/platform/WebSize.h" | |
| 13 #include "third_party/skia/include/core/SkRect.h" | |
| 14 | |
| 15 using blink::WebCanvas; | |
| 16 using blink::WebColor; | |
| 17 using blink::WebRect; | |
| 18 using blink::WebThemeEngine; | |
| 19 | |
| 20 namespace content { | |
| 21 | |
| 22 namespace { | |
| 23 | |
| 24 const SkColor edgeColor = SK_ColorBLACK; | |
| 25 const SkColor readOnlyColor = SkColorSetRGB(0xe9, 0xc2, 0xa6); | |
| 26 | |
| 27 } // namespace | |
| 28 | |
| 29 SkColor bgColors(WebThemeEngine::State state) { | |
| 30 switch (state) { | |
| 31 case WebThemeEngine::StateDisabled: | |
| 32 return SkColorSetRGB(0xc9, 0xc9, 0xc9); | |
| 33 case WebThemeEngine::StateHover: | |
| 34 return SkColorSetRGB(0x43, 0xf9, 0xff); | |
| 35 case WebThemeEngine::StateNormal: | |
| 36 return SkColorSetRGB(0x89, 0xc4, 0xff); | |
| 37 case WebThemeEngine::StatePressed: | |
| 38 return SkColorSetRGB(0xa9, 0xff, 0x12); | |
| 39 case WebThemeEngine::StateFocused: | |
| 40 return SkColorSetRGB(0x00, 0xf3, 0xac); | |
| 41 case WebThemeEngine::StateReadonly: | |
| 42 return SkColorSetRGB(0xf3, 0xe0, 0xd0); | |
| 43 default: | |
| 44 NOTREACHED(); | |
| 45 } | |
| 46 return SkColorSetRGB(0x00, 0x00, 0xff); | |
| 47 } | |
| 48 | |
| 49 blink::WebSize MockWebThemeEngine::getSize(WebThemeEngine::Part part) { | |
| 50 // FIXME: We use this constant to indicate we are being asked for the size o
f | |
| 51 // a part that we don't expect to be asked about. We return a garbage value | |
| 52 // rather than just asserting because this code doesn't have access to eithe
r | |
| 53 // WTF or base to raise an assertion or do any logging :(. | |
| 54 const blink::WebSize invalidPartSize = blink::WebSize(100, 100); | |
| 55 | |
| 56 switch (part) { | |
| 57 case WebThemeEngine::PartScrollbarLeftArrow: | |
| 58 return blink::WebSize(17, 15); | |
| 59 case WebThemeEngine::PartScrollbarRightArrow: | |
| 60 return invalidPartSize; | |
| 61 case WebThemeEngine::PartScrollbarUpArrow: | |
| 62 return blink::WebSize(15, 17); | |
| 63 case WebThemeEngine::PartScrollbarDownArrow: | |
| 64 return invalidPartSize; | |
| 65 case WebThemeEngine::PartScrollbarHorizontalThumb: | |
| 66 return blink::WebSize(15, 15); | |
| 67 case WebThemeEngine::PartScrollbarVerticalThumb: | |
| 68 return blink::WebSize(15, 15); | |
| 69 case WebThemeEngine::PartScrollbarHorizontalTrack: | |
| 70 return blink::WebSize(0, 15); | |
| 71 case WebThemeEngine::PartScrollbarVerticalTrack: | |
| 72 return blink::WebSize(15, 0); | |
| 73 case WebThemeEngine::PartCheckbox: | |
| 74 case WebThemeEngine::PartRadio: | |
| 75 return blink::WebSize(13, 13); | |
| 76 case WebThemeEngine::PartSliderThumb: | |
| 77 return blink::WebSize(11, 21); | |
| 78 case WebThemeEngine::PartInnerSpinButton: | |
| 79 return blink::WebSize(15, 8); | |
| 80 default: | |
| 81 return invalidPartSize; | |
| 82 } | |
| 83 } | |
| 84 | |
| 85 static SkIRect webRectToSkIRect(const WebRect& webRect) { | |
| 86 SkIRect irect; | |
| 87 irect.set(webRect.x, webRect.y, | |
| 88 webRect.x + webRect.width - 1, webRect.y + webRect.height - 1); | |
| 89 return irect; | |
| 90 } | |
| 91 | |
| 92 static SkIRect validate(const SkIRect& rect, WebThemeEngine::Part part) { | |
| 93 switch (part) { | |
| 94 case WebThemeEngine::PartCheckbox: | |
| 95 case WebThemeEngine::PartRadio: { | |
| 96 SkIRect retval = rect; | |
| 97 | |
| 98 // The maximum width and height is 13. | |
| 99 // Center the square in the passed rectangle. | |
| 100 const int maxControlSize = 13; | |
| 101 int controlSize = std::min(rect.width(), rect.height()); | |
| 102 controlSize = std::min(controlSize, maxControlSize); | |
| 103 | |
| 104 retval.fLeft = rect.fLeft + (rect.width() / 2) - (controlSize / 2); | |
| 105 retval.fRight = retval.fLeft + controlSize - 1; | |
| 106 retval.fTop = rect.fTop + (rect.height() / 2) - (controlSize / 2); | |
| 107 retval.fBottom = retval.fTop + controlSize - 1; | |
| 108 | |
| 109 return retval; | |
| 110 } | |
| 111 default: | |
| 112 return rect; | |
| 113 } | |
| 114 } | |
| 115 | |
| 116 void box(SkCanvas* canvas, const SkIRect& rect, SkColor fillColor) { | |
| 117 SkPaint paint; | |
| 118 | |
| 119 paint.setStyle(SkPaint::kFill_Style); | |
| 120 paint.setColor(fillColor); | |
| 121 canvas->drawIRect(rect, paint); | |
| 122 | |
| 123 paint.setColor(edgeColor); | |
| 124 paint.setStyle(SkPaint::kStroke_Style); | |
| 125 canvas->drawIRect(rect, paint); | |
| 126 } | |
| 127 | |
| 128 void line(SkCanvas* canvas, int x0, int y0, int x1, int y1, SkColor color) { | |
| 129 SkPaint paint; | |
| 130 paint.setColor(color); | |
| 131 canvas->drawLine(SkIntToScalar(x0), | |
| 132 SkIntToScalar(y0), | |
| 133 SkIntToScalar(x1), | |
| 134 SkIntToScalar(y1), | |
| 135 paint); | |
| 136 } | |
| 137 | |
| 138 void triangle(SkCanvas* canvas, | |
| 139 int x0, | |
| 140 int y0, | |
| 141 int x1, | |
| 142 int y1, | |
| 143 int x2, | |
| 144 int y2, | |
| 145 SkColor color) { | |
| 146 SkPath path; | |
| 147 SkPaint paint; | |
| 148 | |
| 149 paint.setColor(color); | |
| 150 paint.setStyle(SkPaint::kFill_Style); | |
| 151 path.incReserve(4); | |
| 152 path.moveTo(SkIntToScalar(x0), SkIntToScalar(y0)); | |
| 153 path.lineTo(SkIntToScalar(x1), SkIntToScalar(y1)); | |
| 154 path.lineTo(SkIntToScalar(x2), SkIntToScalar(y2)); | |
| 155 path.close(); | |
| 156 canvas->drawPath(path, paint); | |
| 157 | |
| 158 paint.setColor(edgeColor); | |
| 159 paint.setStyle(SkPaint::kStroke_Style); | |
| 160 canvas->drawPath(path, paint); | |
| 161 } | |
| 162 | |
| 163 void roundRect(SkCanvas* canvas, SkIRect irect, SkColor color) { | |
| 164 SkRect rect; | |
| 165 SkScalar radius = SkIntToScalar(5); | |
| 166 SkPaint paint; | |
| 167 | |
| 168 rect.set(irect); | |
| 169 paint.setColor(color); | |
| 170 paint.setStyle(SkPaint::kFill_Style); | |
| 171 canvas->drawRoundRect(rect, radius, radius, paint); | |
| 172 | |
| 173 paint.setColor(edgeColor); | |
| 174 paint.setStyle(SkPaint::kStroke_Style); | |
| 175 canvas->drawRoundRect(rect, radius, radius, paint); | |
| 176 } | |
| 177 | |
| 178 void oval(SkCanvas* canvas, SkIRect irect, SkColor color) { | |
| 179 SkRect rect; | |
| 180 SkPaint paint; | |
| 181 | |
| 182 rect.set(irect); | |
| 183 paint.setColor(color); | |
| 184 paint.setStyle(SkPaint::kFill_Style); | |
| 185 canvas->drawOval(rect, paint); | |
| 186 | |
| 187 paint.setColor(edgeColor); | |
| 188 paint.setStyle(SkPaint::kStroke_Style); | |
| 189 canvas->drawOval(rect, paint); | |
| 190 } | |
| 191 | |
| 192 void circle(SkCanvas* canvas, SkIRect irect, SkScalar radius, SkColor color) { | |
| 193 int left = irect.fLeft; | |
| 194 int width = irect.width(); | |
| 195 int height = irect.height(); | |
| 196 int top = irect.fTop; | |
| 197 | |
| 198 SkScalar cy = SkIntToScalar(top + height / 2); | |
| 199 SkScalar cx = SkIntToScalar(left + width / 2); | |
| 200 SkPaint paint; | |
| 201 | |
| 202 paint.setColor(color); | |
| 203 paint.setStyle(SkPaint::kFill_Style); | |
| 204 canvas->drawCircle(cx, cy, radius, paint); | |
| 205 | |
| 206 paint.setColor(edgeColor); | |
| 207 paint.setStyle(SkPaint::kStroke_Style); | |
| 208 canvas->drawCircle(cx, cy, radius, paint); | |
| 209 } | |
| 210 | |
| 211 void nestedBoxes(SkCanvas* canvas, | |
| 212 SkIRect irect, | |
| 213 int indentLeft, | |
| 214 int indentTop, | |
| 215 int indentRight, | |
| 216 int indentBottom, | |
| 217 SkColor outerColor, | |
| 218 SkColor innerColor) { | |
| 219 SkIRect lirect; | |
| 220 box(canvas, irect, outerColor); | |
| 221 lirect.set(irect.fLeft + indentLeft, | |
| 222 irect.fTop + indentTop, | |
| 223 irect.fRight - indentRight, | |
| 224 irect.fBottom - indentBottom); | |
| 225 box(canvas, lirect, innerColor); | |
| 226 } | |
| 227 | |
| 228 void insetBox(SkCanvas* canvas, | |
| 229 SkIRect irect, | |
| 230 int indentLeft, | |
| 231 int indentTop, | |
| 232 int indentRight, | |
| 233 int indentBottom, | |
| 234 SkColor color) { | |
| 235 SkIRect lirect; | |
| 236 lirect.set(irect.fLeft + indentLeft, | |
| 237 irect.fTop + indentTop, | |
| 238 irect.fRight - indentRight, | |
| 239 irect.fBottom - indentBottom); | |
| 240 box(canvas, lirect, color); | |
| 241 } | |
| 242 | |
| 243 void markState(SkCanvas* canvas, SkIRect irect, WebThemeEngine::State state) { | |
| 244 int left = irect.fLeft; | |
| 245 int right = irect.fRight; | |
| 246 int top = irect.fTop; | |
| 247 int bottom = irect.fBottom; | |
| 248 | |
| 249 // The length of a triangle side for the corner marks. | |
| 250 const int triangleSize = 5; | |
| 251 | |
| 252 switch (state) { | |
| 253 case WebThemeEngine::StateDisabled: | |
| 254 case WebThemeEngine::StateNormal: | |
| 255 // Don't visually mark these states (color is enough). | |
| 256 break; | |
| 257 | |
| 258 case WebThemeEngine::StateReadonly: { | |
| 259 // The horizontal lines in a read only control are spaced by this amount
. | |
| 260 const int readOnlyLineOffset = 5; | |
| 261 | |
| 262 // Drawing lines across the control. | |
| 263 for (int i = top + readOnlyLineOffset; i < bottom; i += readOnlyLineOffs
et) | |
| 264 line(canvas, left + 1, i, right - 1, i, readOnlyColor); | |
| 265 break; | |
| 266 } | |
| 267 case WebThemeEngine::StateHover: | |
| 268 // Draw a triangle in the upper left corner of the control. (Win's "hot"
) | |
| 269 triangle(canvas, | |
| 270 left, top, | |
| 271 left + triangleSize, top, | |
| 272 left, top + triangleSize, | |
| 273 edgeColor); | |
| 274 break; | |
| 275 | |
| 276 case WebThemeEngine::StateFocused: | |
| 277 // Draw a triangle in the bottom right corner of the control. | |
| 278 triangle(canvas, | |
| 279 right, bottom, | |
| 280 right - triangleSize, bottom, | |
| 281 right, bottom - triangleSize, | |
| 282 edgeColor); | |
| 283 break; | |
| 284 | |
| 285 case WebThemeEngine::StatePressed: | |
| 286 // Draw a triangle in the bottom left corner of the control. | |
| 287 triangle(canvas, | |
| 288 left, bottom, | |
| 289 left, bottom - triangleSize, | |
| 290 left + triangleSize, bottom, | |
| 291 edgeColor); | |
| 292 break; | |
| 293 | |
| 294 default: | |
| 295 // FIXME: Should we do something here to indicate that we got an invalid
state? | |
| 296 // Unfortunately, we can't assert because we don't have access to WTF or
base. | |
| 297 break; | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 void MockWebThemeEngine::paint(blink::WebCanvas* canvas, | |
| 302 WebThemeEngine::Part part, | |
| 303 WebThemeEngine::State state, | |
| 304 const blink::WebRect& rect, | |
| 305 const WebThemeEngine::ExtraParams* extraParams) { | |
| 306 SkIRect irect = webRectToSkIRect(rect); | |
| 307 SkPaint paint; | |
| 308 | |
| 309 // Indent amounts for the check in a checkbox or radio button. | |
| 310 const int checkIndent = 3; | |
| 311 | |
| 312 // Indent amounts for short and long sides of the scrollbar notches. | |
| 313 const int notchLongOffset = 1; | |
| 314 const int notchShortOffset = 4; | |
| 315 const int noOffset = 0; | |
| 316 | |
| 317 // Indent amounts for the short and long sides of a scroll thumb box. | |
| 318 const int thumbLongIndent = 0; | |
| 319 const int thumbShortIndent = 2; | |
| 320 | |
| 321 // Indents for the crosshatch on a scroll grip. | |
| 322 const int gripLongIndent = 3; | |
| 323 const int gripShortIndent = 5; | |
| 324 | |
| 325 // Indents for the the slider track. | |
| 326 const int sliderIndent = 2; | |
| 327 | |
| 328 int halfHeight = irect.height() / 2; | |
| 329 int halfWidth = irect.width() / 2; | |
| 330 int quarterHeight = irect.height() / 4; | |
| 331 int quarterWidth = irect.width() / 4; | |
| 332 int left = irect.fLeft; | |
| 333 int right = irect.fRight; | |
| 334 int top = irect.fTop; | |
| 335 int bottom = irect.fBottom; | |
| 336 | |
| 337 switch (part) { | |
| 338 case WebThemeEngine::PartScrollbarDownArrow: | |
| 339 box(canvas, irect, bgColors(state)); | |
| 340 triangle(canvas, | |
| 341 left + quarterWidth, top + quarterHeight, | |
| 342 right - quarterWidth, top + quarterHeight, | |
| 343 left + halfWidth, bottom - quarterHeight, | |
| 344 edgeColor); | |
| 345 markState(canvas, irect, state); | |
| 346 break; | |
| 347 | |
| 348 case WebThemeEngine::PartScrollbarLeftArrow: | |
| 349 box(canvas, irect, bgColors(state)); | |
| 350 triangle(canvas, | |
| 351 right - quarterWidth, top + quarterHeight, | |
| 352 right - quarterWidth, bottom - quarterHeight, | |
| 353 left + quarterWidth, top + halfHeight, | |
| 354 edgeColor); | |
| 355 break; | |
| 356 | |
| 357 case WebThemeEngine::PartScrollbarRightArrow: | |
| 358 box(canvas, irect, bgColors(state)); | |
| 359 triangle(canvas, | |
| 360 left + quarterWidth, top + quarterHeight, | |
| 361 right - quarterWidth, top + halfHeight, | |
| 362 left + quarterWidth, bottom - quarterHeight, | |
| 363 edgeColor); | |
| 364 break; | |
| 365 | |
| 366 case WebThemeEngine::PartScrollbarUpArrow: | |
| 367 box(canvas, irect, bgColors(state)); | |
| 368 triangle(canvas, | |
| 369 left + quarterWidth, bottom - quarterHeight, | |
| 370 left + halfWidth, top + quarterHeight, | |
| 371 right - quarterWidth, bottom - quarterHeight, | |
| 372 edgeColor); | |
| 373 markState(canvas, irect, state); | |
| 374 break; | |
| 375 | |
| 376 case WebThemeEngine::PartScrollbarHorizontalThumb: { | |
| 377 // Draw a narrower box on top of the outside box. | |
| 378 nestedBoxes(canvas, irect, thumbLongIndent, thumbShortIndent, | |
| 379 thumbLongIndent, thumbShortIndent, | |
| 380 bgColors(state), bgColors(state)); | |
| 381 // Draw a horizontal crosshatch for the grip. | |
| 382 int longOffset = halfWidth - gripLongIndent; | |
| 383 line(canvas, | |
| 384 left + gripLongIndent, top + halfHeight, | |
| 385 right - gripLongIndent, top + halfHeight, | |
| 386 edgeColor); | |
| 387 line(canvas, | |
| 388 left + longOffset, top + gripShortIndent, | |
| 389 left + longOffset, bottom - gripShortIndent, | |
| 390 edgeColor); | |
| 391 line(canvas, | |
| 392 right - longOffset, top + gripShortIndent, | |
| 393 right - longOffset, bottom - gripShortIndent, | |
| 394 edgeColor); | |
| 395 markState(canvas, irect, state); | |
| 396 break; | |
| 397 } | |
| 398 | |
| 399 case WebThemeEngine::PartScrollbarVerticalThumb: { | |
| 400 // Draw a shorter box on top of the outside box. | |
| 401 nestedBoxes(canvas, irect, thumbShortIndent, thumbLongIndent, | |
| 402 thumbShortIndent, thumbLongIndent, | |
| 403 bgColors(state), bgColors(state)); | |
| 404 // Draw a vertical crosshatch for the grip. | |
| 405 int longOffset = halfHeight - gripLongIndent; | |
| 406 line(canvas, | |
| 407 left + halfWidth, top + gripLongIndent, | |
| 408 left + halfWidth, bottom - gripLongIndent, | |
| 409 edgeColor); | |
| 410 line(canvas, | |
| 411 left + gripShortIndent, top + longOffset, | |
| 412 right - gripShortIndent, top + longOffset, | |
| 413 edgeColor); | |
| 414 line(canvas, | |
| 415 left + gripShortIndent, bottom - longOffset, | |
| 416 right - gripShortIndent, bottom - longOffset, | |
| 417 edgeColor); | |
| 418 markState(canvas, irect, state); | |
| 419 break; | |
| 420 } | |
| 421 | |
| 422 case WebThemeEngine::PartScrollbarHorizontalTrack: { | |
| 423 int longOffset = halfHeight - notchLongOffset; | |
| 424 int shortOffset = irect.width() - notchShortOffset; | |
| 425 box(canvas, irect, bgColors(state)); | |
| 426 // back, notch on right | |
| 427 insetBox(canvas, | |
| 428 irect, | |
| 429 noOffset, | |
| 430 longOffset, | |
| 431 shortOffset, | |
| 432 longOffset, | |
| 433 edgeColor); | |
| 434 // forward, notch on right | |
| 435 insetBox(canvas, | |
| 436 irect, | |
| 437 shortOffset, | |
| 438 longOffset, | |
| 439 noOffset, | |
| 440 longOffset, | |
| 441 edgeColor); | |
| 442 markState(canvas, irect, state); | |
| 443 break; | |
| 444 } | |
| 445 | |
| 446 case WebThemeEngine::PartScrollbarVerticalTrack: { | |
| 447 int longOffset = halfWidth - notchLongOffset; | |
| 448 int shortOffset = irect.height() - notchShortOffset; | |
| 449 box(canvas, irect, bgColors(state)); | |
| 450 // back, notch at top | |
| 451 insetBox(canvas, | |
| 452 irect, | |
| 453 longOffset, | |
| 454 noOffset, | |
| 455 longOffset, | |
| 456 shortOffset, | |
| 457 edgeColor); | |
| 458 // forward, notch at bottom | |
| 459 insetBox(canvas, | |
| 460 irect, | |
| 461 longOffset, | |
| 462 shortOffset, | |
| 463 longOffset, | |
| 464 noOffset, | |
| 465 edgeColor); | |
| 466 markState(canvas, irect, state); | |
| 467 break; | |
| 468 } | |
| 469 | |
| 470 case WebThemeEngine::PartScrollbarCorner: { | |
| 471 SkIRect cornerRect = {rect.x, rect.y, rect.x + rect.width, rect.y + rect
.height}; | |
| 472 paint.setColor(SK_ColorWHITE); | |
| 473 paint.setStyle(SkPaint::kFill_Style); | |
| 474 paint.setXfermodeMode(SkXfermode::kSrc_Mode); | |
| 475 paint.setAntiAlias(true); | |
| 476 canvas->drawIRect(cornerRect, paint); | |
| 477 break; | |
| 478 } | |
| 479 | |
| 480 case WebThemeEngine::PartCheckbox: | |
| 481 if (extraParams->button.indeterminate) { | |
| 482 nestedBoxes(canvas, irect, | |
| 483 checkIndent, halfHeight, | |
| 484 checkIndent, halfHeight, | |
| 485 bgColors(state), edgeColor); | |
| 486 } else if (extraParams->button.checked) { | |
| 487 irect = validate(irect, part); | |
| 488 nestedBoxes(canvas, irect, | |
| 489 checkIndent, checkIndent, | |
| 490 checkIndent, checkIndent, | |
| 491 bgColors(state), edgeColor); | |
| 492 } else { | |
| 493 irect = validate(irect, part); | |
| 494 box(canvas, irect, bgColors(state)); | |
| 495 } | |
| 496 break; | |
| 497 | |
| 498 case WebThemeEngine::PartRadio: | |
| 499 irect = validate(irect, part); | |
| 500 halfHeight = irect.height() / 2; | |
| 501 if (extraParams->button.checked) { | |
| 502 circle(canvas, irect, SkIntToScalar(halfHeight), bgColors(state)); | |
| 503 circle(canvas, irect, SkIntToScalar(halfHeight - checkIndent), edgeC
olor); | |
| 504 } else { | |
| 505 circle(canvas, irect, SkIntToScalar(halfHeight), bgColors(state)); | |
| 506 } | |
| 507 break; | |
| 508 | |
| 509 case WebThemeEngine::PartButton: | |
| 510 roundRect(canvas, irect, bgColors(state)); | |
| 511 markState(canvas, irect, state); | |
| 512 break; | |
| 513 | |
| 514 case WebThemeEngine::PartTextField: | |
| 515 paint.setColor(extraParams->textField.backgroundColor); | |
| 516 paint.setStyle(SkPaint::kFill_Style); | |
| 517 canvas->drawIRect(irect, paint); | |
| 518 | |
| 519 paint.setColor(edgeColor); | |
| 520 paint.setStyle(SkPaint::kStroke_Style); | |
| 521 canvas->drawIRect(irect, paint); | |
| 522 | |
| 523 markState(canvas, irect, state); | |
| 524 break; | |
| 525 | |
| 526 case WebThemeEngine::PartMenuList: | |
| 527 if (extraParams->menuList.fillContentArea) { | |
| 528 box(canvas, irect, extraParams->menuList.backgroundColor); | |
| 529 } else { | |
| 530 SkPaint paint; | |
| 531 paint.setColor(edgeColor); | |
| 532 paint.setStyle(SkPaint::kStroke_Style); | |
| 533 canvas->drawIRect(irect, paint); | |
| 534 } | |
| 535 | |
| 536 // clip the drop-down arrow to be inside the select box | |
| 537 if (extraParams->menuList.arrowX - 4 > irect.fLeft) | |
| 538 irect.fLeft = extraParams->menuList.arrowX - 4; | |
| 539 if (extraParams->menuList.arrowX + 12 < irect.fRight) | |
| 540 irect.fRight = extraParams->menuList.arrowX + 12; | |
| 541 | |
| 542 irect.fTop = extraParams->menuList.arrowY - (extraParams->menuList.arrow
Height) / 2; | |
| 543 irect.fBottom = extraParams->menuList.arrowY + (extraParams->menuList.ar
rowHeight - 1) / 2; | |
| 544 halfWidth = irect.width() / 2; | |
| 545 quarterWidth = irect.width() / 4; | |
| 546 | |
| 547 if (state == WebThemeEngine::StateFocused) // FIXME: draw differenty? | |
| 548 state = WebThemeEngine::StateNormal; | |
| 549 box(canvas, irect, bgColors(state)); | |
| 550 triangle(canvas, | |
| 551 irect.fLeft + quarterWidth, irect.fTop, | |
| 552 irect.fRight - quarterWidth, irect.fTop, | |
| 553 irect.fLeft + halfWidth, irect.fBottom, | |
| 554 edgeColor); | |
| 555 | |
| 556 break; | |
| 557 | |
| 558 case WebThemeEngine::PartSliderTrack: { | |
| 559 SkIRect lirect = irect; | |
| 560 | |
| 561 // Draw a narrow rect for the track plus box hatches on the ends. | |
| 562 if (state == WebThemeEngine::StateFocused) // FIXME: draw differently? | |
| 563 state = WebThemeEngine::StateNormal; | |
| 564 if (extraParams->slider.vertical) { | |
| 565 lirect.inset(halfWidth - sliderIndent, noOffset); | |
| 566 box(canvas, lirect, bgColors(state)); | |
| 567 line(canvas, left, top, right, top, edgeColor); | |
| 568 line(canvas, left, bottom, right, bottom, edgeColor); | |
| 569 } else { | |
| 570 lirect.inset(noOffset, halfHeight - sliderIndent); | |
| 571 box(canvas, lirect, bgColors(state)); | |
| 572 line(canvas, left, top, left, bottom, edgeColor); | |
| 573 line(canvas, right, top, right, bottom, edgeColor); | |
| 574 } | |
| 575 break; | |
| 576 } | |
| 577 | |
| 578 case WebThemeEngine::PartSliderThumb: | |
| 579 if (state == WebThemeEngine::StateFocused) // FIXME: draw differently? | |
| 580 state = WebThemeEngine::StateNormal; | |
| 581 oval(canvas, irect, bgColors(state)); | |
| 582 break; | |
| 583 | |
| 584 case WebThemeEngine::PartInnerSpinButton: { | |
| 585 // stack half-height up and down arrows on top of each other | |
| 586 SkIRect lirect; | |
| 587 int halfHeight = rect.height / 2; | |
| 588 if (extraParams->innerSpin.readOnly) | |
| 589 state = blink::WebThemeEngine::StateDisabled; | |
| 590 | |
| 591 lirect.set(rect.x, rect.y, rect.x + rect.width - 1, rect.y + halfHeight
- 1); | |
| 592 box(canvas, lirect, bgColors(state)); | |
| 593 bottom = lirect.fBottom; | |
| 594 quarterHeight = lirect.height() / 4; | |
| 595 triangle(canvas, | |
| 596 left + quarterWidth, bottom - quarterHeight, | |
| 597 right - quarterWidth, bottom - quarterHeight, | |
| 598 left + halfWidth, top + quarterHeight, | |
| 599 edgeColor); | |
| 600 | |
| 601 lirect.set(rect.x, rect.y + halfHeight, rect.x + rect.width - 1, | |
| 602 rect.y + 2 * halfHeight - 1); | |
| 603 top = lirect.fTop; | |
| 604 bottom = lirect.fBottom; | |
| 605 quarterHeight = lirect.height() / 4; | |
| 606 box(canvas, lirect, bgColors(state)); | |
| 607 triangle(canvas, | |
| 608 left + quarterWidth, top + quarterHeight, | |
| 609 right - quarterWidth, top + quarterHeight, | |
| 610 left + halfWidth, bottom - quarterHeight, | |
| 611 edgeColor); | |
| 612 markState(canvas, irect, state); | |
| 613 break; | |
| 614 } | |
| 615 case WebThemeEngine::PartProgressBar: { | |
| 616 paint.setColor(bgColors(state)); | |
| 617 paint.setStyle(SkPaint::kFill_Style); | |
| 618 canvas->drawIRect(irect, paint); | |
| 619 | |
| 620 // Emulate clipping | |
| 621 SkIRect tofill = irect; | |
| 622 if (extraParams->progressBar.determinate) { | |
| 623 tofill.set(extraParams->progressBar.valueRectX, | |
| 624 extraParams->progressBar.valueRectY, | |
| 625 extraParams->progressBar.valueRectX + | |
| 626 extraParams->progressBar.valueRectWidth - 1, | |
| 627 extraParams->progressBar.valueRectY + | |
| 628 extraParams->progressBar.valueRectHeight); | |
| 629 } | |
| 630 | |
| 631 if (!tofill.intersect(irect)) | |
| 632 tofill.setEmpty(); | |
| 633 | |
| 634 paint.setColor(edgeColor); | |
| 635 paint.setStyle(SkPaint::kFill_Style); | |
| 636 canvas->drawIRect(tofill, paint); | |
| 637 | |
| 638 markState(canvas, irect, state); | |
| 639 break; | |
| 640 } | |
| 641 default: | |
| 642 // FIXME: Should we do something here to indicate that we got an invalid
part? | |
| 643 // Unfortunately, we can't assert because we don't have access to WTF or
base. | |
| 644 break; | |
| 645 } | |
| 646 } | |
| 647 | |
| 648 } // namespace content | |
| 649 | |
| 650 #endif // !defined(OS_MACOSX) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1167703002:
Move test runner to a component (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master