698256141be891a6afab93ed63ebcfe7e5d3d026
[WebKit-https.git] / Source / WebCore / platform / graphics / skia / PlatformContextSkia.h
1 /*
2  * Copyright (c) 2008, Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef PlatformContextSkia_h
32 #define PlatformContextSkia_h
33
34 #include "GraphicsContext.h"
35 #include "Noncopyable.h"
36
37 #include "SkCanvas.h"
38 #include "SkDashPathEffect.h"
39 #include "SkDrawLooper.h"
40 #include "SkPaint.h"
41 #include "SkPath.h"
42
43 #include <wtf/Vector.h>
44
45 namespace WebCore {
46
47 enum CompositeOperator;
48 class DrawingBuffer;
49 class GraphicsContext3D;
50 class Texture;
51
52 // This class holds the platform-specific state for GraphicsContext. We put
53 // most of our Skia wrappers on this class. In theory, a lot of this stuff could
54 // be moved to GraphicsContext directly, except that some code external to this
55 // would like to poke at our graphics layer as well (like the Image and Font
56 // stuff, which needs some amount of our wrappers and state around SkCanvas).
57 //
58 // So in general, this class uses just Skia types except when there's no easy
59 // conversion. GraphicsContext is responsible for converting the WebKit types to
60 // Skia types and setting up the eventual call to the Skia functions.
61 //
62 // This class then keeps track of all the current Skia state. WebKit expects
63 // that the graphics state that is pushed and popped by save() and restore()
64 // includes things like colors and pen styles. Skia does this differently, where
65 // push and pop only includes transforms and bitmaps, and the application is
66 // responsible for managing the painting state which is store in separate
67 // SkPaint objects. This class provides the adaptor that allows the painting
68 // state to be pushed and popped along with the bitmap.
69 class PlatformContextSkia {
70     WTF_MAKE_NONCOPYABLE(PlatformContextSkia);
71 public:
72     // For printing, there shouldn't be any canvas. canvas can be NULL. If you
73     // supply a NULL canvas, you can also call setCanvas later.
74     PlatformContextSkia(SkCanvas*);
75     ~PlatformContextSkia();
76
77     // Sets the graphics context associated with this context.
78     // GraphicsContextSkia calls this from its constructor.
79     void setGraphicsContext(const GraphicsContext* gc) { m_gc = gc; }
80
81     // Sets the canvas associated with this context. Use when supplying NULL
82     // to the constructor.
83     void setCanvas(SkCanvas*);
84
85     // If false we're rendering to a GraphicsContext for a web page, if false
86     // we're not (as is the case when rendering to a canvas object).
87     // If this is true the contents have not been marked up with the magic
88     // color and all text drawing needs to go to a layer so that the alpha is
89     // correctly updated.
90     void setDrawingToImageBuffer(bool);
91     bool isDrawingToImageBuffer() const;
92
93     void save();
94     void restore();
95
96     // Begins a layer that is clipped to the image |imageBuffer| at the location
97     // |rect|. This layer is implicitly restored when the next restore is
98     // invoked.
99     // NOTE: |imageBuffer| may be deleted before the |restore| is invoked.
100     void beginLayerClippedToImage(const FloatRect&, const ImageBuffer*);
101     void clipPathAntiAliased(const SkPath&);
102
103     // Sets up the common flags on a paint for antialiasing, effects, etc.
104     // This is implicitly called by setupPaintFill and setupPaintStroke, but
105     // you may wish to call it directly sometimes if you don't want that other
106     // behavior.
107     void setupPaintCommon(SkPaint*) const;
108
109     // Sets up the paint for the current fill style.
110     void setupPaintForFilling(SkPaint*) const;
111
112     // Sets up the paint for stroking. Returns an int representing the width of
113     // the pen, or 1 if the pen's width is 0 if a non-zero length is provided,
114     // the number of dashes/dots on a dashed/dotted line will be adjusted to
115     // start and end that length with a dash/dot.
116     float setupPaintForStroking(SkPaint*, SkRect*, int length) const;
117
118     // State setting functions.
119     void setDrawLooper(SkDrawLooper*);  // Note: takes an additional ref.
120     void setMiterLimit(float);
121     void setAlpha(float);
122     void setLineCap(SkPaint::Cap);
123     void setLineJoin(SkPaint::Join);
124     void setXfermodeMode(SkXfermode::Mode);
125     void setFillColor(SkColor);
126     void setStrokeStyle(StrokeStyle);
127     void setStrokeColor(SkColor);
128     void setStrokeThickness(float thickness);
129     void setTextDrawingMode(TextDrawingModeFlags mode);
130     void setUseAntialiasing(bool enable);
131     void setDashPathEffect(SkDashPathEffect*);
132
133     SkDrawLooper* getDrawLooper() const;
134     StrokeStyle getStrokeStyle() const;
135     float getStrokeThickness() const;
136     TextDrawingModeFlags getTextDrawingMode() const;
137     float getAlpha() const;
138     int getNormalizedAlpha() const;
139
140     void canvasClipPath(const SkPath&);
141
142     // Returns the fill color. The returned color has it's alpha adjusted
143     // by the current alpha.
144     SkColor effectiveFillColor() const;
145
146     // Returns the stroke color. The returned color has it's alpha adjusted
147     // by the current alpha.
148     SkColor effectiveStrokeColor() const;
149
150     // Returns the canvas used for painting, NOT guaranteed to be non-null.
151     SkCanvas* canvas() { return m_canvas; }
152
153     InterpolationQuality interpolationQuality() const;
154     void setInterpolationQuality(InterpolationQuality interpolationQuality);
155
156     // FIXME: This should be pushed down to GraphicsContext.
157     void drawRect(SkRect rect);
158
159     // FIXME: I'm still unsure how I will serialize this call.
160     void paintSkPaint(const SkRect&, const SkPaint&);
161
162     const SkBitmap* bitmap() const;
163
164     // Returns if the context is a printing context instead of a display
165     // context. Bitmap shouldn't be resampled when printing to keep the best
166     // possible quality.
167     bool printing() const { return m_printing; }
168     void setPrinting(bool p) { m_printing = p; }
169
170     // Returns if the context allows rendering of fonts using native platform
171     // APIs. If false is returned font rendering is performed using the skia
172     // text drawing APIs.
173     bool isNativeFontRenderingAllowed();
174
175     void getImageResamplingHint(IntSize* srcSize, FloatSize* dstSize) const;
176     void setImageResamplingHint(const IntSize& srcSize, const FloatSize& dstSize);
177     void clearImageResamplingHint();
178     bool hasImageResamplingHint() const;
179
180     bool useSkiaGPU() const { return m_gpuContext; }
181     void setGraphicsContext3D(GraphicsContext3D*, DrawingBuffer*, const IntSize&);
182     void makeGrContextCurrent();
183
184 private:
185     // Used when restoring and the state has an image clip. Only shows the pixels in
186     // m_canvas that are also in imageBuffer.
187     void applyClipFromImage(const FloatRect&, const SkBitmap&);
188     void applyAntiAliasedClipPaths(WTF::Vector<SkPath>& paths);
189
190     // common code between setupPaintFor[Filling,Stroking]
191     void setupShader(SkPaint*, Gradient*, Pattern*, SkColor) const;
192
193     // Defines drawing style.
194     struct State;
195
196     // NULL indicates painting is disabled. Never delete this object.
197     SkCanvas* m_canvas;
198     const GraphicsContext* m_gc;
199
200     // States stack. Enables local drawing state change with save()/restore()
201     // calls.
202     WTF::Vector<State> m_stateStack;
203     // Pointer to the current drawing state. This is a cached value of
204     // mStateStack.back().
205     State* m_state;
206
207     // Stores image sizes for a hint to compute image resampling modes.
208     // Values are used in ImageSkia.cpp
209     IntSize m_imageResamplingHintSrcSize;
210     FloatSize m_imageResamplingHintDstSize;
211     bool m_printing;
212     bool m_drawingToImageBuffer;
213     GraphicsContext3D* m_gpuContext;
214 };
215
216 }
217 #endif // PlatformContextSkia_h