samplecode/SampleQuadStroker.cpp

   1 /*
   2  * Copyright 2012 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 "sk_tool_utils.h"
   9 #include "SampleCode.h"
  10 #include "SkView.h"
  11 #include "SkCanvas.h"
  12 #include "SkPathMeasure.h"
  13 #include "SkRandom.h"
  14 #include "SkRRect.h"
  15 #include "SkColorPriv.h"
  16 #include "SkStrokerPriv.h"
  17 #include "SkSurface.h"
  18
  19 static bool hittest(const SkPoint& target, SkScalar x, SkScalar y) {
  20     const SkScalar TOL = 7;
  21     return SkPoint::Distance(target, SkPoint::Make(x, y)) <= TOL;
  22 }
  23
  24 static int getOnCurvePoints(const SkPath& path, SkPoint storage[]) {
  25     SkPath::RawIter iter(path);
  26     SkPoint pts[4];
  27     SkPath::Verb verb;
  28
  29     int count = 0;
  30     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
  31         switch (verb) {
  32             case SkPath::kMove_Verb:
  33             case SkPath::kLine_Verb:
  34             case SkPath::kQuad_Verb:
  35             case SkPath::kConic_Verb:
  36             case SkPath::kCubic_Verb:
  37                 storage[count++] = pts[0];
  38                 break;
  39             default:
  40                 break;
  41         }
  42     }
  43     return count;
  44 }
  45
  46 static void getContourCounts(const SkPath& path, SkTArray<int>* contourCounts) {
  47     SkPath::RawIter iter(path);
  48     SkPoint pts[4];
  49     SkPath::Verb verb;
  50
  51     int count = 0;
  52     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
  53         switch (verb) {
  54             case SkPath::kMove_Verb:
  55             case SkPath::kLine_Verb:
  56                 count += 1;
  57                 break;
  58             case SkPath::kQuad_Verb:
  59             case SkPath::kConic_Verb:
  60                 count += 2;
  61                 break;
  62             case SkPath::kCubic_Verb:
  63                 count += 3;
  64                 break;
  65             case SkPath::kClose_Verb:
  66                 contourCounts->push_back(count);
  67                 count = 0;
  68                 break;
  69             default:
  70                 break;
  71         }
  72     }
  73     if (count > 0) {
  74         contourCounts->push_back(count);
  75     }
  76 }
  77
  78 static void erase(SkSurface* surface) {
  79     surface->getCanvas()->clear(SK_ColorTRANSPARENT);
  80 }
  81
  82 struct StrokeTypeButton {
  83     SkRect fBounds;
  84     char fLabel;
  85     bool fEnabled;
  86 };
  87
  88 struct CircleTypeButton : public StrokeTypeButton {
  89     bool fFill;
  90 };
  91
  92 class QuadStrokerView : public SampleView {
  93     enum {
  94         SKELETON_COLOR = 0xFF0000FF,
  95         WIREFRAME_COLOR = 0x80FF0000
  96     };
  97
  98     enum {
  99         kCount = 15
 100     };
 101     SkPoint fPts[kCount];
 102     SkRect fWeightControl;
 103     SkRect fErrorControl;
 104     SkRect fWidthControl;
 105     SkRect fBounds;
 106     SkMatrix fMatrix, fInverse;
 107     SkAutoTUnref<SkShader> fShader;
 108     SkAutoTUnref<SkSurface> fMinSurface;
 109     SkAutoTUnref<SkSurface> fMaxSurface;
 110     StrokeTypeButton fCubicButton;
 111     StrokeTypeButton fConicButton;
 112     StrokeTypeButton fQuadButton;
 113     StrokeTypeButton fRRectButton;
 114     CircleTypeButton fCircleButton;
 115     StrokeTypeButton fTextButton;
 116     SkString fText;
 117     SkScalar fTextSize;
 118     SkScalar fWeight;
 119     SkScalar fWidth, fDWidth;
 120     SkScalar fWidthScale;
 121     int fW, fH, fZoom;
 122     bool fAnimate;
 123     bool fDrawRibs;
 124     bool fDrawTangents;
 125 #if !defined SK_LEGACY_STROKE_CURVES && defined(SK_DEBUG)
 126     #define kStrokerErrorMin 0.001f
 127     #define kStrokerErrorMax 5
 128 #endif
 129     #define kWidthMin 1
 130     #define kWidthMax 100
 131 public:
 132     QuadStrokerView() {
 133         this->setBGColor(SK_ColorLTGRAY);
 134
 135         fPts[0].set(50, 200);  // cubic
 136         fPts[1].set(50, 100);
 137         fPts[2].set(150, 50);
 138         fPts[3].set(300, 50);
 139
 140         fPts[4].set(350, 200);  // conic
 141         fPts[5].set(350, 100);
 142         fPts[6].set(450, 50);
 143
 144         fPts[7].set(150, 300);  // quad
 145         fPts[8].set(150, 200);
 146         fPts[9].set(250, 150);
 147
 148         fPts[10].set(200, 200); // rrect
 149         fPts[11].set(400, 400);
 150
 151         fPts[12].set(250, 250);  // oval
 152         fPts[13].set(450, 450);
 153
 154         fText = "a";
 155         fTextSize = 12;
 156         fWidth = 50;
 157         fDWidth = 0.25f;
 158         fWeight = 1;
 159
 160         fCubicButton.fLabel = 'C';
 161         fCubicButton.fEnabled = false;
 162         fConicButton.fLabel = 'K';
 163         fConicButton.fEnabled = true;
 164         fQuadButton.fLabel = 'Q';
 165         fQuadButton.fEnabled = false;
 166         fRRectButton.fLabel = 'R';
 167         fRRectButton.fEnabled = false;
 168         fCircleButton.fLabel = 'O';
 169         fCircleButton.fEnabled = false;
 170         fCircleButton.fFill = false;
 171         fTextButton.fLabel = 'T';
 172         fTextButton.fEnabled = false;
 173         fAnimate = true;
 174         setAsNeeded();
 175     }
 176
 177 protected:
 178     bool onQuery(SkEvent* evt) override {
 179         if (SampleCode::TitleQ(*evt)) {
 180             SampleCode::TitleR(evt, "QuadStroker");
 181             return true;
 182         }
 183         SkUnichar uni;
 184         if (fTextButton.fEnabled && SampleCode::CharQ(*evt, &uni)) {
 185             switch (uni) {
 186                 case ' ':
 187                     fText = "";
 188                     break;
 189                 case '-':
 190                     fTextSize = SkTMax(1.0f, fTextSize - 1);
 191                     break;
 192                 case '+':
 193                 case '=':
 194                     fTextSize += 1;
 195                     break;
 196                 default:
 197                     fText.appendUnichar(uni);
 198             }
 199             this->inval(NULL);
 200             return true;
 201         }
 202         return this->INHERITED::onQuery(evt);
 203     }
 204
 205     void onSizeChange() override {
 206         fWeightControl.setXYWH(this->width() - 150, 30, 30, 400);
 207         fErrorControl.setXYWH(this->width() - 100, 30, 30, 400);
 208         fWidthControl.setXYWH(this->width() -  50, 30, 30, 400);
 209         int buttonOffset = 450;
 210         fCubicButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
 211         buttonOffset += 50;
 212         fConicButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
 213         buttonOffset += 50;
 214         fQuadButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
 215         buttonOffset += 50;
 216         fRRectButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
 217         buttonOffset += 50;
 218         fCircleButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
 219         buttonOffset += 50;
 220         fTextButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
 221         this->INHERITED::onSizeChange();
 222     }
 223
 224      void copyMinToMax() {
 225         erase(fMaxSurface);
 226         SkCanvas* canvas = fMaxSurface->getCanvas();
 227         canvas->save();
 228         canvas->concat(fMatrix);
 229         fMinSurface->draw(canvas, 0, 0, NULL);
 230         canvas->restore();
 231
 232         SkPaint paint;
 233         paint.setXfermodeMode(SkXfermode::kClear_Mode);
 234         for (int iy = 1; iy < fH; ++iy) {
 235             SkScalar y = SkIntToScalar(iy * fZoom);
 236             canvas->drawLine(0, y - SK_ScalarHalf, 999, y - SK_ScalarHalf, paint);
 237         }
 238         for (int ix = 1; ix < fW; ++ix) {
 239             SkScalar x = SkIntToScalar(ix * fZoom);
 240             canvas->drawLine(x - SK_ScalarHalf, 0, x - SK_ScalarHalf, 999, paint);
 241         }
 242     }
 243
 244    void setWHZ(int width, int height, int zoom) {
 245         fZoom = zoom;
 246         fBounds.set(0, 0, SkIntToScalar(width * zoom), SkIntToScalar(height * zoom));
 247         fMatrix.setScale(SkIntToScalar(zoom), SkIntToScalar(zoom));
 248         fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom);
 249         fShader.reset(sk_tool_utils::create_checkerboard_shader(
 250                               0xFFCCCCCC, 0xFFFFFFFF, zoom));
 251
 252         SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
 253         fMinSurface.reset(SkSurface::NewRaster(info));
 254         info = info.makeWH(width * zoom, height * zoom);
 255         fMaxSurface.reset(SkSurface::NewRaster(info));
 256     }
 257
 258     void draw_points(SkCanvas* canvas, const SkPath& path, SkColor color,
 259                      bool show_lines) {
 260         SkPaint paint;
 261         paint.setColor(color);
 262         paint.setAlpha(0x80);
 263         paint.setAntiAlias(true);
 264         int n = path.countPoints();
 265         SkAutoSTArray<32, SkPoint> pts(n);
 266         if (show_lines && fDrawTangents) {
 267             SkTArray<int> contourCounts;
 268             getContourCounts(path, &contourCounts);
 269             SkPoint* ptPtr = pts.get();
 270             for (int i = 0; i < contourCounts.count(); ++i) {
 271                 int count = contourCounts[i];
 272                 path.getPoints(ptPtr, count);
 273                 canvas->drawPoints(SkCanvas::kPolygon_PointMode, count, ptPtr, paint);
 274                 ptPtr += count;
 275             }
 276         } else {
 277             n = getOnCurvePoints(path, pts.get());
 278         }
 279         paint.setStrokeWidth(5);
 280         canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts.get(), paint);
 281     }
 282
 283     void draw_ribs(SkCanvas* canvas, const SkPath& path, SkScalar width,
 284                    SkColor color) {
 285         const SkScalar radius = width / 2;
 286
 287         SkPathMeasure meas(path, false);
 288         SkScalar total = meas.getLength();
 289
 290         SkScalar delta = 8;
 291         SkPaint paint;
 292         paint.setColor(color);
 293
 294         SkPoint pos, tan;
 295         for (SkScalar dist = 0; dist <= total; dist += delta) {
 296             if (meas.getPosTan(dist, &pos, &tan)) {
 297                 tan.scale(radius);
 298                 tan.rotateCCW();
 299                 canvas->drawLine(pos.x() + tan.x(), pos.y() + tan.y(),
 300                                  pos.x() - tan.x(), pos.y() - tan.y(), paint);
 301             }
 302         }
 303     }
 304
 305     void draw_stroke(SkCanvas* canvas, const SkPath& path, SkScalar width, SkScalar scale,
 306             bool drawText) {
 307         SkRect bounds = path.getBounds();
 308         if (bounds.isEmpty()) {
 309             return;
 310         }
 311         this->setWHZ(SkScalarCeilToInt(bounds.right()), drawText
 312                 ? SkScalarRoundToInt(scale * 3 / 2) : SkScalarRoundToInt(scale),
 313                 SkScalarRoundToInt(950.0f / scale));
 314         erase(fMinSurface);
 315         SkPaint paint;
 316         paint.setColor(0x1f1f0f0f);
 317         paint.setStyle(SkPaint::kStroke_Style);
 318         paint.setStrokeWidth(width * scale * scale);
 319         paint.setColor(0x3f0f1f3f);
 320         if (drawText) {
 321             fMinSurface->getCanvas()->drawPath(path, paint);
 322             this->copyMinToMax();
 323             fMaxSurface->draw(canvas, 0, 0, NULL);
 324         }
 325         paint.setAntiAlias(true);
 326         paint.setStyle(SkPaint::kStroke_Style);
 327         paint.setStrokeWidth(1);
 328
 329         paint.setColor(SKELETON_COLOR);
 330         SkPath scaled;
 331         SkMatrix matrix;
 332         matrix.reset();
 333         matrix.setScale(950 / scale, 950 / scale);
 334         if (drawText) {
 335             path.transform(matrix, &scaled);
 336         } else {
 337             scaled = path;
 338         }
 339         canvas->drawPath(scaled, paint);
 340         draw_points(canvas, scaled, SKELETON_COLOR, true);
 341
 342         if (fDrawRibs) {
 343             draw_ribs(canvas, scaled, width, 0xFF00FF00);
 344         }
 345
 346         SkPath fill;
 347
 348         SkPaint p;
 349         p.setStyle(SkPaint::kStroke_Style);
 350         if (drawText) {
 351             p.setStrokeWidth(width * scale * scale);
 352         } else {
 353             p.setStrokeWidth(width);
 354         }
 355         p.getFillPath(path, &fill);
 356         SkPath scaledFill;
 357         if (drawText) {
 358             fill.transform(matrix, &scaledFill);
 359         } else {
 360             scaledFill = fill;
 361         }
 362         paint.setColor(WIREFRAME_COLOR);
 363         canvas->drawPath(scaledFill, paint);
 364         draw_points(canvas, scaledFill, WIREFRAME_COLOR, false);
 365     }
 366
 367     void draw_fill(SkCanvas* canvas, const SkRect& rect, SkScalar width) {
 368         if (rect.isEmpty()) {
 369             return;
 370         }
 371         SkPaint paint;
 372         paint.setColor(0x1f1f0f0f);
 373         paint.setStyle(SkPaint::kStroke_Style);
 374         paint.setStrokeWidth(width);
 375         SkPath path;
 376         SkScalar maxSide = SkTMax(rect.width(), rect.height()) / 2;
 377         SkPoint center = { rect.fLeft + maxSide, rect.fTop + maxSide };
 378         path.addCircle(center.fX, center.fY, maxSide);
 379         canvas->drawPath(path, paint);
 380         paint.setStyle(SkPaint::kFill_Style);
 381         path.reset();
 382         path.addCircle(center.fX, center.fY, maxSide - width / 2);
 383         paint.setColor(0x3f0f1f3f);
 384         canvas->drawPath(path, paint);
 385         path.reset();
 386         path.setFillType(SkPath::kEvenOdd_FillType);
 387         path.addCircle(center.fX, center.fY, maxSide + width / 2);
 388         SkRect outside = SkRect::MakeXYWH(center.fX - maxSide - width, center.fY - maxSide - width,
 389                 (maxSide + width) * 2, (maxSide + width) * 2);
 390         path.addRect(outside);
 391         canvas->drawPath(path, paint);
 392     }
 393
 394     void draw_button(SkCanvas* canvas, const StrokeTypeButton& button) {
 395         SkPaint paint;
 396         paint.setAntiAlias(true);
 397         paint.setStyle(SkPaint::kStroke_Style);
 398         paint.setColor(button.fEnabled ? 0xFF3F0000 : 0x6F3F0000);
 399         canvas->drawRect(button.fBounds, paint);
 400         paint.setTextSize(25.0f);
 401         paint.setColor(button.fEnabled ? 0xFF3F0000 : 0x6F3F0000);
 402         paint.setTextAlign(SkPaint::kCenter_Align);
 403         paint.setStyle(SkPaint::kFill_Style);
 404         canvas->drawText(&button.fLabel, 1, button.fBounds.centerX(), button.fBounds.fBottom - 5,
 405                 paint);
 406     }
 407
 408     void draw_control(SkCanvas* canvas, const SkRect& bounds, SkScalar value,
 409             SkScalar min, SkScalar max, const char* name) {
 410         SkPaint paint;
 411         paint.setAntiAlias(true);
 412         paint.setStyle(SkPaint::kStroke_Style);
 413         canvas->drawRect(bounds, paint);
 414         SkScalar scale = max - min;
 415         SkScalar yPos = bounds.fTop + (value - min) * bounds.height() / scale;
 416         paint.setColor(0xFFFF0000);
 417         canvas->drawLine(bounds.fLeft - 5, yPos, bounds.fRight + 5, yPos, paint);
 418         SkString label;
 419         label.printf("%0.3g", value);
 420         paint.setColor(0xFF000000);
 421         paint.setTextSize(11.0f);
 422         paint.setStyle(SkPaint::kFill_Style);
 423         canvas->drawText(label.c_str(), label.size(), bounds.fLeft + 5, yPos - 5, paint);
 424         paint.setTextSize(13.0f);
 425         canvas->drawText(name, strlen(name), bounds.fLeft, bounds.bottom() + 11, paint);
 426     }
 427
 428     void setForGeometry() {
 429         fDrawRibs = true;
 430         fDrawTangents = true;
 431         fWidthScale = 1;
 432     }
 433
 434     void setForText() {
 435         fDrawRibs = fDrawTangents = false;
 436         fWidthScale = 0.002f;
 437     }
 438
 439     void setAsNeeded() {
 440         if (fConicButton.fEnabled || fCubicButton.fEnabled || fQuadButton.fEnabled
 441                 || fRRectButton.fEnabled || fCircleButton.fEnabled) {
 442             setForGeometry();
 443         } else {
 444             setForText();
 445         }
 446     }
 447
 448     void onDrawContent(SkCanvas* canvas) override {
 449         SkPath path;
 450         SkScalar width = fWidth;
 451
 452         if (fCubicButton.fEnabled) {
 453             path.moveTo(fPts[0]);
 454             path.cubicTo(fPts[1], fPts[2], fPts[3]);
 455             setForGeometry();
 456             draw_stroke(canvas, path, width, 950, false);
 457         }
 458
 459         if (fConicButton.fEnabled) {
 460             path.moveTo(fPts[4]);
 461             path.conicTo(fPts[5], fPts[6], fWeight);
 462             setForGeometry();
 463             draw_stroke(canvas, path, width, 950, false);
 464         }
 465
 466         if (fQuadButton.fEnabled) {
 467             path.reset();
 468             path.moveTo(fPts[7]);
 469             path.quadTo(fPts[8], fPts[9]);
 470             setForGeometry();
 471             draw_stroke(canvas, path, width, 950, false);
 472         }
 473
 474         if (fRRectButton.fEnabled) {
 475             SkScalar rad = 32;
 476             SkRect r;
 477             r.set(&fPts[10], 2);
 478             path.reset();
 479             SkRRect rr;
 480             rr.setRectXY(r, rad, rad);
 481             path.addRRect(rr);
 482             setForGeometry();
 483             draw_stroke(canvas, path, width, 950, false);
 484
 485             path.reset();
 486             SkRRect rr2;
 487             rr.inset(width/2, width/2, &rr2);
 488             path.addRRect(rr2, SkPath::kCCW_Direction);
 489             rr.inset(-width/2, -width/2, &rr2);
 490             path.addRRect(rr2, SkPath::kCW_Direction);
 491             SkPaint paint;
 492             paint.setAntiAlias(true);
 493             paint.setColor(0x40FF8844);
 494             canvas->drawPath(path, paint);
 495         }
 496
 497         if (fCircleButton.fEnabled) {
 498             path.reset();
 499             SkRect r;
 500             r.set(&fPts[12], 2);
 501             path.addOval(r);
 502             setForGeometry();
 503             if (fCircleButton.fFill) {
 504                 draw_fill(canvas, r, width);
 505             } else {
 506                 draw_stroke(canvas, path, width, 950, false);
 507             }
 508         }
 509
 510         if (fTextButton.fEnabled) {
 511             path.reset();
 512             SkPaint paint;
 513             paint.setAntiAlias(true);
 514             paint.setTextSize(fTextSize);
 515             paint.getTextPath(fText.c_str(), fText.size(), 0, fTextSize, &path);
 516             setForText();
 517             draw_stroke(canvas, path, width * fWidthScale / fTextSize, fTextSize, true);
 518         }
 519
 520         if (fAnimate) {
 521             fWidth += fDWidth;
 522             if (fDWidth > 0 && fWidth > kWidthMax) {
 523                 fDWidth = -fDWidth;
 524             } else if (fDWidth < 0 && fWidth < kWidthMin) {
 525                 fDWidth = -fDWidth;
 526             }
 527         }
 528         setAsNeeded();
 529         if (fConicButton.fEnabled) {
 530             draw_control(canvas, fWeightControl, fWeight, 0, 5, "weight");
 531         }
 532 #if !defined SK_LEGACY_STROKE_CURVES && defined(SK_DEBUG)
 533         draw_control(canvas, fErrorControl, gDebugStrokerError, kStrokerErrorMin, kStrokerErrorMax,
 534                 "error");
 535 #endif
 536         draw_control(canvas, fWidthControl, fWidth * fWidthScale, kWidthMin * fWidthScale,
 537                 kWidthMax * fWidthScale, "width");
 538         draw_button(canvas, fQuadButton);
 539         draw_button(canvas, fCubicButton);
 540         draw_button(canvas, fConicButton);
 541         draw_button(canvas, fRRectButton);
 542         draw_button(canvas, fCircleButton);
 543         draw_button(canvas, fTextButton);
 544         this->inval(NULL);
 545     }
 546
 547     class MyClick : public Click {
 548     public:
 549         int fIndex;
 550         MyClick(SkView* target, int index) : Click(target), fIndex(index) {}
 551     };
 552
 553     virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
 554                                               unsigned modi) override {
 555         for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
 556             if (hittest(fPts[i], x, y)) {
 557                 return new MyClick(this, (int)i);
 558             }
 559         }
 560         const SkRect& rectPt = SkRect::MakeXYWH(x, y, 1, 1);
 561         if (fWeightControl.contains(rectPt)) {
 562             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 1);
 563         }
 564 #if !defined SK_LEGACY_STROKE_CURVES && defined(SK_DEBUG)
 565         if (fErrorControl.contains(rectPt)) {
 566             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 2);
 567         }
 568 #endif
 569         if (fWidthControl.contains(rectPt)) {
 570             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 3);
 571         }
 572         if (fCubicButton.fBounds.contains(rectPt)) {
 573             fCubicButton.fEnabled ^= true;
 574             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 4);
 575         }
 576         if (fConicButton.fBounds.contains(rectPt)) {
 577             fConicButton.fEnabled ^= true;
 578             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 5);
 579         }
 580         if (fQuadButton.fBounds.contains(rectPt)) {
 581             fQuadButton.fEnabled ^= true;
 582             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 6);
 583         }
 584         if (fRRectButton.fBounds.contains(rectPt)) {
 585             fRRectButton.fEnabled ^= true;
 586             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 7);
 587         }
 588         if (fCircleButton.fBounds.contains(rectPt)) {
 589             bool wasEnabled = fCircleButton.fEnabled;
 590             fCircleButton.fEnabled = !fCircleButton.fFill;
 591             fCircleButton.fFill = wasEnabled && !fCircleButton.fFill;
 592             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 8);
 593         }
 594         if (fTextButton.fBounds.contains(rectPt)) {
 595             fTextButton.fEnabled ^= true;
 596             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 9);
 597         }
 598         return this->INHERITED::onFindClickHandler(x, y, modi);
 599     }
 600
 601     static SkScalar MapScreenYtoValue(int y, const SkRect& control, SkScalar min,
 602             SkScalar max) {
 603         return (SkIntToScalar(y) - control.fTop) / control.height() * (max - min) + min;
 604     }
 605
 606     bool onClick(Click* click) override {
 607         int index = ((MyClick*)click)->fIndex;
 608         if (index < (int) SK_ARRAY_COUNT(fPts)) {
 609             fPts[index].offset(SkIntToScalar(click->fICurr.fX - click->fIPrev.fX),
 610                                SkIntToScalar(click->fICurr.fY - click->fIPrev.fY));
 611             this->inval(NULL);
 612         } else if (index == (int) SK_ARRAY_COUNT(fPts) + 1) {
 613             fWeight = MapScreenYtoValue(click->fICurr.fY, fWeightControl, 0, 5);
 614         }
 615 #if !defined SK_LEGACY_STROKE_CURVES && defined(SK_DEBUG)
 616         else if (index == (int) SK_ARRAY_COUNT(fPts) + 2) {
 617             gDebugStrokerError = SkTMax(FLT_EPSILON, MapScreenYtoValue(click->fICurr.fY,
 618                     fErrorControl, kStrokerErrorMin, kStrokerErrorMax));
 619             gDebugStrokerErrorSet = true;
 620         }
 621 #endif
 622         else if (index == (int) SK_ARRAY_COUNT(fPts) + 3) {
 623             fWidth = SkTMax(FLT_EPSILON, MapScreenYtoValue(click->fICurr.fY, fWidthControl,
 624                     kWidthMin, kWidthMax));
 625             fAnimate = fWidth <= kWidthMin;
 626         }
 627         return true;
 628     }
 629
 630 private:
 631     typedef SkView INHERITED;
 632 };
 633
 634 ///////////////////////////////////////////////////////////////////////////////
 635
 636 static SkView* F2() { return new QuadStrokerView; }
 637 static SkViewRegister gR2(F2);