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