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