pathfill.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620
  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. #include "gm/gm.h"
  8. #include "include/core/SkCanvas.h"
  9. #include "include/core/SkColor.h"
  10. #include "include/core/SkPaint.h"
  11. #include "include/core/SkPath.h"
  12. #include "include/core/SkRect.h"
  13. #include "include/core/SkScalar.h"
  14. #include "include/core/SkSize.h"
  15. #include "include/core/SkString.h"
  16. #include "include/core/SkTypes.h"
  17. typedef SkScalar (*MakePathProc)(SkPath*);
  18. static SkScalar make_frame(SkPath* path) {
  19. SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
  20. SkIntToScalar(630), SkIntToScalar(470) };
  21. path->addRoundRect(r, SkIntToScalar(15), SkIntToScalar(15));
  22. SkPaint paint;
  23. paint.setStyle(SkPaint::kStroke_Style);
  24. paint.setStrokeWidth(SkIntToScalar(5));
  25. paint.getFillPath(*path, path);
  26. return SkIntToScalar(15);
  27. }
  28. static SkScalar make_triangle(SkPath* path) {
  29. constexpr int gCoord[] = {
  30. 10, 20, 15, 5, 30, 30
  31. };
  32. path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1]));
  33. path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
  34. path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
  35. path->close();
  36. path->offset(SkIntToScalar(10), SkIntToScalar(0));
  37. return SkIntToScalar(30);
  38. }
  39. static SkScalar make_rect(SkPath* path) {
  40. SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
  41. SkIntToScalar(30), SkIntToScalar(30) };
  42. path->addRect(r);
  43. path->offset(SkIntToScalar(10), SkIntToScalar(0));
  44. return SkIntToScalar(30);
  45. }
  46. static SkScalar make_oval(SkPath* path) {
  47. SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
  48. SkIntToScalar(30), SkIntToScalar(30) };
  49. path->addOval(r);
  50. path->offset(SkIntToScalar(10), SkIntToScalar(0));
  51. return SkIntToScalar(30);
  52. }
  53. static SkScalar make_sawtooth(SkPath* path, int teeth) {
  54. SkScalar x = SkIntToScalar(20);
  55. SkScalar y = SkIntToScalar(20);
  56. const SkScalar x0 = x;
  57. const SkScalar dx = SkIntToScalar(5);
  58. const SkScalar dy = SkIntToScalar(10);
  59. path->moveTo(x, y);
  60. for (int i = 0; i < teeth; i++) {
  61. x += dx;
  62. path->lineTo(x, y - dy);
  63. x += dx;
  64. path->lineTo(x, y + dy);
  65. }
  66. path->lineTo(x, y + (2 * dy));
  67. path->lineTo(x0, y + (2 * dy));
  68. path->close();
  69. return SkIntToScalar(30);
  70. }
  71. static SkScalar make_sawtooth_3(SkPath* path) { return make_sawtooth(path, 3); }
  72. static SkScalar make_sawtooth_32(SkPath* path) { return make_sawtooth(path, 32); }
  73. static SkScalar make_house(SkPath* path) {
  74. path->moveTo(21, 23);
  75. path->lineTo(21, 11.534f);
  76. path->lineTo(22.327f, 12.741f);
  77. path->lineTo(23.673f, 11.261f);
  78. path->lineTo(12, 0.648f);
  79. path->lineTo(8, 4.285f);
  80. path->lineTo(8, 2);
  81. path->lineTo(4, 2);
  82. path->lineTo(4, 7.921f);
  83. path->lineTo(0.327f, 11.26f);
  84. path->lineTo(1.673f, 12.74f);
  85. path->lineTo(3, 11.534f);
  86. path->lineTo(3, 23);
  87. path->lineTo(11, 23);
  88. path->lineTo(11, 18);
  89. path->lineTo(13, 18);
  90. path->lineTo(13, 23);
  91. path->lineTo(21, 23);
  92. path->close();
  93. path->lineTo(9, 16);
  94. path->lineTo(9, 21);
  95. path->lineTo(5, 21);
  96. path->lineTo(5, 9.715f);
  97. path->lineTo(12, 3.351f);
  98. path->lineTo(19, 9.715f);
  99. path->lineTo(19, 21);
  100. path->lineTo(15, 21);
  101. path->lineTo(15, 16);
  102. path->lineTo(9, 16);
  103. path->close();
  104. path->offset(20, 0);
  105. return SkIntToScalar(30);
  106. }
  107. static SkScalar make_star(SkPath* path, int n) {
  108. const SkScalar c = SkIntToScalar(45);
  109. const SkScalar r = SkIntToScalar(20);
  110. SkScalar rad = -SK_ScalarPI / 2;
  111. const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
  112. path->moveTo(c, c - r);
  113. for (int i = 1; i < n; i++) {
  114. rad += drad;
  115. path->lineTo(c + SkScalarCos(rad) * r, c + SkScalarSin(rad) * r);
  116. }
  117. path->close();
  118. return r * 2 * 6 / 5;
  119. }
  120. static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); }
  121. static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); }
  122. // We don't expect any output from this path.
  123. static SkScalar make_line(SkPath* path) {
  124. path->moveTo(SkIntToScalar(30), SkIntToScalar(30));
  125. path->lineTo(SkIntToScalar(120), SkIntToScalar(40));
  126. path->close();
  127. path->moveTo(SkIntToScalar(150), SkIntToScalar(30));
  128. path->lineTo(SkIntToScalar(150), SkIntToScalar(30));
  129. path->lineTo(SkIntToScalar(300), SkIntToScalar(40));
  130. path->close();
  131. return SkIntToScalar(40);
  132. }
  133. static void make_info(SkPath* path) {
  134. path->moveTo(24, 4);
  135. path->cubicTo(12.94999980926514f,
  136. 4,
  137. 4,
  138. 12.94999980926514f,
  139. 4,
  140. 24);
  141. path->cubicTo(4,
  142. 35.04999923706055f,
  143. 12.94999980926514f,
  144. 44,
  145. 24,
  146. 44);
  147. path->cubicTo(35.04999923706055f,
  148. 44,
  149. 44,
  150. 35.04999923706055f,
  151. 44,
  152. 24);
  153. path->cubicTo(44,
  154. 12.95000076293945f,
  155. 35.04999923706055f,
  156. 4,
  157. 24,
  158. 4);
  159. path->close();
  160. path->moveTo(26, 34);
  161. path->lineTo(22, 34);
  162. path->lineTo(22, 22);
  163. path->lineTo(26, 22);
  164. path->lineTo(26, 34);
  165. path->close();
  166. path->moveTo(26, 18);
  167. path->lineTo(22, 18);
  168. path->lineTo(22, 14);
  169. path->lineTo(26, 14);
  170. path->lineTo(26, 18);
  171. path->close();
  172. }
  173. static void make_accessibility(SkPath* path) {
  174. path->moveTo(12, 2);
  175. path->cubicTo(13.10000038146973f,
  176. 2,
  177. 14,
  178. 2.900000095367432f,
  179. 14,
  180. 4);
  181. path->cubicTo(14,
  182. 5.099999904632568f,
  183. 13.10000038146973f,
  184. 6,
  185. 12,
  186. 6);
  187. path->cubicTo(10.89999961853027f,
  188. 6,
  189. 10,
  190. 5.099999904632568f,
  191. 10,
  192. 4);
  193. path->cubicTo(10,
  194. 2.900000095367432f,
  195. 10.89999961853027f,
  196. 2,
  197. 12,
  198. 2);
  199. path->close();
  200. path->moveTo(21, 9);
  201. path->lineTo(15, 9);
  202. path->lineTo(15, 22);
  203. path->lineTo(13, 22);
  204. path->lineTo(13, 16);
  205. path->lineTo(11, 16);
  206. path->lineTo(11, 22);
  207. path->lineTo(9, 22);
  208. path->lineTo(9, 9);
  209. path->lineTo(3, 9);
  210. path->lineTo(3, 7);
  211. path->lineTo(21, 7);
  212. path->lineTo(21, 9);
  213. path->close();
  214. }
  215. // test case for http://crbug.com/695196
  216. static void make_visualizer(SkPath* path) {
  217. path->moveTo(1.9520f, 2.0000f);
  218. path->conicTo(1.5573f, 1.9992f, 1.2782f, 2.2782f, 0.9235f);
  219. path->conicTo(0.9992f, 2.5573f, 1.0000f, 2.9520f, 0.9235f);
  220. path->lineTo(1.0000f, 5.4300f);
  221. path->lineTo(17.0000f, 5.4300f);
  222. path->lineTo(17.0000f, 2.9520f);
  223. path->conicTo(17.0008f, 2.5573f, 16.7218f, 2.2782f, 0.9235f);
  224. path->conicTo(16.4427f, 1.9992f, 16.0480f, 2.0000f, 0.9235f);
  225. path->lineTo(1.9520f, 2.0000f);
  226. path->close();
  227. path->moveTo(2.7140f, 3.1430f);
  228. path->conicTo(3.0547f, 3.1287f, 3.2292f, 3.4216f, 0.8590f);
  229. path->conicTo(3.4038f, 3.7145f, 3.2292f, 4.0074f, 0.8590f);
  230. path->conicTo(3.0547f, 4.3003f, 2.7140f, 4.2860f, 0.8590f);
  231. path->conicTo(2.1659f, 4.2631f, 2.1659f, 3.7145f, 0.7217f);
  232. path->conicTo(2.1659f, 3.1659f, 2.7140f, 3.1430f, 0.7217f);
  233. path->lineTo(2.7140f, 3.1430f);
  234. path->close();
  235. path->moveTo(5.0000f, 3.1430f);
  236. path->conicTo(5.3407f, 3.1287f, 5.5152f, 3.4216f, 0.8590f);
  237. path->conicTo(5.6898f, 3.7145f, 5.5152f, 4.0074f, 0.8590f);
  238. path->conicTo(5.3407f, 4.3003f, 5.0000f, 4.2860f, 0.8590f);
  239. path->conicTo(4.4519f, 4.2631f, 4.4519f, 3.7145f, 0.7217f);
  240. path->conicTo(4.4519f, 3.1659f, 5.0000f, 3.1430f, 0.7217f);
  241. path->lineTo(5.0000f, 3.1430f);
  242. path->close();
  243. path->moveTo(7.2860f, 3.1430f);
  244. path->conicTo(7.6267f, 3.1287f, 7.8012f, 3.4216f, 0.8590f);
  245. path->conicTo(7.9758f, 3.7145f, 7.8012f, 4.0074f, 0.8590f);
  246. path->conicTo(7.6267f, 4.3003f, 7.2860f, 4.2860f, 0.8590f);
  247. path->conicTo(6.7379f, 4.2631f, 6.7379f, 3.7145f, 0.7217f);
  248. path->conicTo(6.7379f, 3.1659f, 7.2860f, 3.1430f, 0.7217f);
  249. path->close();
  250. path->moveTo(1.0000f, 6.1900f);
  251. path->lineTo(1.0000f, 14.3810f);
  252. path->conicTo(0.9992f, 14.7757f, 1.2782f, 15.0548f, 0.9235f);
  253. path->conicTo(1.5573f, 15.3338f, 1.9520f, 15.3330f, 0.9235f);
  254. path->lineTo(16.0480f, 15.3330f);
  255. path->conicTo(16.4427f, 15.3338f, 16.7218f, 15.0548f, 0.9235f);
  256. path->conicTo(17.0008f, 14.7757f, 17.0000f, 14.3810f, 0.9235f);
  257. path->lineTo(17.0000f, 6.1910f);
  258. path->lineTo(1.0000f, 6.1910f);
  259. path->lineTo(1.0000f, 6.1900f);
  260. path->close();
  261. }
  262. constexpr MakePathProc gProcs[] = {
  263. make_frame,
  264. make_triangle,
  265. make_rect,
  266. make_oval,
  267. make_sawtooth_32,
  268. make_star_5,
  269. make_star_13,
  270. make_line,
  271. make_house,
  272. make_sawtooth_3,
  273. };
  274. #define N SK_ARRAY_COUNT(gProcs)
  275. class PathFillGM : public skiagm::GM {
  276. SkPath fPath[N];
  277. SkScalar fDY[N];
  278. SkPath fInfoPath;
  279. SkPath fAccessibilityPath;
  280. SkPath fVisualizerPath;
  281. protected:
  282. void onOnceBeforeDraw() override {
  283. for (size_t i = 0; i < N; i++) {
  284. fDY[i] = gProcs[i](&fPath[i]);
  285. }
  286. make_info(&fInfoPath);
  287. make_accessibility(&fAccessibilityPath);
  288. make_visualizer(&fVisualizerPath);
  289. }
  290. SkString onShortName() override {
  291. return SkString("pathfill");
  292. }
  293. SkISize onISize() override {
  294. return SkISize::Make(640, 480);
  295. }
  296. void onDraw(SkCanvas* canvas) override {
  297. SkPaint paint;
  298. paint.setAntiAlias(true);
  299. for (size_t i = 0; i < N; i++) {
  300. canvas->drawPath(fPath[i], paint);
  301. canvas->translate(SkIntToScalar(0), fDY[i]);
  302. }
  303. canvas->save();
  304. canvas->scale(0.300000011920929f, 0.300000011920929f);
  305. canvas->translate(50, 50);
  306. canvas->drawPath(fInfoPath, paint);
  307. canvas->restore();
  308. canvas->scale(2, 2);
  309. canvas->translate(5, 15);
  310. canvas->drawPath(fAccessibilityPath, paint);
  311. canvas->scale(0.5f, 0.5f);
  312. canvas->translate(5, 50);
  313. canvas->drawPath(fVisualizerPath, paint);
  314. }
  315. private:
  316. typedef skiagm::GM INHERITED;
  317. };
  318. // test inverse-fill w/ a clip that completely excludes the geometry
  319. class PathInverseFillGM : public skiagm::GM {
  320. SkPath fPath[N];
  321. SkScalar fDY[N];
  322. protected:
  323. void onOnceBeforeDraw() override {
  324. for (size_t i = 0; i < N; i++) {
  325. fDY[i] = gProcs[i](&fPath[i]);
  326. }
  327. }
  328. SkString onShortName() override {
  329. return SkString("pathinvfill");
  330. }
  331. SkISize onISize() override {
  332. return SkISize::Make(450, 220);
  333. }
  334. static void show(SkCanvas* canvas, const SkPath& path, const SkPaint& paint,
  335. const SkRect* clip, SkScalar top, const SkScalar bottom) {
  336. canvas->save();
  337. if (clip) {
  338. SkRect r = *clip;
  339. r.fTop = top;
  340. r.fBottom = bottom;
  341. canvas->clipRect(r);
  342. }
  343. canvas->drawPath(path, paint);
  344. canvas->restore();
  345. }
  346. void onDraw(SkCanvas* canvas) override {
  347. SkPath path;
  348. path.addCircle(SkIntToScalar(50), SkIntToScalar(50), SkIntToScalar(40));
  349. path.toggleInverseFillType();
  350. SkRect clipR = { 0, 0, SkIntToScalar(100), SkIntToScalar(200) };
  351. canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
  352. for (int doclip = 0; doclip <= 1; ++doclip) {
  353. for (int aa = 0; aa <= 1; ++aa) {
  354. SkPaint paint;
  355. paint.setAntiAlias(SkToBool(aa));
  356. canvas->save();
  357. canvas->clipRect(clipR);
  358. const SkRect* clipPtr = doclip ? &clipR : nullptr;
  359. show(canvas, path, paint, clipPtr, clipR.fTop, clipR.centerY());
  360. show(canvas, path, paint, clipPtr, clipR.centerY(), clipR.fBottom);
  361. canvas->restore();
  362. canvas->translate(SkIntToScalar(110), 0);
  363. }
  364. }
  365. }
  366. private:
  367. typedef skiagm::GM INHERITED;
  368. };
  369. DEF_SIMPLE_GM(rotatedcubicpath, canvas, 200, 200) {
  370. SkPaint p;
  371. p.setAntiAlias(true);
  372. p.setStyle(SkPaint::kFill_Style);
  373. canvas->translate(50, 50);
  374. SkPath path;
  375. path.moveTo(48,-23);
  376. path.cubicTo(48,-29.5, 6,-30, 6,-30);
  377. path.cubicTo(6,-30, 2,0, 2,0);
  378. path.cubicTo(2,0, 44,-21.5, 48,-23);
  379. path.close();
  380. p.setColor(SK_ColorBLUE);
  381. canvas->drawPath(path, p);
  382. // Rotated path, which is not antialiased on GPU
  383. p.setColor(SK_ColorRED);
  384. canvas->rotate(90);
  385. canvas->drawPath(path, p);
  386. }
  387. ///////////////////////////////////////////////////////////////////////////////
  388. DEF_GM( return new PathFillGM; )
  389. DEF_GM( return new PathInverseFillGM; )
  390. DEF_SIMPLE_GM(bug7792, canvas, 800, 800) {
  391. // from skbug.com/7792 bug description
  392. SkPaint p;
  393. SkPath path;
  394. path.moveTo(10, 10);
  395. path.moveTo(75, 75);
  396. path.lineTo(150, 75);
  397. path.lineTo(150, 150);
  398. path.lineTo(75, 150);
  399. canvas->drawPath(path, p);
  400. // from skbug.com/7792#c3
  401. canvas->translate(200, 0);
  402. path.reset();
  403. path.moveTo(75, 50);
  404. path.moveTo(100, 75);
  405. path.lineTo(150, 75);
  406. path.lineTo(150, 150);
  407. path.lineTo(75, 150);
  408. path.lineTo(75, 50);
  409. path.close();
  410. canvas->drawPath(path, p);
  411. // from skbug.com/7792#c9
  412. canvas->translate(200, 0);
  413. path.reset();
  414. path.moveTo(10, 10);
  415. path.moveTo(75, 75);
  416. path.lineTo(150, 75);
  417. path.lineTo(150, 150);
  418. path.lineTo(75, 150);
  419. path.close();
  420. canvas->drawPath(path, p);
  421. // from skbug.com/7792#c11
  422. canvas->translate(-200 * 2, 200);
  423. path.reset();
  424. path.moveTo(75, 150);
  425. path.lineTo(75, 75);
  426. path.lineTo(150, 75);
  427. path.lineTo(150, 150);
  428. path.lineTo(75, 150);
  429. path.moveTo(75, 150);
  430. canvas->drawPath(path, p);
  431. // from skbug.com/7792#c14
  432. canvas->translate(200, 0);
  433. path.reset();
  434. path.moveTo(250, 75);
  435. path.moveTo(250, 75);
  436. path.moveTo(250, 75);
  437. path.moveTo(100, 75);
  438. path.lineTo(150, 75);
  439. path.lineTo(150, 150);
  440. path.lineTo(75, 150);
  441. path.lineTo(75, 75);
  442. path.close();
  443. path.lineTo(0, 0);
  444. path.close();
  445. canvas->drawPath(path, p);
  446. // from skbug.com/7792#c15
  447. canvas->translate(200, 0);
  448. path.reset();
  449. path.moveTo(75, 75);
  450. path.lineTo(150, 75);
  451. path.lineTo(150, 150);
  452. path.lineTo(75, 150);
  453. path.moveTo(250, 75);
  454. canvas->drawPath(path, p);
  455. // from skbug.com/7792#c17
  456. canvas->translate(-200 * 2, 200);
  457. path.reset();
  458. path.moveTo(75, 10);
  459. path.moveTo(75, 75);
  460. path.lineTo(150, 75);
  461. path.lineTo(150, 150);
  462. path.lineTo(75, 150);
  463. path.lineTo(75, 10);
  464. path.close();
  465. canvas->drawPath(path, p);
  466. // from skbug.com/7792#c19
  467. canvas->translate(200, 0);
  468. path.reset();
  469. path.moveTo(75, 75);
  470. path.lineTo(75, 75);
  471. path.lineTo(75, 75);
  472. path.lineTo(75, 75);
  473. path.lineTo(150, 75);
  474. path.lineTo(150, 150);
  475. path.lineTo(75, 150);
  476. path.close();
  477. path.moveTo(10, 10);
  478. path.lineTo(30, 10);
  479. path.lineTo(10, 30);
  480. canvas->drawPath(path, p);
  481. // from skbug.com/7792#c23
  482. canvas->translate(200, 0);
  483. path.reset();
  484. path.moveTo(75, 75);
  485. path.lineTo(75, 75);
  486. path.moveTo(75, 75);
  487. path.lineTo(75, 75);
  488. path.lineTo(150, 75);
  489. path.lineTo(150, 150);
  490. path.lineTo(75, 150);
  491. path.close();
  492. canvas->drawPath(path, p);
  493. // from skbug.com/7792#c29
  494. canvas->translate(-200 * 2, 200);
  495. path.reset();
  496. path.moveTo(75, 75);
  497. path.lineTo(150, 75);
  498. path.lineTo(150, 150);
  499. path.lineTo(75, 150);
  500. path.lineTo(75, 250);
  501. path.moveTo(75, 75);
  502. path.close();
  503. canvas->drawPath(path, p);
  504. // from skbug.com/7792#c31
  505. canvas->translate(200, 0);
  506. path.reset();
  507. path.moveTo(75, 75);
  508. path.lineTo(150, 75);
  509. path.lineTo(150, 150);
  510. path.lineTo(75, 150);
  511. path.lineTo(75, 10);
  512. path.moveTo(75, 75);
  513. path.close();
  514. canvas->drawPath(path, p);
  515. // from skbug.com/7792#c36
  516. canvas->translate(200, 0);
  517. path.reset();
  518. path.moveTo(75, 75);
  519. path.lineTo(150, 75);
  520. path.lineTo(150, 150);
  521. path.lineTo(10, 150);
  522. path.moveTo(75, 75);
  523. path.lineTo(75, 75);
  524. canvas->drawPath(path, p);
  525. // from skbug.com/7792#c39
  526. canvas->translate(200, -200 * 3);
  527. path.reset();
  528. path.moveTo(150, 75);
  529. path.lineTo(150, 150);
  530. path.lineTo(75, 150);
  531. path.lineTo(75, 100);
  532. canvas->drawPath(path, p);
  533. // from zero_length_paths_aa
  534. canvas->translate(0, 200);
  535. path.reset();
  536. path.moveTo(150, 100);
  537. path.lineTo(150, 100);
  538. path.lineTo(150, 150);
  539. path.lineTo(75, 150);
  540. path.lineTo(75, 100);
  541. path.lineTo(75, 75);
  542. path.lineTo(150, 75);
  543. path.close();
  544. canvas->drawPath(path, p);
  545. // from skbug.com/7792#c41
  546. canvas->translate(0, 200);
  547. path.reset();
  548. path.moveTo(75, 75);
  549. path.lineTo(150, 75);
  550. path.lineTo(150, 150);
  551. path.lineTo(140, 150);
  552. path.lineTo(140, 75);
  553. path.moveTo(75, 75);
  554. path.close();
  555. canvas->drawPath(path, p);
  556. // from skbug.com/7792#c53
  557. canvas->translate(0, 200);
  558. path.reset();
  559. path.moveTo(75, 75);
  560. path.lineTo(150, 75);
  561. path.lineTo(150, 150);
  562. path.lineTo(140, 150);
  563. path.lineTo(140, 75);
  564. path.moveTo(75, 75);
  565. path.close();
  566. canvas->drawPath(path, p);
  567. }