Remove GraphicsContext::drawConvexPolygon() and GraphicsContext::clipConvexPolygon()
[WebKit-https.git] / Source / WebCore / platform / graphics / GraphicsContext.h
1 /*
2  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
3  * Copyright (C) 2008-2009 Torch Mobile, Inc.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef GraphicsContext_h
28 #define GraphicsContext_h
29
30 #include "DashArray.h"
31 #include "FloatRect.h"
32 #include "FontCascade.h"
33 #include "Gradient.h"
34 #include "GraphicsTypes.h"
35 #include "Image.h"
36 #include "ImageOrientation.h"
37 #include "Path.h"
38 #include "Pattern.h"
39 #include <wtf/Noncopyable.h>
40
41 #if USE(CG)
42 typedef struct CGContext PlatformGraphicsContext;
43 #elif USE(CAIRO)
44 namespace WebCore {
45 class PlatformContextCairo;
46 }
47 typedef WebCore::PlatformContextCairo PlatformGraphicsContext;
48 #elif USE(WINGDI)
49 typedef struct HDC__ PlatformGraphicsContext;
50 #else
51 typedef void PlatformGraphicsContext;
52 #endif
53
54 #if PLATFORM(WIN)
55 #include "DIBPixelData.h"
56 typedef struct HDC__* HDC;
57 #if !USE(CG)
58 // UInt8 is defined in CoreFoundation/CFBase.h
59 typedef unsigned char UInt8;
60 #endif
61 #endif
62
63 namespace WebCore {
64
65 #if USE(WINGDI)
66 class SharedBitmap;
67 class Font;
68 class GlyphBuffer;
69 #endif
70
71 const int cMisspellingLineThickness = 3;
72 const int cMisspellingLinePatternWidth = 4;
73 const int cMisspellingLinePatternGapWidth = 1;
74
75 class AffineTransform;
76 class FloatRoundedRect;
77 class Gradient;
78 class GraphicsContextPlatformPrivate;
79 class ImageBuffer;
80 class IntRect;
81 class RoundedRect;
82 class URL;
83 class GraphicsContext3D;
84 class TextRun;
85 class TransformationMatrix;
86
87 enum TextDrawingMode {
88     TextModeFill = 1 << 0,
89     TextModeStroke = 1 << 1,
90 #if ENABLE(LETTERPRESS)
91     TextModeLetterpress = 1 << 2,
92 #endif
93 };
94 typedef unsigned TextDrawingModeFlags;
95
96 enum StrokeStyle {
97     NoStroke,
98     SolidStroke,
99     DottedStroke,
100     DashedStroke,
101     DoubleStroke,
102     WavyStroke,
103 };
104
105 enum InterpolationQuality {
106     InterpolationDefault,
107     InterpolationNone,
108     InterpolationLow,
109     InterpolationMedium,
110     InterpolationHigh
111 };
112
113 namespace DisplayList {
114 class Recorder;
115 }
116
117 struct GraphicsContextState {
118     GraphicsContextState()
119         : shouldAntialias(true)
120         , shouldSmoothFonts(true)
121         , antialiasedFontDilationEnabled(true)
122         , shouldSubpixelQuantizeFonts(true)
123         , shadowsIgnoreTransforms(false)
124 #if USE(CG)
125         // Core Graphics incorrectly renders shadows with radius > 8px (<rdar://problem/8103442>),
126         // but we need to preserve this buggy behavior for canvas and -webkit-box-shadow.
127         , shadowsUseLegacyRadius(false)
128 #endif
129         , drawLuminanceMask(false)
130     {
131     }
132
133     enum Change : uint32_t {
134         NoChange                                = 0,
135         StrokeGradientChange                    = 1 << 1,
136         StrokePatternChange                     = 1 << 2,
137         FillGradientChange                      = 1 << 3,
138         FillPatternChange                       = 1 << 4,
139         StrokeThicknessChange                   = 1 << 5,
140         StrokeColorChange                       = 1 << 6,
141         StrokeStyleChange                       = 1 << 7,
142         FillColorChange                         = 1 << 8,
143         FillRuleChange                          = 1 << 9,
144         ShadowChange                            = 1 << 10,
145         ShadowColorChange                       = 1 << 11,
146         ShadowsIgnoreTransformsChange           = 1 << 12,
147         AlphaChange                             = 1 << 13,
148         CompositeOperationChange                = 1 << 14,
149         BlendModeChange                         = 1 << 15,
150         TextDrawingModeChange                   = 1 << 16,
151         ShouldAntialiasChange                   = 1 << 17,
152         ShouldSmoothFontsChange                 = 1 << 18,
153         AntialiasedFontDilationEnabledChange    = 1 << 19,
154         ShouldSubpixelQuantizeFontsChange       = 1 << 20,
155         DrawLuminanceMaskChange                 = 1 << 21,
156         ImageInterpolationQualityChange         = 1 << 22,
157     };
158     typedef uint32_t StateChangeFlags;
159
160     RefPtr<Gradient> strokeGradient;
161     RefPtr<Pattern> strokePattern;
162     
163     RefPtr<Gradient> fillGradient;
164     RefPtr<Pattern> fillPattern;
165
166     FloatSize shadowOffset;
167
168     float strokeThickness { 0 };
169     float shadowBlur { 0 };
170
171     TextDrawingModeFlags textDrawingMode { TextModeFill };
172
173     Color strokeColor { Color::black };
174     Color fillColor { Color::black };
175     Color shadowColor;
176
177     StrokeStyle strokeStyle { SolidStroke };
178     WindRule fillRule { RULE_NONZERO };
179
180     float alpha { 1 };
181     CompositeOperator compositeOperator { CompositeSourceOver };
182     BlendMode blendMode { BlendModeNormal };
183     InterpolationQuality imageInterpolationQuality { InterpolationDefault };
184
185     bool shouldAntialias : 1;
186     bool shouldSmoothFonts : 1;
187     bool antialiasedFontDilationEnabled : 1;
188     bool shouldSubpixelQuantizeFonts : 1;
189     bool shadowsIgnoreTransforms : 1;
190 #if USE(CG)
191     bool shadowsUseLegacyRadius : 1;
192 #endif
193     bool drawLuminanceMask : 1;
194 };
195
196 struct ImagePaintingOptions {
197     ImagePaintingOptions(CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), bool useLowQualityScale = false)
198         : m_compositeOperator(compositeOperator)
199         , m_blendMode(blendMode)
200         , m_orientationDescription(orientationDescription)
201         , m_useLowQualityScale(useLowQualityScale)
202     {
203     }
204
205     ImagePaintingOptions(ImageOrientationDescription orientationDescription, bool useLowQualityScale = false, CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal)
206         : m_compositeOperator(compositeOperator)
207         , m_blendMode(blendMode)
208         , m_orientationDescription(orientationDescription)
209         , m_useLowQualityScale(useLowQualityScale)
210     {
211     }
212
213     ImagePaintingOptions(bool useLowQualityScale, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal)
214         : m_compositeOperator(compositeOperator)
215         , m_blendMode(blendMode)
216         , m_orientationDescription(orientationDescription)
217         , m_useLowQualityScale(useLowQualityScale)
218     {
219     }
220
221     CompositeOperator m_compositeOperator;
222     BlendMode m_blendMode;
223     ImageOrientationDescription m_orientationDescription;
224     bool m_useLowQualityScale;
225 };
226
227 struct GraphicsContextStateChange {
228     GraphicsContextStateChange() = default;
229     GraphicsContextStateChange(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
230         : m_state(state)
231         , m_changeFlags(flags)
232     {
233     }
234
235     GraphicsContextState::StateChangeFlags changesFromState(const GraphicsContextState&) const;
236
237     void accumulate(const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
238     void apply(GraphicsContext&) const;
239     
240     void dump(TextStream&) const;
241
242     GraphicsContextState m_state;
243     GraphicsContextState::StateChangeFlags m_changeFlags { GraphicsContextState::NoChange };
244 };
245
246 TextStream& operator<<(TextStream&, const GraphicsContextStateChange&);
247
248
249 class GraphicsContext {
250     WTF_MAKE_NONCOPYABLE(GraphicsContext); WTF_MAKE_FAST_ALLOCATED;
251 public:
252     WEBCORE_EXPORT GraphicsContext(PlatformGraphicsContext*);
253     GraphicsContext() = default;
254     WEBCORE_EXPORT ~GraphicsContext();
255     
256     enum class NonPaintingReasons {
257         NoReasons,
258         UpdatingControlTints
259     };
260     GraphicsContext(NonPaintingReasons);
261
262     WEBCORE_EXPORT PlatformGraphicsContext* platformContext() const;
263
264     bool paintingDisabled() const { return !m_data && !isRecording(); }
265     bool updatingControlTints() const { return m_nonPaintingReasons == NonPaintingReasons::UpdatingControlTints; }
266
267     void setDisplayListRecorder(DisplayList::Recorder* recorder) { m_displayListRecorder = recorder; }
268     bool isRecording() const { return m_displayListRecorder; }
269
270     void setStrokeThickness(float);
271     float strokeThickness() const { return m_state.strokeThickness; }
272
273     void setStrokeStyle(StrokeStyle);
274     StrokeStyle strokeStyle() const { return m_state.strokeStyle; }
275
276     WEBCORE_EXPORT void setStrokeColor(const Color&);
277     Color strokeColor() const { return m_state.strokeColor; }
278
279     void setStrokePattern(Ref<Pattern>&&);
280     Pattern* strokePattern() const { return m_state.strokePattern.get(); }
281
282     void setStrokeGradient(Ref<Gradient>&&);
283     Gradient* strokeGradient() const { return m_state.strokeGradient.get(); }
284
285     void setFillRule(WindRule);
286     WindRule fillRule() const { return m_state.fillRule; }
287
288     WEBCORE_EXPORT void setFillColor(const Color&);
289     Color fillColor() const { return m_state.fillColor; }
290
291     void setFillPattern(Ref<Pattern>&&);
292     Pattern* fillPattern() const { return m_state.fillPattern.get(); }
293
294     WEBCORE_EXPORT void setFillGradient(Ref<Gradient>&&);
295     Gradient* fillGradient() const { return m_state.fillGradient.get(); }
296
297     void setShadowsIgnoreTransforms(bool);
298     bool shadowsIgnoreTransforms() const { return m_state.shadowsIgnoreTransforms; }
299
300     WEBCORE_EXPORT void setShouldAntialias(bool);
301     bool shouldAntialias() const { return m_state.shouldAntialias; }
302
303     WEBCORE_EXPORT void setAntialiasedFontDilationEnabled(bool);
304     bool antialiasedFontDilationEnabled() const { return m_state.antialiasedFontDilationEnabled; }
305
306     WEBCORE_EXPORT void setShouldSmoothFonts(bool);
307     bool shouldSmoothFonts() const { return m_state.shouldSmoothFonts; }
308
309     // Normally CG enables subpixel-quantization because it improves the performance of aligning glyphs.
310     // In some cases we have to disable to to ensure a high-quality output of the glyphs.
311     void setShouldSubpixelQuantizeFonts(bool);
312     bool shouldSubpixelQuantizeFonts() const { return m_state.shouldSubpixelQuantizeFonts; }
313
314     const GraphicsContextState& state() const { return m_state; }
315
316 #if USE(CG) || USE(CAIRO)
317     WEBCORE_EXPORT void drawNativeImage(PassNativeImagePtr, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, ImageOrientation = DefaultImageOrientation);
318 #endif
319
320 #if USE(CG)
321     void applyStrokePattern();
322     void applyFillPattern();
323     void drawPath(const Path&);
324
325     WEBCORE_EXPORT void setIsCALayerContext(bool);
326     bool isCALayerContext() const;
327
328     WEBCORE_EXPORT void setIsAcceleratedContext(bool);
329 #endif
330     bool isAcceleratedContext() const;
331     RenderingMode renderingMode() const { return isAcceleratedContext() ? Accelerated : Unaccelerated; }
332
333     WEBCORE_EXPORT void save();
334     WEBCORE_EXPORT void restore();
335
336     // These draw methods will do both stroking and filling.
337     // FIXME: ...except drawRect(), which fills properly but always strokes
338     // using a 1-pixel stroke inset from the rect borders (of the correct
339     // stroke color).
340     void drawRect(const FloatRect&, float borderThickness = 1);
341     void drawLine(const FloatPoint&, const FloatPoint&);
342
343     void drawEllipse(const FloatRect&);
344     void drawRaisedEllipse(const FloatRect&, const Color& ellipseColor, const Color& shadowColor);
345
346     WEBCORE_EXPORT void fillPath(const Path&);
347     void strokePath(const Path&);
348
349     void fillEllipse(const FloatRect&);
350     void strokeEllipse(const FloatRect&);
351
352     WEBCORE_EXPORT void fillRect(const FloatRect&);
353     WEBCORE_EXPORT void fillRect(const FloatRect&, const Color&);
354     void fillRect(const FloatRect&, Gradient&);
355     void fillRect(const FloatRect&, const Color&, CompositeOperator, BlendMode = BlendModeNormal);
356     void fillRoundedRect(const FloatRoundedRect&, const Color&, BlendMode = BlendModeNormal);
357     void fillRectWithRoundedHole(const FloatRect&, const FloatRoundedRect& roundedHoleRect, const Color&);
358
359     WEBCORE_EXPORT void clearRect(const FloatRect&);
360
361     WEBCORE_EXPORT void strokeRect(const FloatRect&, float lineWidth);
362
363     WEBCORE_EXPORT void drawImage(Image&, const FloatPoint& destination, const ImagePaintingOptions& = ImagePaintingOptions());
364     WEBCORE_EXPORT void drawImage(Image&, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
365     void drawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = ImagePaintingOptions());
366
367     void drawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& = ImagePaintingOptions());
368     void drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor,
369         Image::TileRule, Image::TileRule, const ImagePaintingOptions& = ImagePaintingOptions());
370
371     WEBCORE_EXPORT void drawImageBuffer(ImageBuffer&, const FloatPoint& destination, const ImagePaintingOptions& = ImagePaintingOptions());
372     void drawImageBuffer(ImageBuffer&, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
373     void drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = ImagePaintingOptions());
374
375     void drawPattern(Image&, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal);
376
377     WEBCORE_EXPORT void drawConsumingImageBuffer(std::unique_ptr<ImageBuffer>, const FloatPoint& destination, const ImagePaintingOptions& = ImagePaintingOptions());
378     void drawConsumingImageBuffer(std::unique_ptr<ImageBuffer>, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
379     void drawConsumingImageBuffer(std::unique_ptr<ImageBuffer>, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = ImagePaintingOptions());
380
381     WEBCORE_EXPORT void setImageInterpolationQuality(InterpolationQuality);
382     InterpolationQuality imageInterpolationQuality() const { return m_state.imageInterpolationQuality; }
383
384     WEBCORE_EXPORT void clip(const FloatRect&);
385     void clipRoundedRect(const FloatRoundedRect&);
386
387     void clipOut(const FloatRect&);
388     void clipOutRoundedRect(const FloatRoundedRect&);
389     void clipPath(const Path&, WindRule = RULE_EVENODD);
390     void clipToImageBuffer(ImageBuffer&, const FloatRect&);
391     
392     IntRect clipBounds() const;
393
394     void setTextDrawingMode(TextDrawingModeFlags);
395     TextDrawingModeFlags textDrawingMode() const { return m_state.textDrawingMode; }
396
397     float drawText(const FontCascade&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
398     void drawGlyphs(const FontCascade&, const Font&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
399     void drawEmphasisMarks(const FontCascade&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);
400     void drawBidiText(const FontCascade&, const TextRun&, const FloatPoint&, FontCascade::CustomFontNotReadyAction = FontCascade::DoNotPaintIfFontNotReady);
401
402     void applyState(const GraphicsContextState&);
403
404     enum RoundingMode {
405         RoundAllSides,
406         RoundOriginAndDimensions
407     };
408     FloatRect roundToDevicePixels(const FloatRect&, RoundingMode = RoundAllSides);
409
410     FloatRect computeUnderlineBoundsForText(const FloatPoint&, float width, bool printing);
411     WEBCORE_EXPORT void drawLineForText(const FloatPoint&, float width, bool printing, bool doubleLines = false);
412     void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines = false);
413     enum DocumentMarkerLineStyle {
414 #if PLATFORM(IOS)
415         TextCheckingDictationPhraseWithAlternativesLineStyle,
416 #endif
417         DocumentMarkerSpellingLineStyle,
418         DocumentMarkerGrammarLineStyle,
419         DocumentMarkerAutocorrectionReplacementLineStyle,
420         DocumentMarkerDictationAlternativesLineStyle
421     };
422     static void updateDocumentMarkerResources();
423     void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle);
424
425     WEBCORE_EXPORT void beginTransparencyLayer(float opacity);
426     WEBCORE_EXPORT void endTransparencyLayer();
427     bool isInTransparencyLayer() const { return (m_transparencyCount > 0) && supportsTransparencyLayers(); }
428
429     WEBCORE_EXPORT void setShadow(const FloatSize&, float blur, const Color&);
430     // Legacy shadow blur radius is used for canvas, and -webkit-box-shadow.
431     // It has different treatment of radii > 8px.
432     void setLegacyShadow(const FloatSize&, float blur, const Color&);
433
434     WEBCORE_EXPORT void clearShadow();
435     bool getShadow(FloatSize&, float&, Color&) const;
436
437     bool hasVisibleShadow() const { return m_state.shadowColor.isValid() && m_state.shadowColor.alpha(); }
438     bool hasShadow() const { return hasVisibleShadow() && (m_state.shadowBlur || m_state.shadowOffset.width() || m_state.shadowOffset.height()); }
439     bool hasBlurredShadow() const { return hasVisibleShadow() && m_state.shadowBlur; }
440
441 #if USE(CAIRO)
442     bool mustUseShadowBlur() const;
443 #endif
444
445     void drawFocusRing(const Vector<IntRect>&, float width, float offset, const Color&);
446     void drawFocusRing(const Path&, float width, float offset, const Color&);
447 #if PLATFORM(MAC)
448     void drawFocusRing(const Vector<IntRect>&, float width, float offset, double timeOffset, bool& needsRedraw);
449 #endif
450
451     void setLineCap(LineCap);
452     void setLineDash(const DashArray&, float dashOffset);
453     void setLineJoin(LineJoin);
454     void setMiterLimit(float);
455
456     void setAlpha(float);
457     float alpha() const { return m_state.alpha; }
458
459     WEBCORE_EXPORT void setCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
460     CompositeOperator compositeOperation() const { return m_state.compositeOperator; }
461     BlendMode blendModeOperation() const { return m_state.blendMode; }
462
463     void setDrawLuminanceMask(bool);
464     bool drawLuminanceMask() const { return m_state.drawLuminanceMask; }
465
466     // This clip function is used only by <canvas> code. It allows
467     // implementations to handle clipping on the canvas differently since
468     // the discipline is different.
469     void canvasClip(const Path&, WindRule = RULE_EVENODD);
470     void clipOut(const Path&);
471
472     WEBCORE_EXPORT void scale(const FloatSize&);
473     void rotate(float angleInRadians);
474     void translate(const FloatSize& size) { translate(size.width(), size.height()); }
475     WEBCORE_EXPORT void translate(float x, float y);
476
477     void setURLForRect(const URL&, const IntRect&);
478
479     void concatCTM(const AffineTransform&);
480     void setCTM(const AffineTransform&);
481
482     enum IncludeDeviceScale { DefinitelyIncludeDeviceScale, PossiblyIncludeDeviceScale };
483     AffineTransform getCTM(IncludeDeviceScale includeScale = PossiblyIncludeDeviceScale) const;
484
485 #if ENABLE(3D_TRANSFORMS) && USE(TEXTURE_MAPPER)
486     // This is needed when using accelerated-compositing in software mode, like in TextureMapper.
487     void concat3DTransform(const TransformationMatrix&);
488     void set3DTransform(const TransformationMatrix&);
489     TransformationMatrix get3DTransform() const;
490 #endif
491     // Create an image buffer compatible with this context, with suitable resolution
492     // for drawing into the buffer and then into this context.
493     std::unique_ptr<ImageBuffer> createCompatibleBuffer(const FloatSize&, bool hasAlpha = true) const;
494     bool isCompatibleWithBuffer(ImageBuffer&) const;
495
496     // This function applies the device scale factor to the context, making the context capable of
497     // acting as a base-level context for a HiDPI environment.
498     WEBCORE_EXPORT void applyDeviceScaleFactor(float);
499     void platformApplyDeviceScaleFactor(float);
500
501 #if OS(WINDOWS)
502     HDC getWindowsContext(const IntRect&, bool supportAlphaBlend, bool mayCreateBitmap); // The passed in rect is used to create a bitmap for compositing inside transparency layers.
503     void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend, bool mayCreateBitmap); // The passed in HDC should be the one handed back by getWindowsContext.
504     HDC hdc() const;
505 #if PLATFORM(WIN)
506 #if USE(WINGDI)
507     void setBitmap(PassRefPtr<SharedBitmap>);
508     const AffineTransform& affineTransform() const;
509     AffineTransform& affineTransform();
510     void resetAffineTransform();
511     void fillRect(const FloatRect&, const Gradient*);
512     void drawText(const Font&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
513     void drawFrameControl(const IntRect& rect, unsigned type, unsigned state);
514     void drawFocusRect(const IntRect& rect);
515     void paintTextField(const IntRect& rect, unsigned state);
516     void drawBitmap(SharedBitmap*, const IntRect& dstRect, const IntRect& srcRect, CompositeOperator, BlendMode);
517     void drawBitmapPattern(SharedBitmap*, const FloatRect& tileRectIn, const AffineTransform& patternTransform, const FloatPoint& phase, CompositeOperator, const FloatRect& destRect, const IntSize& origSourceSize);
518     void drawIcon(HICON icon, const IntRect& dstRect, UINT flags);
519     void drawRoundCorner(bool newClip, RECT clipRect, RECT rectWin, HDC dc, int width, int height);
520 #else
521     GraphicsContext(HDC, bool hasAlpha = false); // FIXME: To be removed.
522
523     // When set to true, child windows should be rendered into this context
524     // rather than allowing them just to render to the screen. Defaults to
525     // false.
526     // FIXME: This is a layering violation. GraphicsContext shouldn't know
527     // what a "window" is. It would be much more appropriate for this flag
528     // to be passed as a parameter alongside the GraphicsContext, but doing
529     // that would require lots of changes in cross-platform code that we
530     // aren't sure we want to make.
531     void setShouldIncludeChildWindows(bool);
532     bool shouldIncludeChildWindows() const;
533
534     class WindowsBitmap {
535         WTF_MAKE_NONCOPYABLE(WindowsBitmap);
536     public:
537         WindowsBitmap(HDC, const IntSize&);
538         ~WindowsBitmap();
539
540         HDC hdc() const { return m_hdc; }
541         UInt8* buffer() const { return m_pixelData.buffer(); }
542         unsigned bufferLength() const { return m_pixelData.bufferLength(); }
543         const IntSize& size() const { return m_pixelData.size(); }
544         unsigned bytesPerRow() const { return m_pixelData.bytesPerRow(); }
545         unsigned short bitsPerPixel() const { return m_pixelData.bitsPerPixel(); }
546         const DIBPixelData& windowsDIB() const { return m_pixelData; }
547
548     private:
549         HDC m_hdc;
550         HBITMAP m_bitmap;
551         DIBPixelData m_pixelData;
552     };
553
554     std::unique_ptr<WindowsBitmap> createWindowsBitmap(const IntSize&);
555     // The bitmap should be non-premultiplied.
556     void drawWindowsBitmap(WindowsBitmap*, const IntPoint&);
557 #endif
558 #else // PLATFORM(WIN)
559     bool shouldIncludeChildWindows() const { return false; }
560 #endif // PLATFORM(WIN)
561 #endif // OS(WINDOWS)
562
563 #if USE(CAIRO)
564     GraphicsContext(cairo_t*);
565 #endif
566
567     static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle);
568
569 private:
570     void platformInit(PlatformGraphicsContext*);
571     void platformDestroy();
572
573 #if PLATFORM(WIN) && !USE(WINGDI)
574     void platformInit(HDC, bool hasAlpha = false);
575 #endif
576
577     void savePlatformState();
578     void restorePlatformState();
579
580     void setPlatformTextDrawingMode(TextDrawingModeFlags);
581
582     void setPlatformStrokeColor(const Color&);
583     void setPlatformStrokeStyle(StrokeStyle);
584     void setPlatformStrokeThickness(float);
585
586     void setPlatformFillColor(const Color&);
587
588     void setPlatformShouldAntialias(bool);
589     void setPlatformShouldSmoothFonts(bool);
590     void setPlatformImageInterpolationQuality(InterpolationQuality);
591
592     void setPlatformShadow(const FloatSize&, float blur, const Color&);
593     void clearPlatformShadow();
594
595     void setPlatformAlpha(float);
596     void setPlatformCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
597
598     void beginPlatformTransparencyLayer(float opacity);
599     void endPlatformTransparencyLayer();
600     static bool supportsTransparencyLayers();
601
602     void fillEllipseAsPath(const FloatRect&);
603     void strokeEllipseAsPath(const FloatRect&);
604
605     void platformFillEllipse(const FloatRect&);
606     void platformStrokeEllipse(const FloatRect&);
607
608     void platformFillRoundedRect(const FloatRoundedRect&, const Color&);
609
610     FloatRect computeLineBoundsAndAntialiasingModeForText(const FloatPoint&, float width, bool printing,  Color&);
611
612     GraphicsContextPlatformPrivate* m_data { nullptr };
613     DisplayList::Recorder* m_displayListRecorder { nullptr };
614
615     GraphicsContextState m_state;
616     Vector<GraphicsContextState, 1> m_stack;
617
618     const NonPaintingReasons m_nonPaintingReasons { NonPaintingReasons::NoReasons };
619     unsigned m_transparencyCount { 0 };
620 };
621
622 class GraphicsContextStateSaver {
623     WTF_MAKE_FAST_ALLOCATED;
624 public:
625     GraphicsContextStateSaver(GraphicsContext& context, bool saveAndRestore = true)
626     : m_context(context)
627     , m_saveAndRestore(saveAndRestore)
628     {
629         if (m_saveAndRestore)
630             m_context.save();
631     }
632     
633     ~GraphicsContextStateSaver()
634     {
635         if (m_saveAndRestore)
636             m_context.restore();
637     }
638     
639     void save()
640     {
641         ASSERT(!m_saveAndRestore);
642         m_context.save();
643         m_saveAndRestore = true;
644     }
645
646     void restore()
647     {
648         ASSERT(m_saveAndRestore);
649         m_context.restore();
650         m_saveAndRestore = false;
651     }
652     
653     GraphicsContext* context() const { return &m_context; }
654
655 private:
656     GraphicsContext& m_context;
657     bool m_saveAndRestore;
658 };
659
660 } // namespace WebCore
661
662 #endif // GraphicsContext_h