style cleanup

git-svn-id: http://skia.googlecode.com/svn/trunk@2100 2bbb7eff-a529-9590-31e7-b0007b416f81

diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 0df8cbd9c1fa27637c31cad9ad62c0f4d96db9eb..054f1d5cb7b840e7c3a3388651bd64b5057238aa 100644 (file)
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -10,52 +10,48 @@
 #include "Sk1DPathEffect.h"
 #include "SkPathMeasure.h"
 
-bool Sk1DPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
-{
+bool Sk1DPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* width) {
     SkPathMeasure   meas(src, false);
     do {
         SkScalar    length = meas.getLength();
         SkScalar    distance = this->begin(length);
-        while (distance < length)
-        {
+        while (distance < length) {
             SkScalar delta = this->next(dst, distance, meas);
-            if (delta <= 0)
+            if (delta <= 0) {
                 break;
+            }
             distance += delta;
         }
     } while (meas.nextContour());
     return true;
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
 SkPath1DPathEffect::SkPath1DPathEffect(const SkPath& path, SkScalar advance, 
     SkScalar phase, Style style) : fPath(path)
 {
-    if (advance <= 0 || path.isEmpty())
-    {
+    if (advance <= 0 || path.isEmpty()) {
         SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n"));
         fAdvance = 0;   // signals we can't draw anything
-    }
-    else
-    {
+    } else {
         // cleanup their phase parameter, inverting it so that it becomes an
         // offset along the path (to match the interpretation in PostScript)
-        if (phase < 0)
-        {
+        if (phase < 0) {
             phase = -phase;
-            if (phase > advance)
+            if (phase > advance) {
                 phase = SkScalarMod(phase, advance);
-        }
-        else
-        {
-            if (phase > advance)
+            }
+        } else {
+            if (phase > advance) {
                 phase = SkScalarMod(phase, advance);
+            }
             phase = advance - phase;
         }
         // now catch the edge case where phase == advance (within epsilon)
-        if (phase >= advance)
+        if (phase >= advance) {
             phase = 0;
+        }
         SkASSERT(phase >= 0);
 
         fAdvance = advance;
@@ -68,10 +64,9 @@ SkPath1DPathEffect::SkPath1DPathEffect(const SkPath& path, SkScalar advance,
     }
 }
 
-bool SkPath1DPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
-{
-    if (fAdvance > 0)
-    {
+bool SkPath1DPathEffect::filterPath(SkPath* dst, const SkPath& src,
+                                    SkScalar* width) {
+    if (fAdvance > 0) {
         *width = -1;
         return this->INHERITED::filterPath(dst, src, width);
     }
@@ -79,10 +74,8 @@ bool SkPath1DPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* wi
 }
 
 static void morphpoints(SkPoint dst[], const SkPoint src[], int count,
-                        SkPathMeasure& meas, SkScalar dist)
-{
-    for (int i = 0; i < count; i++)
-    {
+                        SkPathMeasure& meas, SkScalar dist) {
+    for (int i = 0; i < count; i++) {
         SkPoint pos;
         SkVector tangent;
         
@@ -108,14 +101,13 @@ Need differentially more subdivisions when the follow-path is curvy. Not sure ho
 determine that, but we need it. I guess a cheap answer is let the caller tell us,
 but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out.
 */
-static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas, SkScalar dist)
-{
+static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas,
+                      SkScalar dist) {
     SkPath::Iter    iter(src, false);
     SkPoint         srcP[4], dstP[3];
     SkPath::Verb    verb;
-    
-    while ((verb = iter.next(srcP)) != SkPath::kDone_Verb)
-    {
+
+    while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kMove_Verb:
                 morphpoints(dstP, srcP, 1, meas, dist);
@@ -144,8 +136,7 @@ static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas, SkSca
     }
 }
 
-SkPath1DPathEffect::SkPath1DPathEffect(SkFlattenableReadBuffer& buffer)
-{
+SkPath1DPathEffect::SkPath1DPathEffect(SkFlattenableReadBuffer& buffer) {
     fAdvance = buffer.readScalar();
     if (fAdvance > 0) {
         fPath.unflatten(buffer);
@@ -154,13 +145,11 @@ SkPath1DPathEffect::SkPath1DPathEffect(SkFlattenableReadBuffer& buffer)
     }
 }
 
-SkScalar SkPath1DPathEffect::begin(SkScalar contourLength)
-{
+SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) {
     return fInitialOffset;
 }
 
-void SkPath1DPathEffect::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkPath1DPathEffect::flatten(SkFlattenableWriteBuffer& buffer) {
     buffer.writeScalar(fAdvance);
     if (fAdvance > 0) {
         fPath.flatten(buffer);
@@ -169,23 +158,19 @@ void SkPath1DPathEffect::flatten(SkFlattenableWriteBuffer& buffer)
     }
 }
 
-SkScalar SkPath1DPathEffect::next(SkPath* dst, SkScalar distance, SkPathMeasure& meas)
-{
+SkScalar SkPath1DPathEffect::next(SkPath* dst, SkScalar distance,
+                                  SkPathMeasure& meas) {
     switch (fStyle) {
-        case kTranslate_Style:
-        {
+        case kTranslate_Style: {
             SkPoint pos;
             meas.getPosTan(distance, &pos, NULL);
             dst->addPath(fPath, pos.fX, pos.fY);
-        }
-            break;
-        case kRotate_Style:
-        {
+        } break;
+        case kRotate_Style: {
             SkMatrix matrix;
             meas.getMatrix(distance, &matrix);
             dst->addPath(fPath, matrix);
-        }
-            break;
+        } break;
         case kMorph_Style:
             morphpath(dst, fPath, meas, distance);
             break;