[WTF] Import std::optional reference implementation as WTF::Optional
[WebKit-https.git] / 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 std::optional<FloatRect> localBounds(const GraphicsContext&) const { return std::nullopt; }
176
177 private:
178     virtual bool isDrawingItem() const { return true; }
179
180     std::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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     void apply(GraphicsContext&) const override;
545
546     std::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     void apply(GraphicsContext&) const override;
574
575     std::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     void apply(GraphicsContext&) const override;
601
602     std::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     void apply(GraphicsContext&) const override;
627
628     std::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(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator op, BlendMode blendMode, ImageOrientation orientation)
643     {
644         return adoptRef(*new DrawNativeImage(image, 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(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientation);
652
653     void apply(GraphicsContext&) const override;
654
655     std::optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
656
657 #if USE(CG)
658     RetainPtr<CGImageRef> m_image;
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& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, BlendMode blendMode)
674     {
675         return adoptRef(*new DrawPattern(image, destRect, tileRect, patternTransform, phase, spacing, op, 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& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal);
687
688     void apply(GraphicsContext&) const override;
689
690     std::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     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     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     void apply(GraphicsContext&) const override;
759     std::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     void apply(GraphicsContext&) const override;
784     std::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     void apply(GraphicsContext&) const override;
818
819     std::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     void apply(GraphicsContext&) const override;
849
850     std::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     void apply(GraphicsContext&) const override;
874     std::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     void apply(GraphicsContext&) const override;
896
897     std::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     const 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     void apply(GraphicsContext&) const override;
925
926     std::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<FloatRect>& rects, int width, int offset, const Color& color)
937     {
938         return adoptRef(*new DrawFocusRingRects(rects, width, offset, color));
939     }
940
941     const Vector<FloatRect> rects() const { return m_rects; }
942     int width() const { return m_width; }
943     int offset() const { return m_offset; }
944     const Color& color() const { return m_color; }
945
946 private:
947     DrawFocusRingRects(const Vector<FloatRect>& 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     void apply(GraphicsContext&) const override;
957
958     std::optional<FloatRect> localBounds(const GraphicsContext&) const override;
959
960     Vector<FloatRect> 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     void apply(GraphicsContext&) const override;
983     std::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     const 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     void apply(GraphicsContext&) const override;
1008     std::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     void apply(GraphicsContext&) const override;
1032     std::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     const 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     void apply(GraphicsContext&) const override;
1061     std::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     const 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     void apply(GraphicsContext&) const override;
1090     std::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     const 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     void apply(GraphicsContext&) const override;
1118     std::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     void apply(GraphicsContext&) const override;
1142     std::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     void apply(GraphicsContext&) const override;
1164
1165     std::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     void apply(GraphicsContext&) const override;
1189     std::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     void apply(GraphicsContext&) const override;
1212     std::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     void apply(GraphicsContext&) const override;
1235     std::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     void apply(GraphicsContext&) const override;
1257     std::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     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     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     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