add 'g' to fatbits

samplecode/SampleFatBits.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "sk_tool_utils.h"
 #include "SampleCode.h"
 #include "SkView.h"
@@ skipping 25 matching lines @@
     surface->getCanvas()->clear(SK_ColorTRANSPARENT);
 }
 
 class FatBits {
 public:
     FatBits() {
         fAA = false;
         fStyle = kHair_Style;
         fGrid = false;
         fShowSkeleton = true;
-        fUseGPU = false;
         fUseClip = false;
         fRectAsOval = false;
         fUseTriangle = false;
         fStrokeCap = SkPaint::kButt_Cap;
 
         fClipRect.set(2, 2, 11, 8 );
     }
 
     int getZoom() const { return fZoom; }
 
     bool getAA() const { return fAA; }
     void setAA(bool aa) { fAA = aa; }
 
     bool getGrid() const { return fGrid; }
     void setGrid(bool g) { fGrid = g; }
 
     bool getShowSkeleton() const { return fShowSkeleton; }
     void setShowSkeleton(bool ss) { fShowSkeleton = ss; }
 
-    bool getUseGPU() const { return fUseGPU; }
-    void setUseGPU(bool ug) { fUseGPU = ug; }
-
     bool getTriangle() const { return fUseTriangle; }
     void setTriangle(bool ut) { fUseTriangle = ut; }
 
     void toggleRectAsOval() { fRectAsOval = !fRectAsOval; }
 
+    void togglePixelColors() {
+        if (fShader == fShader0) {
+            fShader = fShader1;
+        } else {
+            fShader = fShader0;
+        }
+    }
+
     bool getUseClip() const { return fUseClip; }
     void setUseClip(bool uc) { fUseClip = uc; }
 
     enum Style {
         kHair_Style,
         kStroke_Style,
     };
     Style getStyle() const { return fStyle; }
     void setStyle(Style s) { fStyle = s; }
 
     void setWHZ(int width, int height, int zoom) {
         fW = width;
         fH = height;
         fZoom = zoom;
         fBounds.set(0, 0, SkIntToScalar(width * zoom), SkIntToScalar(height * zoom));
         fMatrix.setScale(SkIntToScalar(zoom), SkIntToScalar(zoom));
         fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom);
-        fShader = sk_tool_utils::create_checkerboard_shader(0xFFCCCCCC, 0xFFFFFFFF, zoom);
+        fShader0 = sk_tool_utils::create_checkerboard_shader(0xFFDDDDDD, 0xFFFFFFFF, zoom);
+        fShader1 = SkShader::MakeColorShader(SK_ColorWHITE);
+        fShader = fShader0;
 
         SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
         fMinSurface = SkSurface::MakeRaster(info);
         info = info.makeWH(width * zoom, height * zoom);
         fMaxSurface = SkSurface::MakeRaster(info);
     }
 
     void drawBG(SkCanvas*);
     void drawFG(SkCanvas*);
     void drawLine(SkCanvas*, SkPoint pts[2]);
     void drawRect(SkCanvas* canvas, SkPoint pts[2]);
     void drawTriangle(SkCanvas* canvas, SkPoint pts[3]);
 
     SkPaint::Cap fStrokeCap;
 
 private:
-    bool fAA, fGrid, fShowSkeleton, fUseGPU, fUseClip, fRectAsOval, fUseTriangle;
+    bool fAA, fGrid, fShowSkeleton, fUseClip, fRectAsOval, fUseTriangle;
     Style fStyle;
     int fW, fH, fZoom;
