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