Add asADash entry point into SkPathEffect to allow extracting Dash info from PathEffects

src/effects/SkDashPathEffect.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDashPathEffect.h"
@@ skipping 16 matching lines @@
         }
     }
     // If we get here, phase "appears" to be larger than our length. This
     // shouldn't happen with perfect precision, but we can accumulate errors
     // during the initial length computation (rounding can make our sum be too
     // big or too small. In that event, we just have to eat the error here.
     *index = 0;
     return intervals[0];
 }
 
-SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count,
-                                   SkScalar phase, bool scaleToFit)
-        : fScaleToFit(scaleToFit) {
-    SkASSERT(intervals);
-    SkASSERT(count > 1 && SkAlign2(count) == count);
-
-    fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
-    fCount = count;
-
+void SkDashPathEffect::setInternalMembers(SkScalar phase) {
     SkScalar len = 0;
-    for (int i = 0; i < count; i++) {
-        SkASSERT(intervals[i] >= 0);
-        fIntervals[i] = intervals[i];
-        len += intervals[i];
+    for (int i = 0; i < fCount; i++) {
+        len += fIntervals[i];
     }
     fIntervalLength = len;
 
     // watch out for values that might make us go out of bounds
     if ((len > 0) && SkScalarIsFinite(phase) && SkScalarIsFinite(len)) {
 
         // Adjust phase to be between 0 and len, "flipping" phase if negative.
         // e.g., if len is 100, then phase of -20 (or -120) is equivalent to 80
         if (phase < 0) {
             phase = -phase;
             if (phase > len) {
                 phase = SkScalarMod(phase, len);
             }
             phase = len - phase;
 
             // Due to finite precision, it's possible that phase == len,
             // even after the subtract (if len >>> phase), so fix that here.
             // This fixes http://crbug.com/124652 .
             SkASSERT(phase <= len);
             if (phase == len) {
                 phase = 0;
             }
         } else if (phase >= len) {
             phase = SkScalarMod(phase, len);
         }
         SkASSERT(phase >= 0 && phase < len);
 
-        fInitialDashLength = FindFirstInterval(intervals, phase,
-                                               &fInitialDashIndex, count);
+        fPhase = phase;
+
+        fInitialDashLength = FindFirstInterval(fIntervals, fPhase,
+                                               &fInitialDashIndex, fCount);
 
         SkASSERT(fInitialDashLength >= 0);
         SkASSERT(fInitialDashIndex >= 0 && fInitialDashIndex < fCount);
     } else {
         fInitialDashLength = -1;    // signal bad dash intervals
     }
 }
 
+SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count,
+                                   SkScalar phase, bool scaleToFit)
+        : fScaleToFit(scaleToFit) {
+    SkASSERT(intervals);
+    SkASSERT(count > 1 && SkAlign2(count) == count);
+
+    fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
+    fCount = count;
+    for (int i = 0; i < count; i++) {
+        SkASSERT(intervals[i] >= 0);
+        fIntervals[i] = intervals[i];
+    }
+
+    this->setInternalMembers(phase);
+}
+
 SkDashPathEffect::~SkDashPathEffect() {
     sk_free(fIntervals);
 }
 
 static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) {
     SkScalar radius = SkScalarHalf(rec.getWidth());
     if (0 == radius) {
         radius = SK_Scalar1;    // hairlines
     }
     if (SkPaint::kMiter_Join == rec.getJoin()) {
@@ skipping 424 matching lines @@
             results->fLast.addRect(x - halfWidth, y - halfHeight,
                                    x + halfWidth, y + halfHeight);
         }
 
         SkASSERT(curPt == results->fNumPoints);
     }
 
     return true;
 }
 
+SkPathEffect::DashType SkDashPathEffect::asADash(DashInfo* info) const {
+    if (info) {
+       if (info->fCount >= fCount) {
+            if (info->fIntervals) {
+                memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar));
+            }
+       }
+       info->fCount = fCount;
+       info->fPhase = fPhase;
+       info->fScaleToFit = fScaleToFit;
+    }
+    return kDash_DashType;
+}
+
+#define NEW_FLATTEN_VERSION 123
+
 SkFlattenable::Factory SkDashPathEffect::getFactory() const {
     return CreateProc;
 }
 
 void SkDashPathEffect::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
-    buffer.writeInt(fInitialDashIndex);
-    buffer.writeScalar(fInitialDashLength);
-    buffer.writeScalar(fIntervalLength);
+    if (buffer.pictureVersion() < NEW_FLATTEN_VERSION) {

[bsalomon, 2014/03/28 14:57:22]

Do we need this? Will we ever write an old picture format? I think we only care
about reading old ones.

+        buffer.writeInt(fInitialDashIndex);
+        buffer.writeScalar(fInitialDashLength);
+        buffer.writeScalar(fIntervalLength);
+    } else {
+        buffer.writeScalar(fPhase);
+    }
     buffer.writeBool(fScaleToFit);
     buffer.writeScalarArray(fIntervals, fCount);
 }
 
 SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
     return SkNEW_ARGS(SkDashPathEffect, (buffer));
 }
 
 SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
-    fInitialDashIndex = buffer.readInt();
-    fInitialDashLength = buffer.readScalar();
-    fIntervalLength = buffer.readScalar();
+    if (buffer.pictureVersion() < NEW_FLATTEN_VERSION) {
+        fInitialDashIndex = buffer.readInt();
+        fInitialDashLength = buffer.readScalar();
+        fIntervalLength = buffer.readScalar();
+    } else {
+        fPhase = buffer.readScalar();
+    }
+
     fScaleToFit = buffer.readBool();
 
     fCount = buffer.getArrayCount();
     size_t allocSize = sizeof(SkScalar) * fCount;
     if (buffer.validateAvailable(allocSize)) {
         fIntervals = (SkScalar*)sk_malloc_throw(allocSize);
         buffer.readScalarArray(fIntervals, fCount);
     } else {
         fIntervals = NULL;
     }
+
+    if (buffer.pictureVersion() < NEW_FLATTEN_VERSION) {
+        fPhase = 0.0;
+        for (int i = 0; i < fInitialDashIndex; ++i) {
+            fPhase += fIntervals[i];
+        }
+        fPhase += fInitialDashLength;
+    } else {
+        this->setInternalMembers(fPhase);
+    }
 }