-    SkMatrix fMatrix, fInverse;
-    SkRect   fBounds, fClipRect;
-    sk_sp<SkShader> fShader;
-    sk_sp<SkSurface> fMinSurface;
-    sk_sp<SkSurface> fMaxSurface;
+    SkMatrix            fMatrix, fInverse;
+    SkRect              fBounds, fClipRect;
+    sk_sp<SkShader>     fShader0;
+    sk_sp<SkShader>     fShader1;
+    sk_sp<SkShader>     fShader;
+    sk_sp<SkSurface>    fMinSurface;
+    sk_sp<SkSurface>    fMaxSurface;
 
     void setupPaint(SkPaint* paint) {
         bool aa = this->getAA();
         paint->setStrokeCap(fStrokeCap);
         switch (fStyle) {
             case kHair_Style:
                 paint->setStrokeWidth(0);
                 break;
             case kStroke_Style:
                 paint->setStrokeWidth(SK_Scalar1);
                 break;
         }
         paint->setAntiAlias(aa);
     }
 
     void setupSkeletonPaint(SkPaint* paint) {
         paint->setStyle(SkPaint::kStroke_Style);
         paint->setStrokeWidth(WIRE_FRAME_SIZE);
         paint->setColor(fShowSkeleton ? WIRE_FRAME_COLOR : 0);
         paint->setAntiAlias(true);
     }
 
     void drawTriangleSkeleton(SkCanvas* max, const SkPoint pts[]);
     void drawLineSkeleton(SkCanvas* max, const SkPoint pts[]);
     void drawRectSkeleton(SkCanvas* max, const SkRect& r) {
         SkPaint paint;
         this->setupSkeletonPaint(&paint);
         SkPath path;
 
-        if (fUseGPU && fAA) {
-            SkRect rr = r;
-            rr.inset(SkIntToScalar(fZoom)/2, SkIntToScalar(fZoom)/2);
-            path.addRect(rr);
-            path.moveTo(rr.fLeft, rr.fTop);
-            path.lineTo(rr.fRight, rr.fBottom);
-            rr = r;
-            rr.inset(-SkIntToScalar(fZoom)/2, -SkIntToScalar(fZoom)/2);
-            path.addRect(rr);
-        } else {
-            fRectAsOval ? path.addOval(r) : path.addRect(r);
-            if (fUseGPU) {
-                path.moveTo(r.fLeft, r.fTop);
-                path.lineTo(r.fRight, r.fBottom);
-            }
-        }
+        fRectAsOval ? path.addOval(r) : path.addRect(r);
         max->drawPath(path, paint);
     }
 
     void copyMinToMax() {
         erase(fMaxSurface.get());
         SkCanvas* canvas = fMaxSurface->getCanvas();
         canvas->save();
         canvas->concat(fMatrix);
         fMinSurface->draw(canvas, 0, 0, nullptr);
         canvas->restore();
@@ skipping 56 matching lines @@
 }
 
 void FatBits::drawLineSkeleton(SkCanvas* max, const SkPoint pts[]) {
     SkPaint paint;
     this->setupSkeletonPaint(&paint);
 
     SkPath path;
     path.moveTo(pts[0]);
     path.lineTo(pts[1]);
 
-    switch (fStyle) {
-        case kHair_Style:
-            if (fUseGPU) {
-                SkPaint p;
-                p.setStyle(SkPaint::kStroke_Style);
-                p.setStrokeWidth(SK_Scalar1 * fZoom);
-                SkPath dst;
-                p.getFillPath(path, &dst);
-                path.addPath(dst);
-            }
-            break;
-        case kStroke_Style: {
-            SkPaint p;
-            p.setStyle(SkPaint::kStroke_Style);
-            p.setStrokeWidth(SK_Scalar1 * fZoom);
-            p.setStrokeCap(fStrokeCap);
-            SkPath dst;
-            p.getFillPath(path, &dst);
-            path = dst;
+    if (fStyle == kStroke_Style) {
+        SkPaint p;
+        p.setStyle(SkPaint::kStroke_Style);
+        p.setStrokeWidth(SK_Scalar1 * fZoom);
+        p.setStrokeCap(fStrokeCap);
+        SkPath dst;
+        p.getFillPath(path, &dst);
+        path = dst;
 
-            path.moveTo(pts[0]);
-            path.lineTo(pts[1]);
-
-            if (fUseGPU) {
-                path.moveTo(dst.getPoint(0));
-                path.lineTo(dst.getPoint(2));
-            }
-        } break;
+        path.moveTo(pts[0]);
+        path.lineTo(pts[1]);
     }
     max->drawPath(path, paint);
 }
 
 void FatBits::drawLine(SkCanvas* canvas, SkPoint pts[]) {
     SkPaint paint;
 
     fInverse.mapPoints(pts, 2);
 
     if (fGrid) {
@@ skipping 101 matching lines @@
     int fIndex;
 public:
     IndexClick(SkView* v, int index) : SkView::Click(v), fIndex(index) {}
 
     static int GetIndex(SkView::Click* click) {
         return ((IndexClick*)click)->fIndex;
     }
 };
 
 class DrawLineView : public SampleView {
-    enum {
-        kZoom = 96
-    };
-
     FatBits fFB;
     SkPoint fPts[3];
     bool    fIsRect;
+    int     fZoom = 64;
 public:
     DrawLineView() {
-        fFB.setWHZ(24, 16, kZoom);
+        fFB.setWHZ(24*2, 16*2, fZoom);
         fPts[0].set(1, 1);
         fPts[1].set(5, 4);
         fPts[2].set(2, 6);
-        SkMatrix::MakeScale(kZoom, kZoom).mapPoints(fPts, 3);
+        SkMatrix::MakeScale(SkIntToScalar(fZoom)).mapPoints(fPts, 3);
         fIsRect = false;
     }
 
     void setStyle(FatBits::Style s) {
         fFB.setStyle(s);
         this->inval(nullptr);
     }
 
 protected:
     bool onQuery(SkEvent* evt) override {
@@ skipping 37 matching lines @@
                 } break;
                 case 'a':
                     fFB.setAA(!fFB.getAA());
                     this->inval(nullptr);
                     return true;
                 case 'w':
                     fFB.setShowSkeleton(!fFB.getShowSkeleton());
                     this->inval(nullptr);
                     return true;
                 case 'g':
-                    fFB.setUseGPU(!fFB.getUseGPU());
+                    fFB.togglePixelColors();
                     this->inval(nullptr);
                     return true;
                 case 't':
                     fFB.setTriangle(!fFB.getTriangle());
                     this->inval(nullptr);
                     return true;
             }
         }
         return this->INHERITED::onQuery(evt);
     }
 
     void onDrawContent(SkCanvas* canvas) override {
         fFB.drawBG(canvas);
         if (fFB.getTriangle()) {
             fFB.drawTriangle(canvas, fPts);
         }
         else if (fIsRect) {
             fFB.drawRect(canvas, fPts);
         } else {
             fFB.drawLine(canvas, fPts);
         }
         fFB.drawFG(canvas);
 
         {
             SkString str;
-            str.printf("%s %s %s %s",
+            str.printf("%s %s %s",
                        fFB.getAA() ? "AA" : "BW",
                        FatBits::kHair_Style == fFB.getStyle() ? "Hair" : "Stroke",
-                       fFB.getUseGPU() ? "GPU" : "CPU",
                        fFB.getUseClip() ? "clip" : "noclip");
             SkPaint paint;
             paint.setAntiAlias(true);
             paint.setTextSize(16);
             paint.setColor(SK_ColorBLUE);
             canvas->drawText(str.c_str(), str.size(), 10, 16, paint);
         }
     }
 
     SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
@@ skipping 28 matching lines @@
 
 private:
 
     typedef SampleView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new DrawLineView; }
 static SkViewRegister reg(MyFactory);