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