path ops work in progress

src/pathops/SkIntersectionHelper.h

 /*
  * 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 "SkOpContour.h"
 #include "SkPath.h"
 
 class SkIntersectionHelper {
 public:
     enum SegmentType {
         kHorizontalLine_Segment = -1,
         kVerticalLine_Segment = 0,
         kLine_Segment = SkPath::kLine_Verb,
         kQuad_Segment = SkPath::kQuad_Verb,
         kCubic_Segment = SkPath::kCubic_Verb,
     };
 
-    void addCoincident(SkIntersectionHelper& other, const SkIntersections& ts, bool swap) {
-        fContour->addCoincident(fIndex, other.fContour, other.fIndex, ts, swap);
+    bool addCoincident(SkIntersectionHelper& other, const SkIntersections& ts, bool swap) {
+        return fContour->addCoincident(fIndex, other.fContour, other.fIndex, ts, swap);
     }
 
     // FIXME: does it make sense to write otherIndex now if we're going to
     // fix it up later?
     void addOtherT(int index, double otherT, int otherIndex) {
         fContour->addOtherT(fIndex, index, otherT, otherIndex);
     }
 
-    void addPartialCoincident(SkIntersectionHelper& other, const SkIntersections& ts, int index,
+    bool addPartialCoincident(SkIntersectionHelper& other, const SkIntersections& ts, int index,
             bool swap) {
-        fContour->addPartialCoincident(fIndex, other.fContour, other.fIndex, ts, index, swap);
+        return fContour->addPartialCoincident(fIndex, other.fContour, other.fIndex, ts, index,
+                swap);
     }
 
     // Avoid collapsing t values that are close to the same since
     // we walk ts to describe consecutive intersections. Since a pair of ts can
     // be nearly equal, any problems caused by this should be taken care
     // of later.
     // On the edge or out of range values are negative; add 2 to get end
     int addT(const SkIntersectionHelper& other, const SkPoint& pt, double newT, bool isNear) {
         return fContour->addT(fIndex, other.fContour, other.fIndex, pt, newT, isNear);
     }
@@ skipping 27 matching lines @@
     bool isFirstLast(const SkIntersectionHelper& next) {
         return fContour == next.fContour && fIndex == 0
                 && next.fIndex == fLast - 1;
     }
 
     bool isNear(double t1, double t2, const SkDPoint& pt1, const SkDPoint& pt2) const {
         const SkOpSegment& segment = fContour->segments()[fIndex];
         double mid = (t1 + t2) / 2;
         SkDPoint midPtByT = segment.dPtAtT(mid);
         SkDPoint midPtByAvg = SkDPoint::Mid(pt1, pt2);
-        return midPtByT.approximatelyEqualHalf(midPtByAvg);
+        return midPtByT.approximatelyEqual(midPtByAvg);
     }
 
     SkScalar left() const {
         return bounds().fLeft;
     }
 
     const SkPoint* pts() const {
         return fContour->segments()[fIndex].pts();
     }
 
@@ skipping 43 matching lines @@
 
     bool yFlipped() const {
         return y() != pts()[0].fY;
     }
 
 private:
     SkOpContour* fContour;
     int fIndex;
     int fLast;
 };