2011-07-05 Igor Oliveira <igor.oliveira@openbossa.org>
[WebKit-https.git] / Source / WebCore / platform / graphics / GraphicsContext.h
1 /*
2  * Copyright (C) 2003, 2006, 2007, 2008, 2009 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 COMPUTER, 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 COMPUTER, 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 "Gradient.h"
34 #include "Image.h"
35 #include "Path.h"
36 #include "Pattern.h"
37 #include <wtf/Noncopyable.h>
38 #include <wtf/PassOwnPtr.h>
39
40 #if USE(CG)
41 typedef struct CGContext PlatformGraphicsContext;
42 #elif USE(CAIRO)
43 namespace WebCore {
44 class ContextShadow;
45 class PlatformContextCairo;
46 }
47 typedef WebCore::PlatformContextCairo PlatformGraphicsContext;
48 #elif PLATFORM(OPENVG)
49 namespace WebCore {
50 class SurfaceOpenVG;
51 }
52 typedef class WebCore::SurfaceOpenVG PlatformGraphicsContext;
53 #elif PLATFORM(QT)
54 #include <QPainter>
55 namespace WebCore {
56 class ContextShadow;
57 class ShadowBlur;
58 }
59 typedef QPainter PlatformGraphicsContext;
60 #elif PLATFORM(WX)
61 class wxGCDC;
62 class wxWindowDC;
63
64 // wxGraphicsContext allows us to support Path, etc.
65 // but on some platforms, e.g. Linux, it requires fairly
66 // new software.
67 #if USE(WXGC)
68 // On OS X, wxGCDC is just a typedef for wxDC, so use wxDC explicitly to make
69 // the linker happy.
70 #ifdef __APPLE__
71     class wxDC;
72     typedef wxDC PlatformGraphicsContext;
73 #else
74     typedef wxGCDC PlatformGraphicsContext;
75 #endif
76 #else
77     typedef wxWindowDC PlatformGraphicsContext;
78 #endif
79 #elif USE(SKIA)
80 namespace WebCore {
81 class PlatformContextSkia;
82 }
83 typedef WebCore::PlatformContextSkia PlatformGraphicsContext;
84 #elif PLATFORM(HAIKU)
85 class BView;
86 typedef BView PlatformGraphicsContext;
87 struct pattern;
88 #elif OS(WINCE)
89 typedef struct HDC__ PlatformGraphicsContext;
90 #else
91 typedef void PlatformGraphicsContext;
92 #endif
93
94 #if PLATFORM(WIN)
95 #include "DIBPixelData.h"
96 typedef struct HDC__* HDC;
97 #if !USE(CG)
98 // UInt8 is defined in CoreFoundation/CFBase.h
99 typedef unsigned char UInt8;
100 #endif
101 #endif
102
103 #if PLATFORM(QT) && defined(Q_WS_WIN)
104 #include <windows.h>
105 #endif
106
107 namespace WebCore {
108
109 #if OS(WINCE) && !PLATFORM(QT)
110     class SharedBitmap;
111     class SimpleFontData;
112     class GlyphBuffer;
113 #endif
114
115     const int cMisspellingLineThickness = 3;
116     const int cMisspellingLinePatternWidth = 4;
117     const int cMisspellingLinePatternGapWidth = 1;
118
119     class AffineTransform;
120     class DrawingBuffer;
121     class Font;
122     class Generator;
123     class GraphicsContextPlatformPrivate;
124     class ImageBuffer;
125     class IntRect;
126     class RoundedIntRect;
127     class KURL;
128     class SharedGraphicsContext3D;
129     class TextRun;
130
131     enum TextDrawingMode {
132         TextModeInvisible = 0,
133         TextModeFill      = 1 << 0,
134         TextModeStroke    = 1 << 1,
135         TextModeClip      = 1 << 2
136     };
137     typedef unsigned TextDrawingModeFlags;
138
139     enum StrokeStyle {
140         NoStroke,
141         SolidStroke,
142         DottedStroke,
143         DashedStroke
144     };
145
146     enum InterpolationQuality {
147         InterpolationDefault,
148         InterpolationNone,
149         InterpolationLow,
150         InterpolationMedium,
151         InterpolationHigh
152     };
153
154     struct GraphicsContextState {
155         GraphicsContextState()
156             : strokeThickness(0)
157             , shadowBlur(0)
158             , textDrawingMode(TextModeFill)
159             , strokeColor(Color::black)
160             , fillColor(Color::black)
161             , strokeStyle(SolidStroke)
162             , fillRule(RULE_NONZERO)
163             , strokeColorSpace(ColorSpaceDeviceRGB)
164             , fillColorSpace(ColorSpaceDeviceRGB)
165             , shadowColorSpace(ColorSpaceDeviceRGB)
166             , compositeOperator(CompositeSourceOver)
167             , shouldAntialias(true)
168             , shouldSmoothFonts(true)
169             , paintingDisabled(false)
170             , shadowsIgnoreTransforms(false)
171 #if USE(CG)
172             // Core Graphics incorrectly renders shadows with radius > 8px (<rdar://problem/8103442>),
173             // but we need to preserve this buggy behavior for canvas and -webkit-box-shadow.
174             , shadowsUseLegacyRadius(false)
175 #endif
176         {
177         }
178
179         RefPtr<Gradient> strokeGradient;
180         RefPtr<Pattern> strokePattern;
181         
182         RefPtr<Gradient> fillGradient;
183         RefPtr<Pattern> fillPattern;
184
185         FloatSize shadowOffset;
186
187         float strokeThickness;
188         float shadowBlur;
189
190         TextDrawingModeFlags textDrawingMode;
191
192         Color strokeColor;
193         Color fillColor;
194         Color shadowColor;
195
196         StrokeStyle strokeStyle;
197         WindRule fillRule;
198
199         ColorSpace strokeColorSpace;
200         ColorSpace fillColorSpace;
201         ColorSpace shadowColorSpace;
202
203         CompositeOperator compositeOperator;
204
205         bool shouldAntialias : 1;
206         bool shouldSmoothFonts : 1;
207         bool paintingDisabled : 1;
208         bool shadowsIgnoreTransforms : 1;
209 #if USE(CG)
210         bool shadowsUseLegacyRadius : 1;
211 #endif
212     };
213
214     class GraphicsContext {
215         WTF_MAKE_NONCOPYABLE(GraphicsContext); WTF_MAKE_FAST_ALLOCATED;
216     public:
217         GraphicsContext(PlatformGraphicsContext*);
218         ~GraphicsContext();
219
220 #if !OS(WINCE) || PLATFORM(QT)
221         PlatformGraphicsContext* platformContext() const;
222 #endif
223
224         float strokeThickness() const;
225         void setStrokeThickness(float);
226         StrokeStyle strokeStyle() const;
227         void setStrokeStyle(StrokeStyle);
228         Color strokeColor() const;
229         ColorSpace strokeColorSpace() const;
230         void setStrokeColor(const Color&, ColorSpace);
231
232         void setStrokePattern(PassRefPtr<Pattern>);
233         Pattern* strokePattern() const;
234
235         void setStrokeGradient(PassRefPtr<Gradient>);
236         Gradient* strokeGradient() const;
237
238         WindRule fillRule() const;
239         void setFillRule(WindRule);
240         Color fillColor() const;
241         ColorSpace fillColorSpace() const;
242         void setFillColor(const Color&, ColorSpace);
243
244         void setFillPattern(PassRefPtr<Pattern>);
245         Pattern* fillPattern() const;
246
247         void setFillGradient(PassRefPtr<Gradient>);
248         Gradient* fillGradient() const;
249
250         void setShadowsIgnoreTransforms(bool);
251         bool shadowsIgnoreTransforms() const;
252
253         void setShouldAntialias(bool);
254         bool shouldAntialias() const;
255
256         void setShouldSmoothFonts(bool);
257         bool shouldSmoothFonts() const;
258
259         const GraphicsContextState& state() const;
260
261 #if USE(CG)
262         void applyStrokePattern();
263         void applyFillPattern();
264         void drawPath(const Path&);
265         
266         // Allow font smoothing (LCD antialiasing). Not part of the graphics state.
267         void setAllowsFontSmoothing(bool);
268         
269         void setIsCALayerContext(bool);
270         bool isCALayerContext() const;
271
272         void setIsAcceleratedContext(bool);
273         bool isAcceleratedContext() const;
274 #endif
275
276         void save();
277         void restore();
278
279         // These draw methods will do both stroking and filling.
280         // FIXME: ...except drawRect(), which fills properly but always strokes
281         // using a 1-pixel stroke inset from the rect borders (of the correct
282         // stroke color).
283         void drawRect(const IntRect&);
284         void drawLine(const IntPoint&, const IntPoint&);
285         void drawEllipse(const IntRect&);
286         void drawConvexPolygon(size_t numPoints, const FloatPoint*, bool shouldAntialias = false);
287
288         void fillPath(const Path&);
289         void strokePath(const Path&);
290
291         // Arc drawing (used by border-radius in CSS) just supports stroking at the moment.
292         void strokeArc(const IntRect&, int startAngle, int angleSpan);
293
294         void fillRect(const FloatRect&);
295         void fillRect(const FloatRect&, const Color&, ColorSpace);
296         void fillRect(const FloatRect&, Generator&);
297         void fillRect(const FloatRect&, const Color&, ColorSpace, CompositeOperator);
298         void fillRoundedRect(const IntRect&, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color&, ColorSpace);
299         void fillRoundedRect(const RoundedIntRect&, const Color&, ColorSpace);
300         void fillRectWithRoundedHole(const IntRect&, const RoundedIntRect& roundedHoleRect, const Color&, ColorSpace);
301
302         void clearRect(const FloatRect&);
303
304         void strokeRect(const FloatRect&, float lineWidth);
305
306         void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver);
307         void drawImage(Image*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
308         void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver);
309         void drawImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
310         void drawImage(Image*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),
311                        CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
312         void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize,
313                        CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
314         void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect,
315                             Image::TileRule hRule = Image::StretchTile, Image::TileRule vRule = Image::StretchTile,
316                             CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
317
318         void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver);
319         void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
320         void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver);
321         void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
322         void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),
323                              CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
324
325         void setImageInterpolationQuality(InterpolationQuality);
326         InterpolationQuality imageInterpolationQuality() const;
327
328         void clip(const IntRect&);
329         void clip(const FloatRect&);
330         void addRoundedRectClip(const RoundedIntRect&);
331         void addInnerRoundedRectClip(const IntRect&, int thickness);
332         void clipOut(const IntRect&);
333         void clipOutRoundedRect(const RoundedIntRect&);
334         void clipPath(const Path&, WindRule);
335         void clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias = true);
336         void clipToImageBuffer(ImageBuffer*, const FloatRect&);
337         
338         IntRect clipBounds() const;
339
340         TextDrawingModeFlags textDrawingMode() const;
341         void setTextDrawingMode(TextDrawingModeFlags);
342
343         void drawText(const Font&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
344         void drawEmphasisMarks(const Font&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);
345         void drawBidiText(const Font&, const TextRun&, const FloatPoint&);
346         void drawHighlightForText(const Font&, const TextRun&, const FloatPoint&, int h, const Color& backgroundColor, ColorSpace, int from = 0, int to = -1);
347
348         enum RoundingMode {
349             RoundAllSides,
350             RoundOriginAndDimensions
351         };
352         FloatRect roundToDevicePixels(const FloatRect&, RoundingMode = RoundAllSides);
353
354         void drawLineForText(const FloatPoint&, float width, bool printing);
355         enum TextCheckingLineStyle {
356             TextCheckingSpellingLineStyle,
357             TextCheckingGrammarLineStyle,
358             TextCheckingReplacementLineStyle
359         };
360         void drawLineForTextChecking(const FloatPoint&, float width, TextCheckingLineStyle);
361
362         bool paintingDisabled() const;
363         void setPaintingDisabled(bool);
364
365         bool updatingControlTints() const;
366         void setUpdatingControlTints(bool);
367
368         void beginTransparencyLayer(float opacity);
369         void endTransparencyLayer();
370
371         bool hasShadow() const;
372         void setShadow(const FloatSize&, float blur, const Color&, ColorSpace);
373         // Legacy shadow blur radius is used for canvas, and -webkit-box-shadow.
374         // It has different treatment of radii > 8px.
375         void setLegacyShadow(const FloatSize&, float blur, const Color&, ColorSpace);
376
377         bool getShadow(FloatSize&, float&, Color&, ColorSpace&) const;
378         void clearShadow();
379
380         void drawFocusRing(const Vector<IntRect>&, int width, int offset, const Color&);
381         void drawFocusRing(const Path&, int width, int offset, const Color&);
382
383         void setLineCap(LineCap);
384         void setLineDash(const DashArray&, float dashOffset);
385         void setLineJoin(LineJoin);
386         void setMiterLimit(float);
387
388         void setAlpha(float);
389
390         void setCompositeOperation(CompositeOperator);
391         CompositeOperator compositeOperation() const;
392
393         void clip(const Path&);
394
395         // This clip function is used only by <canvas> code. It allows
396         // implementations to handle clipping on the canvas differently since
397         // the discipline is different.
398         void canvasClip(const Path&);
399         void clipOut(const Path&);
400
401         void scale(const FloatSize&);
402         void rotate(float angleInRadians);
403         void translate(const FloatSize& size) { translate(size.width(), size.height()); }
404         void translate(float x, float y);
405
406         void setURLForRect(const KURL&, const IntRect&);
407
408         void concatCTM(const AffineTransform&);
409         void setCTM(const AffineTransform&);
410         AffineTransform getCTM() const;
411
412 #if OS(WINCE) && !PLATFORM(QT)
413         void setBitmap(PassRefPtr<SharedBitmap>);
414         const AffineTransform& affineTransform() const;
415         AffineTransform& affineTransform();
416         void resetAffineTransform();
417         void fillRect(const FloatRect&, const Gradient*);
418         void drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point);
419         void drawFrameControl(const IntRect& rect, unsigned type, unsigned state);
420         void drawFocusRect(const IntRect& rect);
421         void paintTextField(const IntRect& rect, unsigned state);
422         void drawBitmap(SharedBitmap*, const IntRect& dstRect, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp);
423         void drawBitmapPattern(SharedBitmap*, const FloatRect& tileRectIn, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize);
424         void drawIcon(HICON icon, const IntRect& dstRect, UINT flags);
425         bool inTransparencyLayer() const { return false; }
426         HDC getWindowsContext(const IntRect&, bool supportAlphaBlend = false, bool mayCreateBitmap = true); // The passed in rect is used to create a bitmap for compositing inside transparency layers.
427         void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend = false, bool mayCreateBitmap = true);    // The passed in HDC should be the one handed back by getWindowsContext.
428         void drawRoundCorner(bool newClip, RECT clipRect, RECT rectWin, HDC dc, int width, int height);
429 #elif PLATFORM(WIN)
430         GraphicsContext(HDC, bool hasAlpha = false); // FIXME: To be removed.
431         bool inTransparencyLayer() const;
432         HDC getWindowsContext(const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true); // The passed in rect is used to create a bitmap for compositing inside transparency layers.
433         void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true);    // The passed in HDC should be the one handed back by getWindowsContext.
434
435         // When set to true, child windows should be rendered into this context
436         // rather than allowing them just to render to the screen. Defaults to
437         // false.
438         // FIXME: This is a layering violation. GraphicsContext shouldn't know
439         // what a "window" is. It would be much more appropriate for this flag
440         // to be passed as a parameter alongside the GraphicsContext, but doing
441         // that would require lots of changes in cross-platform code that we
442         // aren't sure we want to make.
443         void setShouldIncludeChildWindows(bool);
444         bool shouldIncludeChildWindows() const;
445
446         class WindowsBitmap {
447             WTF_MAKE_NONCOPYABLE(WindowsBitmap);
448         public:
449             WindowsBitmap(HDC, const IntSize&);
450             ~WindowsBitmap();
451
452             HDC hdc() const { return m_hdc; }
453             UInt8* buffer() const { return m_pixelData.buffer(); }
454             unsigned bufferLength() const { return m_pixelData.bufferLength(); }
455             const IntSize& size() const { return m_pixelData.size(); }
456             unsigned bytesPerRow() const { return m_pixelData.bytesPerRow(); }
457             unsigned short bitsPerPixel() const { return m_pixelData.bitsPerPixel(); }
458             const DIBPixelData& windowsDIB() const { return m_pixelData; }
459
460         private:
461             HDC m_hdc;
462             HBITMAP m_bitmap;
463             DIBPixelData m_pixelData;
464         };
465
466         PassOwnPtr<WindowsBitmap> createWindowsBitmap(const IntSize&);
467         // The bitmap should be non-premultiplied.
468         void drawWindowsBitmap(WindowsBitmap*, const IntPoint&);
469 #endif
470
471 #if (PLATFORM(QT) && defined(Q_WS_WIN)) || (PLATFORM(WX) && OS(WINDOWS))
472         HDC getWindowsContext(const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true);
473         void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true);
474         bool shouldIncludeChildWindows() const { return false; }
475 #endif
476
477 #if PLATFORM(WX)
478         // This is needed because of a bug whereby getting an HDC from a GDI+ context
479         // loses the scale operations applied to the context.
480         FloatSize currentScale(); 
481         bool inTransparencyLayer() const { return false; }
482 #endif
483
484 #if PLATFORM(QT)
485         bool inTransparencyLayer() const;
486         void pushTransparencyLayerInternal(const QRect &rect, qreal opacity, QPixmap& alphaMask);
487         void takeOwnershipOfPlatformContext();
488 #endif
489
490 #if USE(CAIRO)
491         ContextShadow* contextShadow();
492 #endif
493
494 #if PLATFORM(QT)
495         ShadowBlur* shadowBlur();
496 #endif
497
498 #if USE(CAIRO)
499         GraphicsContext(cairo_t*);
500 #endif
501
502 #if PLATFORM(GTK)
503         void setGdkExposeEvent(GdkEventExpose*);
504         GdkWindow* gdkWindow() const;
505         GdkEventExpose* gdkExposeEvent() const;
506 #endif
507
508 #if PLATFORM(HAIKU)
509         pattern getHaikuStrokeStyle();
510 #endif
511
512         void setSharedGraphicsContext3D(SharedGraphicsContext3D*, DrawingBuffer*, const IntSize&);
513         void syncSoftwareCanvas();
514         void markDirtyRect(const IntRect&); // Hints that a portion of the backing store is dirty.
515
516         static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle);
517
518     private:
519         void platformInit(PlatformGraphicsContext*);
520         void platformDestroy();
521
522 #if PLATFORM(WIN) && !OS(WINCE)
523         void platformInit(HDC, bool hasAlpha = false);
524 #endif
525
526         void savePlatformState();
527         void restorePlatformState();
528
529         void setPlatformTextDrawingMode(TextDrawingModeFlags);
530         void setPlatformFont(const Font& font);
531
532         void setPlatformStrokeColor(const Color&, ColorSpace);
533         void setPlatformStrokeStyle(StrokeStyle);
534         void setPlatformStrokeThickness(float);
535         void setPlatformStrokeGradient(Gradient*);
536         void setPlatformStrokePattern(Pattern*);
537
538         void setPlatformFillColor(const Color&, ColorSpace);
539         void setPlatformFillGradient(Gradient*);
540         void setPlatformFillPattern(Pattern*);
541
542         void setPlatformShouldAntialias(bool);
543         void setPlatformShouldSmoothFonts(bool);
544
545         void setPlatformShadow(const FloatSize&, float blur, const Color&, ColorSpace);
546         void clearPlatformShadow();
547
548         void setPlatformCompositeOperation(CompositeOperator);
549
550         GraphicsContextPlatformPrivate* m_data;
551
552         GraphicsContextState m_state;
553         Vector<GraphicsContextState> m_stack;
554         bool m_updatingControlTints;
555     };
556
557     class GraphicsContextStateSaver {
558     public:
559         GraphicsContextStateSaver(GraphicsContext& context, bool saveAndRestore = true)
560         : m_context(context)
561         , m_saveAndRestore(saveAndRestore)
562         {
563             if (m_saveAndRestore)
564                 m_context.save();
565         }
566         
567         ~GraphicsContextStateSaver()
568         {
569             if (m_saveAndRestore)
570                 m_context.restore();
571         }
572         
573         void save()
574         {
575             ASSERT(!m_saveAndRestore);
576             m_context.save();
577             m_saveAndRestore = true;
578         }
579
580         void restore()
581         {
582             ASSERT(m_saveAndRestore);
583             m_context.restore();
584             m_saveAndRestore = false;
585         }
586         
587     private:
588         GraphicsContext& m_context;
589         bool m_saveAndRestore;
590     };
591
592 } // namespace WebCore
593
594 #endif // GraphicsContext_h
595