9e39da581d304d39b9604c76f0ad2461fbda09fe
[WebKit-https.git] / 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 "SkDashPathEffect.h"
38 #include "SkDrawLooper.h"
39 #include "SkDeque.h"
40 #include "skia/ext/platform_canvas.h"
41 #include "SkPaint.h"
42 #include "SkPath.h"
43
44 #include <wtf/Vector.h>
45
46 typedef struct _GdkDrawable GdkSkia;
47
48 // This class holds the platform-specific state for GraphicsContext. We put
49 // most of our Skia wrappers on this class. In theory, a lot of this stuff could
50 // be moved to GraphicsContext directly, except that some code external to this
51 // would like to poke at our graphics layer as well (like the Image and Font
52 // stuff, which needs some amount of our wrappers and state around SkCanvas).
53 //
54 // So in general, this class uses just Skia types except when there's no easy
55 // conversion. GraphicsContext is responsible for converting the WebKit types to
56 // Skia types and setting up the eventual call to the Skia functions.
57 //
58 // This class then keeps track of all the current Skia state. WebKit expects
59 // that the graphics state that is pushed and popped by save() and restore()
60 // includes things like colors and pen styles. Skia does this differently, where
61 // push and pop only includes transforms and bitmaps, and the application is
62 // responsible for managing the painting state which is store in separate
63 // SkPaint objects. This class provides the adaptor that allows the painting
64 // state to be pushed and popped along with the bitmap.
65 class PlatformContextSkia : Noncopyable {
66 public:
67     // For printing, there shouldn't be any canvas. canvas can be NULL. If you
68     // supply a NULL canvas, you can also call setCanvas later.
69     PlatformContextSkia(skia::PlatformCanvas*);
70     ~PlatformContextSkia();
71
72     // Sets the canvas associated with this context. Use when supplying NULL
73     // to the constructor.
74     void setCanvas(skia::PlatformCanvas*);
75
76 #if PLATFORM(WIN_OS)
77     // If false we're rendering to a GraphicsContext for a web page, if false
78     // we're not (as is the case when rendering to a canvas object).
79     // If this is true the contents have not been marked up with the magic
80     // color and all text drawing needs to go to a layer so that the alpha is
81     // correctly updated.
82     void setDrawingToImageBuffer(bool);
83     bool isDrawingToImageBuffer() const;
84 #endif
85
86     void save();
87     void restore();
88
89     // Begins a layer that is clipped to the image |imageBuffer| at the location
90     // |rect|. This layer is implicitly restored when the next restore is
91     // invoked.
92     // NOTE: |imageBuffer| may be deleted before the |restore| is invoked.
93 #if defined(__linux__) || PLATFORM(WIN_OS)
94     void beginLayerClippedToImage(const WebCore::FloatRect&,
95                                   const WebCore::ImageBuffer*);
96 #endif
97
98     // Sets up the common flags on a paint for antialiasing, effects, etc.
99     // This is implicitly called by setupPaintFill and setupPaintStroke, but
100     // you may wish to call it directly sometimes if you don't want that other
101     // behavior.
102     void setupPaintCommon(SkPaint*) const;
103
104     // Sets up the paint for the current fill style.
105     void setupPaintForFilling(SkPaint*) const;
106
107     // Sets up the paint for stroking. Returns an int representing the width of
108     // the pen, or 1 if the pen's width is 0 if a non-zero length is provided,
109     // the number of dashes/dots on a dashed/dotted line will be adjusted to
110     // start and end that length with a dash/dot.
111     float setupPaintForStroking(SkPaint*, SkRect*, int length) const;
112
113     // State setting functions.
114     void setDrawLooper(SkDrawLooper*);  // Note: takes an additional ref.
115     void setMiterLimit(float);
116     void setAlpha(float);
117     void setLineCap(SkPaint::Cap);
118     void setLineJoin(SkPaint::Join);
119     void setFillRule(SkPath::FillType);
120     void setPorterDuffMode(SkPorterDuff::Mode);
121     void setFillColor(SkColor);
122     void setStrokeStyle(WebCore::StrokeStyle);
123     void setStrokeColor(SkColor);
124     void setStrokeThickness(float thickness);
125     void setTextDrawingMode(int mode);
126     void setUseAntialiasing(bool enable);
127     void setGradient(SkShader*);
128     void setPattern(SkShader*);
129     void setDashPathEffect(SkDashPathEffect*);
130
131     SkDrawLooper* getDrawLooper() const;
132     WebCore::StrokeStyle getStrokeStyle() const;
133     float getStrokeThickness() const;
134     int getTextDrawingMode() const;
135
136     void beginPath();
137     void addPath(const SkPath&);
138     SkPath currentPathInLocalCoordinates() const;
139
140     // Returns the fill color. The returned color has it's alpha adjusted
141     // by the current alpha.
142     SkColor effectiveFillColor() const;
143
144     // Returns the stroke color. The returned color has it's alpha adjusted
145     // by the current alpha.
146     SkColor effectiveStrokeColor() const;
147
148     skia::PlatformCanvas* canvas() { return m_canvas; }
149
150     // FIXME: This should be pushed down to GraphicsContext.
151     void drawRect(SkRect rect);
152
153     // FIXME: I'm still unsure how I will serialize this call.
154     void paintSkPaint(const SkRect&, const SkPaint&);
155
156     const SkBitmap* bitmap() const;
157
158     // Returns the canvas used for painting, NOT guaranteed to be non-NULL.
159     //
160     // Warning: This function is deprecated so the users are reminded that they
161     // should use this layer of indirection instead of using the canvas
162     // directly. This is to help with the eventual serialization.
163     skia::PlatformCanvas* canvas() const;
164
165     // Returns if the context is a printing context instead of a display
166     // context. Bitmap shouldn't be resampled when printing to keep the best
167     // possible quality.
168     bool isPrinting();
169
170 #if defined(__linux__)
171     // FIXME: should be camelCase.
172     GdkSkia* gdk_skia() const { return m_gdkskia; }
173 #endif
174
175 private:
176 #if defined(__linux__) || PLATFORM(WIN_OS)
177     // Used when restoring and the state has an image clip. Only shows the pixels in
178     // m_canvas that are also in imageBuffer.
179     void applyClipFromImage(const WebCore::FloatRect&, const SkBitmap&);
180 #endif
181
182     // Defines drawing style.
183     struct State;
184
185     // NULL indicates painting is disabled. Never delete this object.
186     skia::PlatformCanvas* m_canvas;
187
188     // States stack. Enables local drawing state change with save()/restore()
189     // calls.
190     WTF::Vector<State> m_stateStack;
191     // Pointer to the current drawing state. This is a cached value of
192     // mStateStack.back().
193     State* m_state;
194
195     // Current path in global coordinates.
196     SkPath m_path;
197
198 #if defined(__linux__)
199     // A pointer to a GDK Drawable wrapping of this Skia canvas
200     GdkSkia* m_gdkskia;
201 #endif
202
203 #if PLATFORM(WIN_OS)
204     bool m_drawingToImageBuffer;
205 #endif
206 };
207
208 #endif  // PlatformContextSkia_h