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