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