Style bikeshed - remove extraneous whitespace

samplecode/SamplePathClip.cpp

-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SampleCode.h"
 #include "SkView.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
@@ skipping 61 matching lines @@
 DEF_SAMPLE( return new PathClipView; )
 
 //////////////////////////////////////////////////////////////////////////////
 
 static int clip_line(const SkRect& bounds, SkPoint p0, SkPoint p1, SkPoint edges[]) {
     SkPoint* edgesStart = edges;
 
     if (p0.fY == p1.fY) {
         return 0;
     }
-    
+
     if (p0.fY > p1.fY) {
         SkTSwap(p0, p1);
     }
     // now we're monotonic in Y: p0 <= p1
     if (p1.fY <= bounds.top() || p0.fY >= bounds.bottom()) {
         return 0;
     }
-    
+
     double dxdy = (double)(p1.fX - p0.fX) / (p1.fY - p0.fY);
     if (p0.fY < bounds.top()) {
         p0.fX = SkDoubleToScalar(p0.fX + dxdy * (bounds.top() - p0.fY));
         p0.fY = bounds.top();
     }
     if (p1.fY > bounds.bottom()) {
         p1.fX = SkDoubleToScalar(p1.fX + dxdy * (bounds.bottom() - p1.fY));
         p1.fY = bounds.bottom();
     }
-    
+
     // Now p0...p1 is strictly inside bounds vertically, so we just need to clip horizontally
-    
+
     if (p0.fX > p1.fX) {
         SkTSwap(p0, p1);
     }
     // now we're left-to-right: p0 .. p1
-    
+
     if (p1.fX <= bounds.left()) {   // entirely to the left
         p0.fX = p1.fX = bounds.left();
         *edges++ = p0;
         *edges++ = p1;
         return 2;
     }
     if (p0.fX >= bounds.right()) {  // entirely to the right
         p0.fX = p1.fX = bounds.right();
         *edges++ = p0;
         *edges++ = p1;
         return 2;
     }
-    
+
     if (p0.fX < bounds.left()) {
         float y = SkDoubleToScalar(p0.fY + (bounds.left() - p0.fX) / dxdy);
         *edges++ = SkPoint::Make(bounds.left(), p0.fY);
         *edges++ = SkPoint::Make(bounds.left(), y);
         p0.set(bounds.left(), y);
     }
     if (p1.fX > bounds.right()) {
         float y = SkDoubleToScalar(p0.fY + (bounds.right() - p0.fX) / dxdy);
         *edges++ = p0;
         *edges++ = SkPoint::Make(bounds.right(), y);
@@ skipping 18 matching lines @@
 // Demonstrate edge-clipping that is used in the scan converter
 //
 class EdgeClipView : public SampleView {
     enum {
         N = 3
     };
 public:
     SkPoint fPoly[N];
     SkRect  fClip;
     SkColor fEdgeColor[N];
-    
+
     EdgeClipView() : fClip(SkRect::MakeLTRB(150, 150, 550, 450)) {
         fPoly[0].set(300, 40);
         fPoly[1].set(550, 250);
         fPoly[2].set(40, 450);
 
         fEdgeColor[0] = 0xFFFF0000;
         fEdgeColor[1] = 0xFF00FF00;
         fEdgeColor[2] = 0xFF0000FF;
     }
-    
+
 protected:
     bool onQuery(SkEvent* evt) override {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "EdgeClip");
             return true;
         }
         return this->INHERITED::onQuery(evt);
     }
 
     static SkScalar snap(SkScalar x) {
@@ skipping 52 matching lines @@
             draw_clipped_line(canvas, fClip, fPoly[i], fPoly[j], p);
         }
         canvas->restore();
     }
 
     class MyClick : public Click {
     public:
         MyClick(SkView* view) : Click(view) {}
         virtual void handleMove() = 0;
     };
-    
+
     class VertClick : public MyClick {
         SkPoint* fPt;
     public:
         VertClick(SkView* view, SkPoint* pt) : MyClick(view), fPt(pt) {}
         void handleMove() override { *fPt = snap(fCurr); }
     };
-    
+
     class DragRectClick : public MyClick {
         SkRect* fRect;
     public:
         DragRectClick(SkView* view, SkRect* rect) : MyClick(view), fRect(rect) {}
         void handleMove() override { fRect->offset(fCurr.x() - fPrev.x(), fCurr.y() - fPrev.y()); }
     };
-    
+
     class DragPolyClick : public MyClick {
         SkPoint fSrc[100];
         SkPoint* fPoly;
         int fCount;
     public:
         DragPolyClick(SkView* view, SkPoint poly[], int count)
             : MyClick(view), fPoly(poly), fCount(count)
         {
             SkASSERT((size_t)count <= SK_ARRAY_COUNT(fSrc));
             memcpy(fSrc, poly, count * sizeof(SkPoint));
@@ skipping 19 matching lines @@
         const SkScalar dy = pt.y() - y;
         return dx*dx + dy*dy <= rad*rad;
     }
 
     SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
         for (int i = 0; i < N; ++i) {
             if (hit_test(fPoly[i], x, y)) {
                 return new VertClick(this, &fPoly[i]);
             }
         }
-        
+
         SkPath path;
         path.addPoly(fPoly, N, true);
         if (path.contains(x, y)) {
             return new DragPolyClick(this, fPoly, N);
         }
 
         if (fClip.intersects(SkRect::MakeLTRB(x - 1, y - 1, x + 1, y + 1))) {
             return new DragRectClick(this, &fClip);
         }
         return new DoNothingClick(this);
     }
-    
+
     bool onClick(Click* click) override {
         ((MyClick*)click)->handleMove();
         this->inval(nullptr);
         return false;
     }
-    
+
 private:
     typedef SampleView INHERITED;
 };
 DEF_SAMPLE( return new EdgeClipView; )
-