1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 #include "hwui/Canvas.h" 19 #include "CanvasProperty.h" 20 #include "DeferredLayerUpdater.h" 21 #include "RenderNode.h" 22 #include "VectorDrawable.h" 23 24 #include <SkCanvas.h> 25 #include <SkTLazy.h> 26 27 namespace android { 28 29 // Holds an SkCanvas reference plus additional native data. 30 class SkiaCanvas : public Canvas { 31 public: 32 explicit SkiaCanvas(const SkBitmap& bitmap); 33 34 /** 35 * Create a new SkiaCanvas. 36 * 37 * @param canvas SkCanvas to handle calls made to this SkiaCanvas. Must 38 * not be NULL. This constructor does not take ownership, so the caller 39 * must guarantee that it remains valid while the SkiaCanvas is valid. 40 * @param xformToSRGB Indicates if bitmaps should be xformed to the sRGB 41 * color space before drawing. This makes sense for software rendering. 42 * For the picture case, it may make more sense to leave bitmaps as is, 43 * and handle the xform when replaying the picture. 44 */ 45 explicit SkiaCanvas(SkCanvas* canvas, XformToSRGB xformToSRGB); 46 47 virtual ~SkiaCanvas(); 48 asSkCanvas()49 virtual SkCanvas* asSkCanvas() override { 50 return mCanvas; 51 } 52 resetRecording(int width,int height,uirenderer::RenderNode * renderNode)53 virtual void resetRecording(int width, int height, 54 uirenderer::RenderNode* renderNode) override { 55 LOG_ALWAYS_FATAL("SkiaCanvas cannot be reset as a recording canvas"); 56 } 57 finishRecording()58 virtual uirenderer::DisplayList* finishRecording() override { 59 LOG_ALWAYS_FATAL("SkiaCanvas does not produce a DisplayList"); 60 return nullptr; 61 } insertReorderBarrier(bool enableReorder)62 virtual void insertReorderBarrier(bool enableReorder) override { 63 LOG_ALWAYS_FATAL("SkiaCanvas does not support reordering barriers"); 64 } 65 66 virtual void setBitmap(const SkBitmap& bitmap) override; 67 68 virtual bool isOpaque() override; 69 virtual int width() override; 70 virtual int height() override; 71 setHighContrastText(bool highContrastText)72 virtual void setHighContrastText(bool highContrastText) override { 73 mHighContrastText = highContrastText; 74 } isHighContrastText()75 virtual bool isHighContrastText() override { return mHighContrastText; } 76 77 virtual int getSaveCount() const override; 78 virtual int save(SaveFlags::Flags flags) override; 79 virtual void restore() override; 80 virtual void restoreToCount(int saveCount) override; 81 82 virtual int saveLayer(float left, float top, float right, float bottom, 83 const SkPaint* paint, SaveFlags::Flags flags) override; 84 virtual int saveLayerAlpha(float left, float top, float right, float bottom, 85 int alpha, SaveFlags::Flags flags) override; 86 87 virtual void getMatrix(SkMatrix* outMatrix) const override; 88 virtual void setMatrix(const SkMatrix& matrix) override; 89 virtual void concat(const SkMatrix& matrix) override; 90 virtual void rotate(float degrees) override; 91 virtual void scale(float sx, float sy) override; 92 virtual void skew(float sx, float sy) override; 93 virtual void translate(float dx, float dy) override; 94 95 virtual bool getClipBounds(SkRect* outRect) const override; 96 virtual bool quickRejectRect(float left, float top, float right, float bottom) const override; 97 virtual bool quickRejectPath(const SkPath& path) const override; 98 virtual bool clipRect(float left, float top, float right, float bottom, 99 SkClipOp op) override; 100 virtual bool clipPath(const SkPath* path, SkClipOp op) override; 101 102 virtual SkDrawFilter* getDrawFilter() override; 103 virtual void setDrawFilter(SkDrawFilter* drawFilter) override; 104 105 virtual SkCanvasState* captureCanvasState() const override; 106 107 virtual void drawColor(int color, SkBlendMode mode) override; 108 virtual void drawPaint(const SkPaint& paint) override; 109 110 virtual void drawPoint(float x, float y, const SkPaint& paint) override; 111 virtual void drawPoints(const float* points, int count, const SkPaint& paint) override; 112 virtual void drawLine(float startX, float startY, float stopX, float stopY, 113 const SkPaint& paint) override; 114 virtual void drawLines(const float* points, int count, const SkPaint& paint) override; 115 virtual void drawRect(float left, float top, float right, float bottom, 116 const SkPaint& paint) override; 117 virtual void drawRegion(const SkRegion& region, const SkPaint& paint) override; 118 virtual void drawRoundRect(float left, float top, float right, float bottom, 119 float rx, float ry, const SkPaint& paint) override; 120 virtual void drawCircle(float x, float y, float radius, const SkPaint& paint) override; 121 virtual void drawOval(float left, float top, float right, float bottom, 122 const SkPaint& paint) override; 123 virtual void drawArc(float left, float top, float right, float bottom, 124 float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) override; 125 virtual void drawPath(const SkPath& path, const SkPaint& paint) override; 126 virtual void drawVertices(const SkVertices*, SkBlendMode, const SkPaint& paint) override; 127 128 virtual void drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) override; 129 virtual void drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) override; 130 virtual void drawBitmap(Bitmap& bitmap, float srcLeft, float srcTop, 131 float srcRight, float srcBottom, float dstLeft, float dstTop, 132 float dstRight, float dstBottom, const SkPaint* paint) override; 133 virtual void drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight, 134 const float* vertices, const int* colors, const SkPaint* paint) override; 135 virtual void drawNinePatch(Bitmap& bitmap, const android::Res_png_9patch& chunk, 136 float dstLeft, float dstTop, float dstRight, float dstBottom, 137 const SkPaint* paint) override; 138 drawTextAbsolutePos()139 virtual bool drawTextAbsolutePos() const override { return true; } 140 virtual void drawVectorDrawable(VectorDrawableRoot* vectorDrawable) override; 141 142 virtual void drawRoundRect(uirenderer::CanvasPropertyPrimitive* left, 143 uirenderer::CanvasPropertyPrimitive* top, uirenderer::CanvasPropertyPrimitive* right, 144 uirenderer::CanvasPropertyPrimitive* bottom, uirenderer::CanvasPropertyPrimitive* rx, 145 uirenderer::CanvasPropertyPrimitive* ry, uirenderer::CanvasPropertyPaint* paint) override; 146 virtual void drawCircle(uirenderer::CanvasPropertyPrimitive* x, 147 uirenderer::CanvasPropertyPrimitive* y, uirenderer::CanvasPropertyPrimitive* radius, 148 uirenderer::CanvasPropertyPaint* paint) override; 149 150 virtual void drawLayer(uirenderer::DeferredLayerUpdater* layerHandle) override; 151 virtual void drawRenderNode(uirenderer::RenderNode* renderNode) override; 152 virtual void callDrawGLFunction(Functor* functor, 153 uirenderer::GlFunctorLifecycleListener* listener) override; 154 155 protected: 156 SkiaCanvas(); 157 void reset(SkCanvas* skiaCanvas); drawDrawable(SkDrawable * drawable)158 void drawDrawable(SkDrawable* drawable) { mCanvas->drawDrawable(drawable); } 159 160 virtual void drawGlyphs(ReadGlyphFunc glyphFunc, int count, const SkPaint& paint, float x, 161 float y, float boundsLeft, float boundsTop, float boundsRight, float boundsBottom, 162 float totalAdvance) override; 163 virtual void drawLayoutOnPath(const minikin::Layout& layout, float hOffset, float vOffset, 164 const SkPaint& paint, const SkPath& path, size_t start, size_t end) override; 165 166 private: 167 struct SaveRec { 168 int saveCount; 169 SaveFlags::Flags saveFlags; 170 size_t clipIndex; 171 }; 172 173 bool mHighContrastText = false; 174 175 const SaveRec* currentSaveRec() const; 176 void recordPartialSave(SaveFlags::Flags flags); 177 178 template<typename T> 179 void recordClip(const T&, SkClipOp); 180 void applyPersistentClips(size_t clipStartIndex); 181 182 void drawPoints(const float* points, int count, const SkPaint& paint, 183 SkCanvas::PointMode mode); 184 185 class Clip; 186 187 std::unique_ptr<SkCanvas> mCanvasWrapper; // might own a wrapper on the canvas 188 std::unique_ptr<SkCanvas> mCanvasOwned; // might own a canvas we allocated 189 SkCanvas* mCanvas; // we do NOT own this canvas, it must survive us 190 // unless it is the same as mCanvasOwned.get() 191 std::unique_ptr<SkDeque> mSaveStack; // lazily allocated, tracks partial saves. 192 std::vector<Clip> mClipStack; // tracks persistent clips. 193 }; 194 195 } // namespace android 196 197