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 "SkPaint.h" 40 #include "SkPath.h" 41 #include "skia/ext/platform_canvas.h" 42 43 #include <wtf/Vector.h> 44 45 namespace WebCore { 46 47 enum CompositeOperator; 48 class DrawingBuffer; 49 class GLES2Canvas; 50 class GraphicsContext3D; 51 class Texture; 52 53 // This class holds the platform-specific state for GraphicsContext. We put 54 // most of our Skia wrappers on this class. In theory, a lot of this stuff could 55 // be moved to GraphicsContext directly, except that some code external to this 56 // would like to poke at our graphics layer as well (like the Image and Font 57 // stuff, which needs some amount of our wrappers and state around SkCanvas). 58 // 59 // So in general, this class uses just Skia types except when there's no easy 60 // conversion. GraphicsContext is responsible for converting the WebKit types to 61 // Skia types and setting up the eventual call to the Skia functions. 62 // 63 // This class then keeps track of all the current Skia state. WebKit expects 64 // that the graphics state that is pushed and popped by save() and restore() 65 // includes things like colors and pen styles. Skia does this differently, where 66 // push and pop only includes transforms and bitmaps, and the application is 67 // responsible for managing the painting state which is store in separate 68 // SkPaint objects. This class provides the adaptor that allows the painting 69 // state to be pushed and popped along with the bitmap. 70 class PlatformContextSkia { 71 WTF_MAKE_NONCOPYABLE(PlatformContextSkia); 72 public: 73 // For printing, there shouldn't be any canvas. canvas can be NULL. If you 74 // supply a NULL canvas, you can also call setCanvas later. 75 PlatformContextSkia(SkCanvas*); 76 ~PlatformContextSkia(); 77 78 // Sets the canvas associated with this context. Use when supplying NULL 79 // to the constructor. 80 void setCanvas(SkCanvas*); 81 82 // If false we're rendering to a GraphicsContext for a web page, if false 83 // we're not (as is the case when rendering to a canvas object). 84 // If this is true the contents have not been marked up with the magic 85 // color and all text drawing needs to go to a layer so that the alpha is 86 // correctly updated. 87 void setDrawingToImageBuffer(bool); 88 bool isDrawingToImageBuffer() const; 89 90 void save(); 91 void restore(); 92 93 // Begins a layer that is clipped to the image |imageBuffer| at the location 94 // |rect|. This layer is implicitly restored when the next restore is 95 // invoked. 96 // NOTE: |imageBuffer| may be deleted before the |restore| is invoked. 97 void beginLayerClippedToImage(const FloatRect&, const ImageBuffer*); 98 void clipPathAntiAliased(const SkPath&); 99 100 // Sets up the common flags on a paint for antialiasing, effects, etc. 101 // This is implicitly called by setupPaintFill and setupPaintStroke, but 102 // you may wish to call it directly sometimes if you don't want that other 103 // behavior. 104 void setupPaintCommon(SkPaint*) const; 105 106 // Sets up the paint for the current fill style. 107 void setupPaintForFilling(SkPaint*) const; 108 109 // Sets up the paint for stroking. Returns an int representing the width of 110 // the pen, or 1 if the pen's width is 0 if a non-zero length is provided, 111 // the number of dashes/dots on a dashed/dotted line will be adjusted to 112 // start and end that length with a dash/dot. 113 float setupPaintForStroking(SkPaint*, SkRect*, int length) const; 114 115 // State setting functions. 116 void setDrawLooper(SkDrawLooper*); // Note: takes an additional ref. 117 void setMiterLimit(float); 118 void setAlpha(float); 119 void setLineCap(SkPaint::Cap); 120 void setLineJoin(SkPaint::Join); 121 void setXfermodeMode(SkXfermode::Mode); 122 void setFillColor(SkColor); 123 void setFillShader(SkShader*); 124 void setStrokeStyle(StrokeStyle); 125 void setStrokeColor(SkColor); 126 void setStrokeThickness(float thickness); 127 void setStrokeShader(SkShader*); 128 void setTextDrawingMode(TextDrawingModeFlags mode); 129 void setUseAntialiasing(bool enable); 130 void setDashPathEffect(SkDashPathEffect*); 131 132 SkDrawLooper* getDrawLooper() const; 133 StrokeStyle getStrokeStyle() const; 134 float getStrokeThickness() const; 135 TextDrawingModeFlags getTextDrawingMode() const; 136 float getAlpha() const; 137 int getNormalizedAlpha() const; 138 139 void canvasClipPath(const SkPath&); 140 141 // Returns the fill color. The returned color has it's alpha adjusted 142 // by the current alpha. 143 SkColor effectiveFillColor() const; 144 145 // Returns the stroke color. The returned color has it's alpha adjusted 146 // by the current alpha. 147 SkColor effectiveStrokeColor() const; 148 149 // Returns the canvas used for painting, NOT guaranteed to be non-null. canvas()150 SkCanvas* canvas() { return m_canvas; } 151 152 InterpolationQuality interpolationQuality() const; 153 void setInterpolationQuality(InterpolationQuality interpolationQuality); 154 155 // FIXME: This should be pushed down to GraphicsContext. 156 void drawRect(SkRect rect); 157 158 // FIXME: I'm still unsure how I will serialize this call. 159 void paintSkPaint(const SkRect&, const SkPaint&); 160 161 const SkBitmap* bitmap() const; 162 163 // Returns if the context is a printing context instead of a display 164 // context. Bitmap shouldn't be resampled when printing to keep the best 165 // possible quality. printing()166 bool printing() const { return m_printing; } setPrinting(bool p)167 void setPrinting(bool p) { m_printing = p; } 168 169 // Returns if the context allows rendering of fonts using native platform 170 // APIs. If false is returned font rendering is performed using the skia 171 // text drawing APIs. 172 bool isNativeFontRenderingAllowed(); 173 174 void getImageResamplingHint(IntSize* srcSize, FloatSize* dstSize) const; 175 void setImageResamplingHint(const IntSize& srcSize, const FloatSize& dstSize); 176 void clearImageResamplingHint(); 177 bool hasImageResamplingHint() const; 178 179 bool canAccelerate() const; 180 bool canvasClipApplied() const; useGPU()181 bool useGPU() { return m_useGPU; } 182 void setSharedGraphicsContext3D(SharedGraphicsContext3D*, DrawingBuffer*, const IntSize&); 183 #if ENABLE(ACCELERATED_2D_CANVAS) gpuCanvas()184 GLES2Canvas* gpuCanvas() const { return m_gpuCanvas.get(); } 185 #else gpuCanvas()186 GLES2Canvas* gpuCanvas() const { return 0; } 187 #endif 188 // Call these before making a call that manipulates the underlying 189 // SkCanvas or WebCore::GLES2Canvas 190 void prepareForSoftwareDraw() const; 191 void prepareForHardwareDraw() const; 192 // Call to force the SkCanvas to contain all rendering results. 193 void syncSoftwareCanvas() const; 194 void markDirtyRect(const IntRect& rect); 195 196 private: 197 // Used when restoring and the state has an image clip. Only shows the pixels in 198 // m_canvas that are also in imageBuffer. 199 void applyClipFromImage(const FloatRect&, const SkBitmap&); 200 void applyAntiAliasedClipPaths(WTF::Vector<SkPath>& paths); 201 202 void uploadSoftwareToHardware(CompositeOperator) const; 203 void readbackHardwareToSoftware() const; 204 205 // Defines drawing style. 206 struct State; 207 208 // NULL indicates painting is disabled. Never delete this object. 209 SkCanvas* m_canvas; 210 211 // States stack. Enables local drawing state change with save()/restore() 212 // calls. 213 WTF::Vector<State> m_stateStack; 214 // Pointer to the current drawing state. This is a cached value of 215 // mStateStack.back(). 216 State* m_state; 217 218 // Stores image sizes for a hint to compute image resampling modes. 219 // Values are used in ImageSkia.cpp 220 IntSize m_imageResamplingHintSrcSize; 221 FloatSize m_imageResamplingHintDstSize; 222 bool m_printing; 223 bool m_drawingToImageBuffer; 224 bool m_useGPU; 225 #if ENABLE(ACCELERATED_2D_CANVAS) 226 OwnPtr<GLES2Canvas> m_gpuCanvas; 227 mutable RefPtr<Texture> m_uploadTexture; 228 #endif 229 mutable enum { None, Software, Mixed, Hardware } m_backingStoreState; 230 mutable IntRect m_softwareDirtyRect; 231 }; 232 233 } 234 #endif // PlatformContextSkia_h 235