Source/WebCore/platform/graphics/displaylists/DisplayListItems.h

   1 /*
   2  * Copyright (C) 2015 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef DisplayListItems_h
  27 #define DisplayListItems_h
  28
  29 #include "FloatPoint.h"
  30 #include "FloatRect.h"
  31 #include "FloatRoundedRect.h"
  32 #include "Font.h"
  33 #include "GlyphBuffer.h"
  34 #include "GraphicsContext.h"
  35 #include "Image.h"
  36 #include <wtf/RefCounted.h>
  37 #include <wtf/TypeCasts.h>
  38
  39 #if USE(CG)
  40 #include "GraphicsContextPlatformPrivateCG.h"
  41 #endif
  42
  43 namespace WebCore {
  44
  45 class TextStream;
  46 struct ImagePaintingOptions;
  47
  48 namespace DisplayList {
  49
  50 enum class ItemType {
  51     Save,
  52     Restore,
  53     Translate,
  54     Rotate,
  55     Scale,
  56     ConcatenateCTM,
  57     SetState,
  58     SetLineCap,
  59     SetLineDash,
  60     SetLineJoin,
  61     SetMiterLimit,
  62     ClearShadow,
  63     Clip,
  64     ClipOut,
  65     ClipOutToPath,
  66     ClipPath,
  67     DrawGlyphs,
  68     DrawImage,
  69     DrawTiledImage,
  70     DrawTiledScaledImage,
  71 #if USE(CG) || USE(CAIRO)
  72     DrawNativeImage,
  73 #endif
  74     DrawPattern,
  75     DrawRect,
  76     DrawLine,
  77     DrawLinesForText,
  78     DrawLineForDocumentMarker,
  79     DrawEllipse,
  80     DrawPath,
  81     DrawFocusRingPath,
  82     DrawFocusRingRects,
  83     FillRect,
  84     FillRectWithColor,
  85     FillRectWithGradient,
  86     FillCompositedRect,
  87     FillRoundedRect,
  88     FillRectWithRoundedHole,
  89     FillPath,
  90     FillEllipse,
  91     StrokeRect,
  92     StrokePath,
  93     StrokeEllipse,
  94     ClearRect,
  95     BeginTransparencyLayer,
  96     EndTransparencyLayer,
  97 #if USE(CG)
  98     ApplyStrokePattern, // FIXME: should not be a recorded item.
  99     ApplyFillPattern, // FIXME: should not be a recorded item.
 100 #endif
 101     ApplyDeviceScaleFactor,
 102 };
 103
 104 class Item : public RefCounted<Item> {
 105 public:
 106     Item() = delete;
 107
 108     Item(ItemType type)
 109         : m_type(type)
 110     {
 111     }
 112
 113     virtual ~Item() { }
 114
 115     ItemType type() const
 116     {
 117         return m_type;
 118     }
 119
 120     virtual void apply(GraphicsContext&) const = 0;
 121
 122     static constexpr bool isDisplayListItem = true;
 123
 124     virtual bool isDrawingItem() const { return false; }
 125
 126     // A state item is one preserved by Save/Restore.
 127     bool isStateItem() const
 128     {
 129         return isStateItemType(m_type);
 130     }
 131
 132     static bool isStateItemType(ItemType itemType)
 133     {
 134         switch (itemType) {
 135         case ItemType:: Translate:
 136         case ItemType:: Rotate:
 137         case ItemType:: Scale:
 138         case ItemType:: ConcatenateCTM:
 139         case ItemType:: SetState:
 140         case ItemType:: SetLineCap:
 141         case ItemType:: SetLineDash:
 142         case ItemType:: SetLineJoin:
 143         case ItemType:: SetMiterLimit:
 144         case ItemType:: ClearShadow:
 145             return true;
 146         default:
 147             return false;
 148         }
 149         return false;
 150     }
 151
 152 #if !defined(NDEBUG) || !LOG_DISABLED
 153     WTF::CString description() const;
 154 #endif
 155     static size_t sizeInBytes(const Item&);
 156
 157 private:
 158     ItemType m_type;
 159 };
 160
 161 class DrawingItem : public Item {
 162 public:
 163     DrawingItem(ItemType type)
 164         : Item(type)
 165     {
 166     }
 167
 168     void setExtent(const FloatRect& r) { m_extent = r; }
 169     const FloatRect& extent() const { return m_extent.value(); }
 170
 171     bool extentKnown() const { return static_cast<bool>(m_extent); }
 172
 173     // Return bounds of this drawing operation in local coordinates.
 174     // Does not include effets of transform, shadow etc in the state.
 175     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const { return Nullopt; }
 176
 177 private:
 178     virtual bool isDrawingItem() const { return true; }
 179
 180     Optional<FloatRect> m_extent; // In base coordinates, taking shadows and transforms into account.
 181 };
 182
 183 class Save : public Item {
 184 public:
 185     static Ref<Save> create()
 186     {
 187         return adoptRef(*new Save);
 188     }
 189
 190     // Index in the display list of the corresponding Restore item. 0 if unmatched.
 191     size_t restoreIndex() const { return m_restoreIndex; }
 192     void setRestoreIndex(size_t index) { m_restoreIndex = index; }
 193
 194 private:
 195     Save()
 196         : Item(ItemType::Save)
 197     {
 198     }
 199
 200     virtual void apply(GraphicsContext&) const override;
 201
 202     size_t m_restoreIndex { 0 };
 203 };
 204
 205 class Restore : public Item {
 206 public:
 207     static Ref<Restore> create()
 208     {
 209         return adoptRef(*new Restore);
 210     }
 211
 212 private:
 213     Restore()
 214         : Item(ItemType::Restore)
 215     {
 216     }
 217
 218     virtual void apply(GraphicsContext&) const override;
 219 };
 220
 221 class Translate : public Item {
 222 public:
 223     static Ref<Translate> create(float x, float y)
 224     {
 225         return adoptRef(*new Translate(x, y));
 226     }
 227
 228     float x() const { return m_x; }
 229     float y() const { return m_y; }
 230
 231 private:
 232     Translate(float x, float y)
 233         : Item(ItemType::Translate)
 234         , m_x(x)
 235         , m_y(y)
 236     {
 237     }
 238
 239     virtual void apply(GraphicsContext&) const override;
 240
 241     float m_x;
 242     float m_y;
 243 };
 244
 245 class Rotate : public Item {
 246 public:
 247     static Ref<Rotate> create(float angleInRadians)
 248     {
 249         return adoptRef(*new Rotate(angleInRadians));
 250     }
 251
 252     float angle() const { return m_angle; }
 253
 254 private:
 255     Rotate(float angle)
 256         : Item(ItemType::Rotate)
 257         , m_angle(angle)
 258     {
 259     }
 260
 261     virtual void apply(GraphicsContext&) const override;
 262
 263     float m_angle; // In radians.
 264 };
 265
 266 class Scale : public Item {
 267 public:
 268     static Ref<Scale> create(const FloatSize& size)
 269     {
 270         return adoptRef(*new Scale(size));
 271     }
 272
 273     const FloatSize& amount() const { return m_size; }
 274
 275 private:
 276     Scale(const FloatSize& size)
 277         : Item(ItemType::Scale)
 278         , m_size(size)
 279     {
 280     }
 281
 282     virtual void apply(GraphicsContext&) const override;
 283
 284     FloatSize m_size;
 285 };
 286
 287 class ConcatenateCTM : public Item {
 288 public:
 289     static Ref<ConcatenateCTM> create(const AffineTransform& matrix)
 290     {
 291         return adoptRef(*new ConcatenateCTM(matrix));
 292     }
 293
 294     const AffineTransform& transform() const { return m_transform; }
 295
 296 private:
 297     ConcatenateCTM(const AffineTransform&);
 298
 299     virtual void apply(GraphicsContext&) const override;
 300
 301     AffineTransform m_transform;
 302 };
 303
 304 class SetState : public Item {
 305 public:
 306     static Ref<SetState> create(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
 307     {
 308         return adoptRef(*new SetState(state, flags));
 309     }
 310
 311     const GraphicsContextStateChange& state() const { return m_state; }
 312
 313     void accumulate(const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
 314
 315     void accumulate(GraphicsContextState&) const;
 316
 317     static void applyState(GraphicsContext&, const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
 318
 319     static void dumpStateChanges(TextStream&, const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
 320 private:
 321     SetState(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
 322         : Item(ItemType::SetState)
 323         , m_state(state, flags)
 324     {
 325     }
 326
 327     virtual void apply(GraphicsContext&) const override;
 328
 329     GraphicsContextStateChange m_state;
 330 };
 331
 332 class SetLineCap : public Item {
 333 public:
 334     static Ref<SetLineCap> create(LineCap lineCap)
 335     {
 336         return adoptRef(*new SetLineCap(lineCap));
 337     }
 338
 339     LineCap lineCap() const { return m_lineCap; }
 340
 341 private:
 342     SetLineCap(LineCap lineCap)
 343         : Item(ItemType::SetLineCap)
 344         , m_lineCap(lineCap)
 345     {
 346     }
 347
 348     virtual void apply(GraphicsContext&) const override;
 349
 350     LineCap m_lineCap;
 351 };
 352
 353 class SetLineDash : public Item {
 354 public:
 355     static Ref<SetLineDash> create(const DashArray& dashArray, float dashOffset)
 356     {
 357         return adoptRef(*new SetLineDash(dashArray, dashOffset));
 358     }
 359
 360     const DashArray& dashArray() const { return m_dashArray; }
 361     float dashOffset() const { return m_dashOffset; }
 362
 363 private:
 364     SetLineDash(const DashArray& dashArray, float dashOffset)
 365         : Item(ItemType::SetLineDash)
 366         , m_dashArray(dashArray)
 367         , m_dashOffset(dashOffset)
 368     {
 369     }
 370
 371     virtual void apply(GraphicsContext&) const override;
 372
 373     DashArray m_dashArray;
 374     float m_dashOffset;
 375 };
 376
 377 class SetLineJoin : public Item {
 378 public:
 379     static Ref<SetLineJoin> create(LineJoin lineJoin)
 380     {
 381         return adoptRef(*new SetLineJoin(lineJoin));
 382     }
 383
 384     LineJoin lineJoin() const { return m_lineJoin; }
 385
 386 private:
 387     SetLineJoin(LineJoin lineJoin)
 388         : Item(ItemType::SetLineJoin)
 389         , m_lineJoin(lineJoin)
 390     {
 391     }
 392
 393     virtual void apply(GraphicsContext&) const override;
 394
 395     LineJoin m_lineJoin;
 396 };
 397
 398 class SetMiterLimit : public Item {
 399 public:
 400     static Ref<SetMiterLimit> create(float limit)
 401     {
 402         return adoptRef(*new SetMiterLimit(limit));
 403     }
 404
 405     float miterLimit() const { return m_miterLimit; }
 406
 407 private:
 408     SetMiterLimit(float miterLimit)
 409         : Item(ItemType::SetMiterLimit)
 410         , m_miterLimit(miterLimit)
 411     {
 412     }
 413
 414     virtual void apply(GraphicsContext&) const override;
 415
 416     float m_miterLimit;
 417 };
 418
 419 class ClearShadow : public Item {
 420 public:
 421     static Ref<ClearShadow> create()
 422     {
 423         return adoptRef(*new ClearShadow);
 424     }
 425
 426 private:
 427     ClearShadow()
 428         : Item(ItemType::ClearShadow)
 429     {
 430     }
 431
 432     virtual void apply(GraphicsContext&) const override;
 433 };
 434
 435 // FIXME: treat as DrawingItem?
 436 class Clip : public Item {
 437 public:
 438     static Ref<Clip> create(const FloatRect& rect)
 439     {
 440         return adoptRef(*new Clip(rect));
 441     }
 442
 443     FloatRect rect() const { return m_rect; }
 444
 445 private:
 446     Clip(const FloatRect& rect)
 447         : Item(ItemType::Clip)
 448         , m_rect(rect)
 449     {
 450     }
 451
 452     virtual void apply(GraphicsContext&) const override;
 453
 454     FloatRect m_rect;
 455 };
 456
 457 class ClipOut : public Item {
 458 public:
 459     static Ref<ClipOut> create(const FloatRect& rect)
 460     {
 461         return adoptRef(*new ClipOut(rect));
 462     }
 463
 464     FloatRect rect() const { return m_rect; }
 465
 466 private:
 467     ClipOut(const FloatRect& rect)
 468         : Item(ItemType::ClipOut)
 469         , m_rect(rect)
 470     {
 471     }
 472
 473     virtual void apply(GraphicsContext&) const override;
 474
 475     FloatRect m_rect;
 476 };
 477
 478 class ClipOutToPath : public Item {
 479 public:
 480     static Ref<ClipOutToPath> create(const Path& path)
 481     {
 482         return adoptRef(*new ClipOutToPath(path));
 483     }
 484
 485     const Path& path() const { return m_path; }
 486
 487 private:
 488     ClipOutToPath(const Path& path)
 489         : Item(ItemType::ClipOutToPath)
 490         , m_path(path)
 491     {
 492     }
 493
 494     virtual void apply(GraphicsContext&) const override;
 495
 496     const Path m_path;
 497 };
 498
 499 class ClipPath : public Item {
 500 public:
 501     static Ref<ClipPath> create(const Path& path, WindRule windRule)
 502     {
 503         return adoptRef(*new ClipPath(path, windRule));
 504     }
 505
 506     const Path& path() const { return m_path; }
 507     WindRule windRule() const { return m_windRule; }
 508
 509 private:
 510     ClipPath(const Path& path, WindRule windRule)
 511         : Item(ItemType::ClipPath)
 512         , m_path(path)
 513         , m_windRule(windRule)
 514     {
 515     }
 516
 517     virtual void apply(GraphicsContext&) const override;
 518
 519     const Path m_path;
 520     WindRule m_windRule;
 521 };
 522
 523 class DrawGlyphs : public DrawingItem {
 524 public:
 525     static Ref<DrawGlyphs> create(const Font& font, const GlyphBufferGlyph* glyphs, const GlyphBufferAdvance* advances, unsigned count, const FloatPoint& blockLocation, const FloatSize& localAnchor, FontSmoothingMode smoothingMode)
 526     {
 527         return adoptRef(*new DrawGlyphs(font, glyphs, advances, count, blockLocation, localAnchor, smoothingMode));
 528     }
 529
 530     const FloatPoint& blockLocation() const { return m_blockLocation; }
 531     void setBlockLocation(const FloatPoint& blockLocation) { m_blockLocation = blockLocation; }
 532
 533     const FloatSize& localAnchor() const { return m_localAnchor; }
 534
 535     FloatPoint anchorPoint() const { return m_blockLocation + m_localAnchor; }
 536
 537     const Vector<GlyphBufferGlyph, 128>& glyphs() const { return m_glyphs; }
 538
 539 private:
 540     DrawGlyphs(const Font&, const GlyphBufferGlyph*, const GlyphBufferAdvance*, unsigned count, const FloatPoint& blockLocation, const FloatSize& localAnchor, FontSmoothingMode);
 541
 542     void computeBounds();
 543
 544     virtual void apply(GraphicsContext&) const override;
 545
 546     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
 547
 548     GlyphBuffer generateGlyphBuffer() const;
 549
 550     Ref<Font> m_font;
 551     Vector<GlyphBufferGlyph, 128> m_glyphs;
 552     Vector<GlyphBufferAdvance, 128> m_advances;
 553     FloatRect m_bounds;
 554     FloatPoint m_blockLocation;
 555     FloatSize m_localAnchor;
 556     FontSmoothingMode m_smoothingMode;
 557 };
 558
 559 class DrawImage : public DrawingItem {
 560 public:
 561     static Ref<DrawImage> create(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
 562     {
 563         return adoptRef(*new DrawImage(image, destination, source, imagePaintingOptions));
 564     }
 565
 566     const Image& image() const { return m_image.get(); }
 567     FloatRect source() const { return m_source; }
 568     FloatRect destination() const { return m_destination; }
 569
 570 private:
 571     DrawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&);
 572
 573     virtual void apply(GraphicsContext&) const override;
 574
 575     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
 576
 577     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
 578     FloatRect m_destination;
 579     FloatRect m_source;
 580     ImagePaintingOptions m_imagePaintingOptions;
 581 };
 582
 583 class DrawTiledImage : public DrawingItem {
 584 public:
 585     static Ref<DrawTiledImage> create(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
 586     {
 587         return adoptRef(*new DrawTiledImage(image, destination, source, tileSize, spacing, imagePaintingOptions));
 588     }
 589
 590     const Image& image() const { return m_image.get(); }
 591     FloatPoint source() const { return m_source; }
 592     FloatRect destination() const { return m_destination; }
 593
 594     FloatSize tileSize() const { return m_tileSize; }
 595     FloatSize spacing() const { return m_spacing; }
 596
 597 private:
 598     DrawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&);
 599
 600     virtual void apply(GraphicsContext&) const override;
 601
 602     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
 603
 604     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
 605     FloatRect m_destination;
 606     FloatPoint m_source;
 607     FloatSize m_tileSize;
 608     FloatSize m_spacing;
 609     ImagePaintingOptions m_imagePaintingOptions;
 610 };
 611
 612 class DrawTiledScaledImage : public DrawingItem {
 613 public:
 614     static Ref<DrawTiledScaledImage> create(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
 615     {
 616         return adoptRef(*new DrawTiledScaledImage(image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions));
 617     }
 618
 619     const Image& image() const { return m_image.get(); }
 620     FloatRect source() const { return m_source; }
 621     FloatRect destination() const { return m_destination; }
 622
 623 private:
 624     DrawTiledScaledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&);
 625
 626     virtual void apply(GraphicsContext&) const override;
 627
 628     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
 629
 630     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
 631     FloatRect m_destination;
 632     FloatRect m_source;
 633     FloatSize m_tileScaleFactor;
 634     Image::TileRule m_hRule;
 635     Image::TileRule m_vRule;
 636     ImagePaintingOptions m_imagePaintingOptions;
 637 };
 638
 639 #if USE(CG) || USE(CAIRO)
 640 class DrawNativeImage : public DrawingItem {
 641 public:
 642     static Ref<DrawNativeImage> create(PassNativeImagePtr imagePtr, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator op, BlendMode blendMode, ImageOrientation orientation)
 643     {
 644         return adoptRef(*new DrawNativeImage(imagePtr, imageSize, destRect, srcRect, op, blendMode, orientation));
 645     }
 646
 647     FloatRect source() const { return m_srcRect; }
 648     FloatRect destination() const { return m_destination; }
 649
 650 private:
 651     DrawNativeImage(PassNativeImagePtr, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientation);
 652
 653     virtual void apply(GraphicsContext&) const override;
 654
 655     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
 656
 657 #if USE(CG)
 658     RetainPtr<CGImageRef> m_imagePtr;
 659 #endif
 660     FloatSize m_imageSize;
 661     FloatRect m_destination;
 662     FloatRect m_srcRect;
 663 #if USE(CG)
 664     CompositeOperator m_op;
 665     BlendMode m_blendMode;
 666 #endif
 667     ImageOrientation m_orientation;
 668 };
 669 #endif
 670
 671 class DrawPattern : public DrawingItem {
 672 public:
 673     static Ref<DrawPattern> create(Image& image, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
 674     {
 675         return adoptRef(*new DrawPattern(image, tileRect, patternTransform, phase, spacing, op, destRect, blendMode));
 676     }
 677
 678     const Image& image() const { return m_image.get(); }
 679     const AffineTransform& patternTransform() const { return m_patternTransform; }
 680     FloatRect tileRect() const { return m_tileRect; }
 681     FloatRect destRect() const { return m_destination; }
 682     FloatPoint phase() const { return m_phase; }
 683     FloatSize spacing() const { return m_spacing; }
 684
 685 private:
 686     DrawPattern(Image&, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal);
 687
 688     virtual void apply(GraphicsContext&) const override;
 689
 690     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
 691
 692     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
 693     AffineTransform m_patternTransform;
 694     FloatRect m_tileRect;
 695     FloatRect m_destination;
 696     FloatPoint m_phase;
 697     FloatSize m_spacing;
 698     CompositeOperator m_op;
 699     BlendMode m_blendMode;
 700 };
 701
 702 // Is DrawingItem because the size of the transparency layer is implicitly the clip bounds.
 703 class BeginTransparencyLayer : public DrawingItem {
 704 public:
 705     static Ref<BeginTransparencyLayer> create(float opacity)
 706     {
 707         return adoptRef(*new BeginTransparencyLayer(opacity));
 708     }
 709
 710     float opacity() const { return m_opacity; }
 711
 712 private:
 713     BeginTransparencyLayer(float opacity)
 714         : DrawingItem(ItemType::BeginTransparencyLayer)
 715         , m_opacity(opacity)
 716     {
 717     }
 718
 719     virtual void apply(GraphicsContext&) const override;
 720
 721     float m_opacity;
 722 };
 723
 724 class EndTransparencyLayer : public DrawingItem {
 725 public:
 726     static Ref<EndTransparencyLayer> create()
 727     {
 728         return adoptRef(*new EndTransparencyLayer);
 729     }
 730
 731 private:
 732     EndTransparencyLayer()
 733         : DrawingItem(ItemType::EndTransparencyLayer)
 734     {
 735     }
 736
 737     virtual void apply(GraphicsContext&) const override;
 738 };
 739
 740 class DrawRect : public DrawingItem {
 741 public:
 742     static Ref<DrawRect> create(const FloatRect& rect, float borderThickness)
 743     {
 744         return adoptRef(*new DrawRect(rect, borderThickness));
 745     }
 746
 747     FloatRect rect() const { return m_rect; }
 748     float borderThickness() const { return m_borderThickness; }
 749
 750 private:
 751     DrawRect(const FloatRect& rect, float borderThickness)
 752         : DrawingItem(ItemType::DrawRect)
 753         , m_rect(rect)
 754         , m_borderThickness(borderThickness)
 755     {
 756     }
 757
 758     virtual void apply(GraphicsContext&) const override;
 759     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
 760
 761     FloatRect m_rect;
 762     float m_borderThickness;
 763 };
 764
 765 class DrawLine : public DrawingItem {
 766 public:
 767     static Ref<DrawLine> create(const FloatPoint& point1, const FloatPoint& point2)
 768     {
 769         return adoptRef(*new DrawLine(point1, point2));
 770     }
 771
 772     FloatPoint point1() const { return m_point1; }
 773     FloatPoint point2() const { return m_point2; }
 774
 775 private:
 776     DrawLine(const FloatPoint& point1, const FloatPoint& point2)
 777         : DrawingItem(ItemType::DrawLine)
 778         , m_point1(point1)
 779         , m_point2(point2)
 780     {
 781     }
 782
 783     virtual void apply(GraphicsContext&) const override;
 784     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
 785
 786     FloatPoint m_point1;
 787     FloatPoint m_point2;
 788 };
 789
 790 class DrawLinesForText : public DrawingItem {
 791 public:
 792     static Ref<DrawLinesForText> create(const FloatPoint& blockLocation, const FloatSize& localAnchor, const DashArray& widths, bool printing, bool doubleLines, float strokeWidth)
 793     {
 794         return adoptRef(*new DrawLinesForText(blockLocation, localAnchor, widths, printing, doubleLines, strokeWidth));
 795     }
 796
 797     void setBlockLocation(const FloatPoint& blockLocation) { m_blockLocation = blockLocation; }
 798     const FloatPoint& blockLocation() const { return m_blockLocation; }
 799     const FloatSize& localAnchor() const { return m_localAnchor; }
 800     FloatPoint point() const { return m_blockLocation + m_localAnchor; }
 801     const DashArray& widths() const { return m_widths; }
 802     bool isPrinting() const { return m_printing; }
 803     bool doubleLines() const { return m_doubleLines; }
 804
 805 private:
 806     DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, const DashArray& widths, bool printing, bool doubleLines, float strokeWidth)
 807         : DrawingItem(ItemType::DrawLinesForText)
 808         , m_blockLocation(blockLocation)
 809         , m_localAnchor(localAnchor)
 810         , m_widths(widths)
 811         , m_strokeWidth(strokeWidth)
 812         , m_printing(printing)
 813         , m_doubleLines(doubleLines)
 814     {
 815     }
 816
 817     virtual void apply(GraphicsContext&) const override;
 818
 819     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
 820
 821     FloatPoint m_blockLocation;
 822     FloatSize m_localAnchor;
 823     DashArray m_widths;
 824     float m_strokeWidth;
 825     bool m_printing;
 826     bool m_doubleLines;
 827 };
 828
 829 class DrawLineForDocumentMarker : public DrawingItem {
 830 public:
 831     static Ref<DrawLineForDocumentMarker> create(const FloatPoint& point, float width, GraphicsContext::DocumentMarkerLineStyle style)
 832     {
 833         return adoptRef(*new DrawLineForDocumentMarker(point, width, style));
 834     }
 835
 836     FloatPoint point() const { return m_point; }
 837     float width() const { return m_width; }
 838
 839 private:
 840     DrawLineForDocumentMarker(const FloatPoint& point, float width, GraphicsContext::DocumentMarkerLineStyle style)
 841         : DrawingItem(ItemType::DrawLineForDocumentMarker)
 842         , m_point(point)
 843         , m_width(width)
 844         , m_style(style)
 845     {
 846     }
 847
 848     virtual void apply(GraphicsContext&) const override;
 849
 850     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
 851
 852     FloatPoint m_point;
 853     float m_width;
 854     GraphicsContext::DocumentMarkerLineStyle m_style;
 855 };
 856
 857 class DrawEllipse : public DrawingItem {
 858 public:
 859     static Ref<DrawEllipse> create(const FloatRect& rect)
 860     {
 861         return adoptRef(*new DrawEllipse(rect));
 862     }
 863
 864     FloatRect rect() const { return m_rect; }
 865
 866 private:
 867     DrawEllipse(const FloatRect& rect)
 868         : DrawingItem(ItemType::DrawEllipse)
 869         , m_rect(rect)
 870     {
 871     }
 872
 873     virtual void apply(GraphicsContext&) const override;
 874     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
 875
 876     FloatRect m_rect;
 877 };
 878
 879 class DrawPath : public DrawingItem {
 880 public:
 881     static Ref<DrawPath> create(const Path& path)
 882     {
 883         return adoptRef(*new DrawPath(path));
 884     }
 885
 886     const Path& path() const { return m_path; }
 887
 888 private:
 889     DrawPath(const Path& path)
 890         : DrawingItem(ItemType::DrawPath)
 891         , m_path(path)
 892     {
 893     }
 894
 895     virtual void apply(GraphicsContext&) const override;
 896
 897     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_path.fastBoundingRect(); }
 898
 899     const Path m_path;
 900 };
 901
 902 class DrawFocusRingPath : public DrawingItem {
 903 public:
 904     static Ref<DrawFocusRingPath> create(const Path& path, int width, int offset, const Color& color)
 905     {
 906         return adoptRef(*new DrawFocusRingPath(path, width, offset, color));
 907     }
 908
 909     const Path& path() const { return m_path; }
 910     int width() const { return m_width; }
 911     int offset() const { return m_offset; }
 912     Color color() const { return m_color; }
 913
 914 private:
 915     DrawFocusRingPath(const Path& path, int width, int offset, const Color& color)
 916         : DrawingItem(ItemType::DrawFocusRingPath)
 917         , m_path(path)
 918         , m_width(width)
 919         , m_offset(offset)
 920         , m_color(color)
 921     {
 922     }
 923
 924     virtual void apply(GraphicsContext&) const override;
 925
 926     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
 927
 928     const Path m_path;
 929     int m_width;
 930     int m_offset;
 931     Color m_color;
 932 };
 933
 934 class DrawFocusRingRects : public DrawingItem {
 935 public:
 936     static Ref<DrawFocusRingRects> create(const Vector<IntRect>& rects, int width, int offset, const Color& color)
 937     {
 938         return adoptRef(*new DrawFocusRingRects(rects, width, offset, color));
 939     }
 940
 941     const Vector<IntRect> rects() const { return m_rects; }
 942     int width() const { return m_width; }
 943     int offset() const { return m_offset; }
 944     Color color() const { return m_color; }
 945
 946 private:
 947     DrawFocusRingRects(const Vector<IntRect>& rects, int width, int offset, const Color& color)
 948         : DrawingItem(ItemType::DrawFocusRingRects)
 949         , m_rects(rects)
 950         , m_width(width)
 951         , m_offset(offset)
 952         , m_color(color)
 953     {
 954     }
 955
 956     virtual void apply(GraphicsContext&) const override;
 957
 958     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
 959
 960     Vector<IntRect> m_rects;
 961     int m_width;
 962     int m_offset;
 963     Color m_color;
 964 };
 965
 966 class FillRect : public DrawingItem {
 967 public:
 968     static Ref<FillRect> create(const FloatRect& rect)
 969     {
 970         return adoptRef(*new FillRect(rect));
 971     }
 972
 973     FloatRect rect() const { return m_rect; }
 974
 975 private:
 976     FillRect(const FloatRect& rect)
 977         : DrawingItem(ItemType::FillRect)
 978         , m_rect(rect)
 979     {
 980     }
 981
 982     virtual void apply(GraphicsContext&) const override;
 983     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
 984
 985     FloatRect m_rect;
 986 };
 987
 988 // FIXME: Make these inherit from FillRect proper.
 989 class FillRectWithColor : public DrawingItem {
 990 public:
 991     static Ref<FillRectWithColor> create(const FloatRect& rect, const Color& color)
 992     {
 993         return adoptRef(*new FillRectWithColor(rect, color));
 994     }
 995
 996     FloatRect rect() const { return m_rect; }
 997     Color color() const { return m_color; }
 998
 999 private:
1000     FillRectWithColor(const FloatRect& rect, const Color& color)
1001         : DrawingItem(ItemType::FillRectWithColor)
1002         , m_rect(rect)
1003         , m_color(color)
1004     {
1005     }
1006
1007     virtual void apply(GraphicsContext&) const override;
1008     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1009
1010     FloatRect m_rect;
1011     Color m_color;
1012 };
1013
1014 class FillRectWithGradient : public DrawingItem {
1015 public:
1016     static Ref<FillRectWithGradient> create(const FloatRect& rect, Gradient& gradient)
1017     {
1018         return adoptRef(*new FillRectWithGradient(rect, gradient));
1019     }
1020
1021     FloatRect rect() const { return m_rect; }
1022
1023 private:
1024     FillRectWithGradient(const FloatRect& rect, Gradient& gradient)
1025         : DrawingItem(ItemType::FillRectWithGradient)
1026         , m_rect(rect)
1027         , m_gradient(gradient)
1028     {
1029     }
1030
1031     virtual void apply(GraphicsContext&) const override;
1032     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1033
1034     FloatRect m_rect;
1035     mutable Ref<Gradient> m_gradient; // FIXME: Make this not mutable
1036 };
1037
1038 class FillCompositedRect : public DrawingItem {
1039 public:
1040     static Ref<FillCompositedRect> create(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
1041     {
1042         return adoptRef(*new FillCompositedRect(rect, color, op, blendMode));
1043     }
1044
1045     FloatRect rect() const { return m_rect; }
1046     Color color() const { return m_color; }
1047     CompositeOperator compositeOperator() const { return m_op; }
1048     BlendMode blendMode() const { return m_blendMode; }
1049
1050 private:
1051     FillCompositedRect(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
1052         : DrawingItem(ItemType::FillCompositedRect)
1053         , m_rect(rect)
1054         , m_color(color)
1055         , m_op(op)
1056         , m_blendMode(blendMode)
1057     {
1058     }
1059
1060     virtual void apply(GraphicsContext&) const override;
1061     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1062
1063     FloatRect m_rect;
1064     Color m_color;
1065     CompositeOperator m_op;
1066     BlendMode m_blendMode;
1067 };
1068
1069 class FillRoundedRect : public DrawingItem {
1070 public:
1071     static Ref<FillRoundedRect> create(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
1072     {
1073         return adoptRef(*new FillRoundedRect(rect, color, blendMode));
1074     }
1075
1076     const FloatRoundedRect& roundedRect() const { return m_rect; }
1077     Color color() const { return m_color; }
1078     BlendMode blendMode() const { return m_blendMode; }
1079
1080 private:
1081     FillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
1082         : DrawingItem(ItemType::FillRoundedRect)
1083         , m_rect(rect)
1084         , m_color(color)
1085         , m_blendMode(blendMode)
1086     {
1087     }
1088
1089     virtual void apply(GraphicsContext&) const override;
1090     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect.rect(); }
1091
1092     FloatRoundedRect m_rect;
1093     Color m_color;
1094     BlendMode m_blendMode;
1095 };
1096
1097 class FillRectWithRoundedHole : public DrawingItem {
1098 public:
1099     static Ref<FillRectWithRoundedHole> create(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
1100     {
1101         return adoptRef(*new FillRectWithRoundedHole(rect, roundedHoleRect, color));
1102     }
1103
1104     const FloatRect& rect() const { return m_rect; }
1105     const FloatRoundedRect& roundedHoleRect() const { return m_roundedHoleRect; }
1106     Color color() const { return m_color; }
1107
1108 private:
1109     FillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
1110         : DrawingItem(ItemType::FillRectWithRoundedHole)
1111         , m_rect(rect)
1112         , m_roundedHoleRect(roundedHoleRect)
1113         , m_color(color)
1114     {
1115     }
1116
1117     virtual void apply(GraphicsContext&) const override;
1118     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1119
1120     FloatRect m_rect;
1121     FloatRoundedRect m_roundedHoleRect;
1122     Color m_color;
1123 };
1124
1125 class FillPath : public DrawingItem {
1126 public:
1127     static Ref<FillPath> create(const Path& path)
1128     {
1129         return adoptRef(*new FillPath(path));
1130     }
1131
1132     const Path& path() const { return m_path; }
1133
1134 private:
1135     FillPath(const Path& path)
1136         : DrawingItem(ItemType::FillPath)
1137         , m_path(path)
1138     {
1139     }
1140
1141     virtual void apply(GraphicsContext&) const override;
1142     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_path.fastBoundingRect(); }
1143
1144     const Path m_path;
1145 };
1146
1147 class FillEllipse : public DrawingItem {
1148 public:
1149     static Ref<FillEllipse> create(const FloatRect& rect)
1150     {
1151         return adoptRef(*new FillEllipse(rect));
1152     }
1153
1154     FloatRect rect() const { return m_rect; }
1155
1156 private:
1157     FillEllipse(const FloatRect& rect)
1158         : DrawingItem(ItemType::FillEllipse)
1159         , m_rect(rect)
1160     {
1161     }
1162
1163     virtual void apply(GraphicsContext&) const override;
1164
1165     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1166
1167     FloatRect m_rect;
1168 };
1169
1170 class StrokeRect : public DrawingItem {
1171 public:
1172     static Ref<StrokeRect> create(const FloatRect& rect, float lineWidth)
1173     {
1174         return adoptRef(*new StrokeRect(rect, lineWidth));
1175     }
1176
1177     FloatRect rect() const { return m_rect; }
1178     float lineWidth() const { return m_lineWidth; }
1179
1180 private:
1181     StrokeRect(const FloatRect& rect, float lineWidth)
1182         : DrawingItem(ItemType::StrokeRect)
1183         , m_rect(rect)
1184         , m_lineWidth(lineWidth)
1185     {
1186     }
1187
1188     virtual void apply(GraphicsContext&) const override;
1189     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1190
1191     FloatRect m_rect;
1192     float m_lineWidth;
1193 };
1194
1195 class StrokePath : public DrawingItem {
1196 public:
1197     static Ref<StrokePath> create(const Path& path)
1198     {
1199         return adoptRef(*new StrokePath(path));
1200     }
1201
1202     const Path& path() const { return m_path; }
1203
1204 private:
1205     StrokePath(const Path& path)
1206         : DrawingItem(ItemType::StrokePath)
1207         , m_path(path)
1208     {
1209     }
1210
1211     virtual void apply(GraphicsContext&) const override;
1212     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1213
1214     const Path m_path;
1215     FloatPoint m_blockLocation;
1216 };
1217
1218 class StrokeEllipse : public DrawingItem {
1219 public:
1220     static Ref<StrokeEllipse> create(const FloatRect& rect)
1221     {
1222         return adoptRef(*new StrokeEllipse(rect));
1223     }
1224
1225     FloatRect rect() const { return m_rect; }
1226
1227 private:
1228     StrokeEllipse(const FloatRect& rect)
1229         : DrawingItem(ItemType::StrokeEllipse)
1230         , m_rect(rect)
1231     {
1232     }
1233
1234     virtual void apply(GraphicsContext&) const override;
1235     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1236
1237     FloatRect m_rect;
1238 };
1239
1240 class ClearRect : public DrawingItem {
1241 public:
1242     static Ref<ClearRect> create(const FloatRect& rect)
1243     {
1244         return adoptRef(*new ClearRect(rect));
1245     }
1246
1247     FloatRect rect() const { return m_rect; }
1248
1249 private:
1250     ClearRect(const FloatRect& rect)
1251         : DrawingItem(ItemType::ClearRect)
1252         , m_rect(rect)
1253     {
1254     }
1255
1256     virtual void apply(GraphicsContext&) const override;
1257     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1258
1259     FloatRect m_rect;
1260 };
1261
1262 #if USE(CG)
1263 class ApplyStrokePattern : public Item {
1264 public:
1265     static Ref<ApplyStrokePattern> create()
1266     {
1267         return adoptRef(*new ApplyStrokePattern);
1268     }
1269
1270 private:
1271     ApplyStrokePattern()
1272         : Item(ItemType::ApplyStrokePattern)
1273     {
1274     }
1275
1276     virtual void apply(GraphicsContext&) const override;
1277 };
1278
1279 class ApplyFillPattern : public Item {
1280 public:
1281     static Ref<ApplyFillPattern> create()
1282     {
1283         return adoptRef(*new ApplyFillPattern);
1284     }
1285
1286 private:
1287     ApplyFillPattern()
1288         : Item(ItemType::ApplyFillPattern)
1289     {
1290     }
1291
1292     virtual void apply(GraphicsContext&) const override;
1293 };
1294 #endif
1295
1296 class ApplyDeviceScaleFactor : public Item {
1297 public:
1298     static Ref<ApplyDeviceScaleFactor> create(float scaleFactor)
1299     {
1300         return adoptRef(*new ApplyDeviceScaleFactor(scaleFactor));
1301     }
1302
1303     float scaleFactor() const { return m_scaleFactor; }
1304
1305 private:
1306     ApplyDeviceScaleFactor(float scaleFactor)
1307         : Item(ItemType::ApplyDeviceScaleFactor)
1308         , m_scaleFactor(scaleFactor)
1309     {
1310     }
1311
1312     virtual void apply(GraphicsContext&) const override;
1313
1314     float m_scaleFactor;
1315 };
1316
1317 TextStream& operator<<(TextStream&, const Item&);
1318
1319 } // namespace DisplayList
1320 } // namespace WebCore
1321
1322
1323 #define SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_DRAWINGITEM(ToValueTypeName, predicate) \
1324 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DisplayList::ToValueTypeName) \
1325     static bool isType(const WebCore::DisplayList::Item& object) { return object.predicate; } \
1326 SPECIALIZE_TYPE_TRAITS_END()
1327
1328 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_DRAWINGITEM(DrawingItem, isDrawingItem())
1329
1330 #define SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ToValueTypeName) \
1331 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DisplayList::ToValueTypeName) \
1332     static bool isType(const WebCore::DisplayList::Item& item) { return item.type() == WebCore::DisplayList::ItemType::ToValueTypeName; } \
1333 SPECIALIZE_TYPE_TRAITS_END()
1334
1335 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Save)
1336 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Restore)
1337 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Translate)
1338 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Rotate)
1339 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Scale)
1340 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ConcatenateCTM)
1341 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetState)
1342 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineCap)
1343 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineDash)
1344 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineJoin)
1345 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetMiterLimit)
1346 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Clip)
1347 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipOut)
1348 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipOutToPath)
1349 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipPath)
1350 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawGlyphs)
1351 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImage)
1352 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledImage)
1353 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledScaledImage)
1354 #if USE(CG) || USE(CAIRO)
1355 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawNativeImage)
1356 #endif
1357 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPattern)
1358 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawRect)
1359 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLine)
1360 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLinesForText)
1361 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLineForDocumentMarker)
1362 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawEllipse)
1363 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPath)
1364 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawFocusRingPath)
1365 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawFocusRingRects)
1366 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRect)
1367 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithColor)
1368 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithGradient)
1369 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillCompositedRect)
1370 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRoundedRect)
1371 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithRoundedHole)
1372 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillPath)
1373 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillEllipse)
1374 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeRect)
1375 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokePath)
1376 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeEllipse)
1377 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClearRect)
1378 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(BeginTransparencyLayer)
1379 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(EndTransparencyLayer)
1380 #if USE(CG)
1381 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyStrokePattern)
1382 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyFillPattern)
1383 #endif
1384 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyDeviceScaleFactor)
1385 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClearShadow)
1386
1387 #endif // DisplayListItems_h