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