tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "gm.h" |
| 9 | #include "SkCanvas.h" |
| 10 | #include "SkPath.h" |
Mike Reed | 5df4934 | 2016-11-12 08:06:55 -0600 | [diff] [blame] | 11 | #include "SkMakeUnique.h" |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 12 | |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 13 | static void do_draw(SkCanvas* canvas, const SkRect& r) { |
| 14 | SkPaint paint; |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 15 | paint.setBlendMode(SkBlendMode::kSrc); |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 16 | paint.setColor(0x800000FF); |
| 17 | canvas->drawRect(r, paint); |
| 18 | } |
| 19 | |
| 20 | /** |
| 21 | * Exercise kDontClipToLayer_Legacy_SaveLayerFlag flag, which does not limit the clip to the |
| 22 | * layer's bounds. Thus when a draw occurs, it can (depending on "where" it is) draw into the layer |
| 23 | * and/or draw onto the surrounding portions of the canvas, or both. |
| 24 | * |
| 25 | * This GM has a 100x100 rectangle (r), which its going to draw. However first it creates a layer |
| 26 | * with this flag covering 1/2 of the rectangle (upper half). Then it draws the rect in SRC mode. |
| 27 | * |
| 28 | * The portion of the draw that intersects the layer should see the SRC draw, apply it to the layer |
| 29 | * and then during restore, it will SRC_OVER that layer onto the canvas (SRC_OVER since the layer |
| 30 | * has no paint, so it gets the default xfermode during restore). |
| 31 | * |
reed | 28d1ce5 | 2016-09-06 14:57:00 -0700 | [diff] [blame] | 32 | * Note: when we talk about drawing directly into the "canvas", in fact we are drawing into an |
| 33 | * "outer" layer we created (filled with red). This is a testing detail, so that our final |
| 34 | * output image is itself opaque, otherwise we make it harder to view the GM as a PNG. |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 35 | * |
reed | 28d1ce5 | 2016-09-06 14:57:00 -0700 | [diff] [blame] | 36 | * The portion of the draw below the layer draws directly into the canvas. Since it is in SRC mode, |
| 37 | * it will write 0x80 to the canvas' alpha, overwriting the "red", which then gets blended with |
| 38 | * the GM's white background. |
| 39 | * |
| 40 | * The portion in the layer, will end up SRC_OVERing the 0x80 layer pixels onto the canvas' red |
| 41 | * pixels, making magenta. |
| 42 | * |
| 43 | * Thus the expected result is the upper half to be magenta 0xFF7F0080, and the lower half to be |
| 44 | * light blue 0xFF7F7FFF. |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 45 | */ |
| 46 | DEF_SIMPLE_GM(dont_clip_to_layer, canvas, 120, 120) { |
reed | 28d1ce5 | 2016-09-06 14:57:00 -0700 | [diff] [blame] | 47 | const SkRect r { 10, 10, 110, 110 }; |
| 48 | |
| 49 | // Wrap the entire test inside a red layer, so we don't punch the actual gm's alpha with |
| 50 | // kSrc_Mode, which makes it hard to view (we like our GMs to have opaque pixels). |
| 51 | canvas->saveLayer(&r, nullptr); |
| 52 | canvas->drawColor(SK_ColorRED); |
| 53 | |
Mike Reed | 8a8937c | 2017-02-14 10:12:34 -0500 | [diff] [blame] | 54 | SkRect r0 = { 20, 20, 100, 55 }; |
| 55 | SkRect r1 = { 20, 65, 100, 100 }; |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 56 | |
| 57 | SkCanvas::SaveLayerRec rec; |
| 58 | rec.fPaint = nullptr; |
| 59 | rec.fBounds = &r0; |
| 60 | rec.fBackdrop = nullptr; |
| 61 | rec.fSaveLayerFlags = 1 << 31;//SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag; |
| 62 | canvas->saveLayer(rec); |
Mike Reed | 8a8937c | 2017-02-14 10:12:34 -0500 | [diff] [blame] | 63 | rec.fBounds = &r1; |
| 64 | canvas->saveLayer(rec); |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 65 | do_draw(canvas, r); |
| 66 | canvas->restore(); |
reed | 28d1ce5 | 2016-09-06 14:57:00 -0700 | [diff] [blame] | 67 | |
| 68 | canvas->restore(); // red-layer |
reed | 02f9ed7 | 2016-09-06 09:06:18 -0700 | [diff] [blame] | 69 | } |
| 70 | |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 71 | /** Draw a 2px border around the target, then red behind the target; |
| 72 | set the clip to match the target, then draw >> the target in blue. |
| 73 | */ |
| 74 | |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 75 | static void draw(SkCanvas* canvas, SkRect& target, int x, int y) { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 76 | SkPaint borderPaint; |
| 77 | borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0)); |
| 78 | borderPaint.setAntiAlias(true); |
| 79 | SkPaint backgroundPaint; |
| 80 | backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0)); |
| 81 | backgroundPaint.setAntiAlias(true); |
| 82 | SkPaint foregroundPaint; |
| 83 | foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD)); |
| 84 | foregroundPaint.setAntiAlias(true); |
| 85 | |
| 86 | canvas->save(); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 87 | canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); |
| 88 | target.inset(SkIntToScalar(-2), SkIntToScalar(-2)); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 89 | canvas->drawRect(target, borderPaint); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 90 | target.inset(SkIntToScalar(2), SkIntToScalar(2)); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 91 | canvas->drawRect(target, backgroundPaint); |
reed | 6699838 | 2016-09-21 11:15:07 -0700 | [diff] [blame] | 92 | canvas->clipRect(target, true); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 93 | target.inset(SkIntToScalar(-4), SkIntToScalar(-4)); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 94 | canvas->drawRect(target, foregroundPaint); |
| 95 | canvas->restore(); |
| 96 | } |
| 97 | |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 98 | static void draw_square(SkCanvas* canvas, int x, int y) { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 99 | SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 10 * SK_Scalar1)); |
| 100 | draw(canvas, target, x, y); |
| 101 | } |
| 102 | |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 103 | static void draw_column(SkCanvas* canvas, int x, int y) { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 104 | SkRect target (SkRect::MakeWH(1 * SK_Scalar1, 10 * SK_Scalar1)); |
| 105 | draw(canvas, target, x, y); |
| 106 | } |
| 107 | |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 108 | static void draw_bar(SkCanvas* canvas, int x, int y) { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 109 | SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 1 * SK_Scalar1)); |
| 110 | draw(canvas, target, x, y); |
| 111 | } |
| 112 | |
commit-bot@chromium.org | c3bd8af | 2014-02-13 17:14:46 +0000 | [diff] [blame] | 113 | static void draw_rect_tests(SkCanvas* canvas) { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 114 | draw_square(canvas, 10, 10); |
| 115 | draw_column(canvas, 30, 10); |
| 116 | draw_bar(canvas, 10, 30); |
| 117 | } |
| 118 | |
| 119 | /** |
| 120 | Test a set of clipping problems discovered while writing blitAntiRect, |
| 121 | and test all the code paths through the clipping blitters. |
| 122 | Each region should show as a blue center surrounded by a 2px green |
| 123 | border, with no red. |
| 124 | */ |
| 125 | |
reed@google.com | ff26b7e | 2013-05-23 17:04:19 +0000 | [diff] [blame] | 126 | class AAClipGM : public skiagm::GM { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 127 | public: |
| 128 | AAClipGM() { |
reed@google.com | 7112173 | 2012-09-18 15:14:33 +0000 | [diff] [blame] | 129 | |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | protected: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 133 | SkString onShortName() override { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 134 | return SkString("aaclip"); |
| 135 | } |
| 136 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 137 | SkISize onISize() override { |
commit-bot@chromium.org | 5d0b150 | 2014-04-14 15:02:19 +0000 | [diff] [blame] | 138 | return SkISize::Make(240, 120); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 139 | } |
| 140 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 141 | void onDraw(SkCanvas* canvas) override { |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 142 | // Initial pixel-boundary-aligned draw |
| 143 | draw_rect_tests(canvas); |
| 144 | |
| 145 | // Repeat 4x with .2, .4, .6, .8 px offsets |
| 146 | canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 147 | canvas->translate(SkIntToScalar(50), 0); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 148 | draw_rect_tests(canvas); |
| 149 | |
| 150 | canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 151 | canvas->translate(SkIntToScalar(50), 0); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 152 | draw_rect_tests(canvas); |
| 153 | |
| 154 | canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 155 | canvas->translate(SkIntToScalar(50), 0); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 156 | draw_rect_tests(canvas); |
| 157 | |
| 158 | canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); |
tomhudson@google.com | abfa8d1 | 2011-12-28 19:40:48 +0000 | [diff] [blame] | 159 | canvas->translate(SkIntToScalar(50), 0); |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 160 | draw_rect_tests(canvas); |
| 161 | } |
| 162 | |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 163 | private: |
reed@google.com | ff26b7e | 2013-05-23 17:04:19 +0000 | [diff] [blame] | 164 | typedef skiagm::GM INHERITED; |
tomhudson@google.com | ef279d3 | 2011-12-21 14:27:14 +0000 | [diff] [blame] | 165 | }; |
| 166 | |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 167 | DEF_GM(return new AAClipGM;) |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 168 | |
| 169 | ///////////////////////////////////////////////////////////////////////// |
| 170 | |
| 171 | #ifdef SK_BUILD_FOR_MAC |
| 172 | |
Mike Reed | 5df4934 | 2016-11-12 08:06:55 -0600 | [diff] [blame] | 173 | static std::unique_ptr<SkCanvas> make_canvas(const SkBitmap& bm) { |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 174 | const SkImageInfo& info = bm.info(); |
| 175 | if (info.bytesPerPixel() == 4) { |
Mike Reed | 5df4934 | 2016-11-12 08:06:55 -0600 | [diff] [blame] | 176 | return SkCanvas::MakeRasterDirectN32(info.width(), info.height(), |
| 177 | (SkPMColor*)bm.getPixels(), |
| 178 | bm.rowBytes()); |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 179 | } else { |
Mike Reed | 5df4934 | 2016-11-12 08:06:55 -0600 | [diff] [blame] | 180 | return skstd::make_unique<SkCanvas>(bm); |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 181 | } |
| 182 | } |
| 183 | |
| 184 | #include "SkCGUtils.h" |
| 185 | static void test_image(SkCanvas* canvas, const SkImageInfo& info) { |
| 186 | SkBitmap bm; |
| 187 | bm.allocPixels(info); |
| 188 | |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 189 | if (info.isOpaque()) { |
| 190 | bm.eraseColor(SK_ColorGREEN); |
| 191 | } else { |
| 192 | bm.eraseColor(0); |
| 193 | } |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 194 | |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 195 | SkPaint paint; |
| 196 | paint.setAntiAlias(true); |
| 197 | paint.setColor(SK_ColorBLUE); |
Mike Reed | 5df4934 | 2016-11-12 08:06:55 -0600 | [diff] [blame] | 198 | make_canvas(bm)->drawCircle(50, 50, 49, paint); |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 199 | canvas->drawBitmap(bm, 10, 10); |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 200 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 201 | CGImageRef image = SkCreateCGImageRefWithColorspace(bm, nullptr); |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 202 | |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 203 | SkBitmap bm2; |
| 204 | SkCreateBitmapFromCGImage(&bm2, image); |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 205 | canvas->drawBitmap(bm2, 10, 120); |
Mike Reed | 463c848 | 2016-12-21 12:01:12 -0500 | [diff] [blame] | 206 | canvas->drawImage(SkMakeImageFromCGImage(image), 10, 120 + bm2.height() + 10); |
| 207 | |
| 208 | CGImageRelease(image); |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 209 | } |
| 210 | |
| 211 | class CGImageGM : public skiagm::GM { |
| 212 | public: |
| 213 | CGImageGM() {} |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 214 | |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 215 | protected: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 216 | SkString onShortName() override { |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 217 | return SkString("cgimage"); |
| 218 | } |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 219 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 220 | SkISize onISize() override { |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 221 | return SkISize::Make(800, 250); |
| 222 | } |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 223 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 224 | void onDraw(SkCanvas* canvas) override { |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 225 | const struct { |
| 226 | SkColorType fCT; |
| 227 | SkAlphaType fAT; |
| 228 | } rec[] = { |
| 229 | { kRGB_565_SkColorType, kOpaque_SkAlphaType }, |
| 230 | |
| 231 | { kRGBA_8888_SkColorType, kPremul_SkAlphaType }, |
| 232 | { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType }, |
| 233 | { kRGBA_8888_SkColorType, kOpaque_SkAlphaType }, |
| 234 | |
| 235 | { kBGRA_8888_SkColorType, kPremul_SkAlphaType }, |
| 236 | { kBGRA_8888_SkColorType, kUnpremul_SkAlphaType }, |
| 237 | { kBGRA_8888_SkColorType, kOpaque_SkAlphaType }, |
| 238 | }; |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 239 | |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 240 | for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) { |
| 241 | SkImageInfo info = SkImageInfo::Make(100, 100, rec[i].fCT, rec[i].fAT); |
| 242 | test_image(canvas, info); |
| 243 | canvas->translate(info.width() + 10, 0); |
| 244 | } |
| 245 | } |
skia.committer@gmail.com | ede0c5c | 2014-04-23 03:04:11 +0000 | [diff] [blame] | 246 | |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 247 | private: |
| 248 | typedef skiagm::GM INHERITED; |
| 249 | }; |
Mike Reed | 463c848 | 2016-12-21 12:01:12 -0500 | [diff] [blame] | 250 | //DEF_GM( return new CGImageGM; ) |
commit-bot@chromium.org | 60b5dce | 2014-04-22 20:24:33 +0000 | [diff] [blame] | 251 | #endif |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 252 | |
| 253 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 254 | |
halcanary | 6950de6 | 2015-11-07 05:29:00 -0800 | [diff] [blame] | 255 | // https://bug.skia.org/3716 |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 256 | class ClipCubicGM : public skiagm::GM { |
| 257 | const SkScalar W = 100; |
| 258 | const SkScalar H = 240; |
| 259 | |
| 260 | SkPath fVPath, fHPath; |
| 261 | public: |
| 262 | ClipCubicGM() { |
| 263 | fVPath.moveTo(W, 0); |
| 264 | fVPath.cubicTo(W, H-10, 0, 10, 0, H); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 265 | |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 266 | SkMatrix pivot; |
| 267 | pivot.setRotate(90, W/2, H/2); |
| 268 | fVPath.transform(pivot, &fHPath); |
| 269 | } |
| 270 | |
| 271 | protected: |
| 272 | SkString onShortName() override { |
| 273 | return SkString("clipcubic"); |
| 274 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 275 | |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 276 | SkISize onISize() override { |
| 277 | return SkISize::Make(400, 410); |
| 278 | } |
| 279 | |
| 280 | void doDraw(SkCanvas* canvas, const SkPath& path) { |
| 281 | SkPaint paint; |
| 282 | paint.setAntiAlias(true); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 283 | |
caryclark | 1259601 | 2015-07-29 05:27:47 -0700 | [diff] [blame] | 284 | paint.setColor(sk_tool_utils::color_to_565(0xFFCCCCCC)); |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 285 | canvas->drawPath(path, paint); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 286 | |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 287 | paint.setColor(SK_ColorRED); |
| 288 | paint.setStyle(SkPaint::kStroke_Style); |
| 289 | canvas->drawPath(path, paint); |
| 290 | } |
| 291 | |
| 292 | void drawAndClip(SkCanvas* canvas, const SkPath& path, SkScalar dx, SkScalar dy) { |
| 293 | SkAutoCanvasRestore acr(canvas, true); |
| 294 | |
| 295 | SkRect r = SkRect::MakeXYWH(0, H/4, W, H/2); |
| 296 | SkPaint paint; |
caryclark | 1259601 | 2015-07-29 05:27:47 -0700 | [diff] [blame] | 297 | paint.setColor(sk_tool_utils::color_to_565(0xFF8888FF)); |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 298 | |
| 299 | canvas->drawRect(r, paint); |
| 300 | this->doDraw(canvas, path); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 301 | |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 302 | canvas->translate(dx, dy); |
| 303 | |
| 304 | canvas->drawRect(r, paint); |
| 305 | canvas->clipRect(r); |
| 306 | this->doDraw(canvas, path); |
| 307 | } |
| 308 | |
| 309 | void onDraw(SkCanvas* canvas) override { |
| 310 | canvas->translate(80, 10); |
| 311 | this->drawAndClip(canvas, fVPath, 200, 0); |
| 312 | canvas->translate(0, 200); |
| 313 | this->drawAndClip(canvas, fHPath, 200, 0); |
| 314 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 315 | |
reed | 8f76cb9 | 2015-04-22 17:38:23 -0700 | [diff] [blame] | 316 | private: |
| 317 | typedef skiagm::GM INHERITED; |
| 318 | }; |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 319 | DEF_GM(return new ClipCubicGM;) |