working on initial winding for cubics

src/pathops/SkOpSegment.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.
  */
 #ifndef SkOpSegment_DEFINE
 #define SkOpSegment_DEFINE
 
 #include "SkOpAngle.h"
 #include "SkOpSpan.h"
 #include "SkOpTAllocator.h"
 #include "SkPathOpsBounds.h"
+#include "SkPathOpsCubic.h"
 #include "SkPathOpsCurve.h"
 
 struct SkDCurve;
 class SkOpCoincidence;
 class SkOpContour;
 class SkPathWriter;
 
 class SkOpSegment {
 public:
     enum AllowAlias {
@@ skipping 14 matching lines @@
     bool activeOp(SkOpSpanBase* start, SkOpSpanBase* end, int xorMiMask, int xorSuMask,
                   SkPathOp op);
     bool activeOp(int xorMiMask, int xorSuMask, SkOpSpanBase* start, SkOpSpanBase* end, SkPathOp op,
                   int* sumMiWinding, int* sumSuWinding);
 
     SkPoint activeLeftTop(SkOpSpanBase** firstT);
 
     bool activeWinding(SkOpSpanBase* start, SkOpSpanBase* end);
     bool activeWinding(SkOpSpanBase* start, SkOpSpanBase* end, int* sumWinding);
 
-    void addConic(SkPoint pts[3], SkScalar weight, SkOpContour* parent) {
+    SkOpSegment* addConic(SkPoint pts[3], SkScalar weight, SkOpContour* parent) {
         init(pts, weight, parent, SkPath::kConic_Verb);
         fBounds.setConicBounds(pts, weight);
+        return this;
     }
 
-    void addCubic(SkPoint pts[4], SkOpContour* parent) {
+    SkOpSegment* addCubic(SkPoint pts[4], SkOpContour* parent) {
         init(pts, 1, parent, SkPath::kCubic_Verb);
         fBounds.setCubicBounds(pts, 1);
+        return this;
     }
 
     void addCurveTo(const SkOpSpanBase* start, const SkOpSpanBase* end, SkPathWriter* path,
                     bool active) const;
 
     SkOpAngle* addEndSpan(SkChunkAlloc* allocator) {
         SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(allocator);
         angle->set(&fTail, fTail.prev());
         fTail.setFromAngle(angle);
         return angle;
     }
 
-    void addLine(SkPoint pts[2], SkOpContour* parent) {
+    SkOpSegment* addLine(SkPoint pts[2], SkOpContour* parent) {
         init(pts, 1, parent, SkPath::kLine_Verb);
         fBounds.set(pts, 2);
+        return this;
     }
 
     SkOpPtT* addMissing(double t, SkOpSegment* opp, SkChunkAlloc* );
     SkOpAngle* addSingletonAngleDown(SkOpSegment** otherPtr, SkOpAngle** , SkChunkAlloc* );
     SkOpAngle* addSingletonAngles(int step, SkChunkAlloc* );
     SkOpAngle* addSingletonAngleUp(SkOpSegment** otherPtr, SkOpAngle** , SkChunkAlloc* );
 
     SkOpAngle* addStartSpan(SkChunkAlloc* allocator) {
         SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(allocator);
         angle->set(&fHead, fHead.next());
         fHead.setToAngle(angle);
         return angle;
     }
 
-    void addQuad(SkPoint pts[3], SkOpContour* parent) {
+    SkOpSegment* addQuad(SkPoint pts[3], SkOpContour* parent) {
         init(pts, 1, parent, SkPath::kQuad_Verb);
         fBounds.setQuadBounds(pts, 1);
+        return this;
     }
 
     SkOpPtT* addT(double t, AllowAlias , SkChunkAlloc* );
 
     void align();
     static bool BetweenTs(const SkOpSpanBase* lesser, double testT, const SkOpSpanBase* greater);
 
     const SkPathOpsBounds& bounds() const {
         return fBounds;
     }
@@ skipping 192 matching lines @@
     bool ptsDisjoint(double t1, const SkPoint& pt1, double t2, const SkPoint& pt2) const;
 
     void resetVisited() {
         fVisited = false;
     }
 
     void setContour(SkOpContour* contour) {
         fContour = contour;
     }
 
+    void setCubicType(SkDCubic::CubicType cubicType) {
+        fCubicType = cubicType;
+    }
+
     void setNext(SkOpSegment* next) {
         fNext = next;
     }
 
     void setPrev(SkOpSegment* prev) {
         fPrev = prev;
     }
 
     bool setVisited() {
         if (fVisited) {
@@ skipping 72 matching lines @@
     SkOpSpanBase fTail;  // the tail span always has its t set to one
     SkOpContour* fContour;
     SkOpSegment* fNext;  // forward-only linked list used by contour to walk the segments
     const SkOpSegment* fPrev;
     SkPoint* fPts;  // pointer into array of points owned by edge builder that may be tweaked
     SkPathOpsBounds fBounds;  // tight bounds
     SkScalar fWeight;
     int fCount;  // number of spans (one for a non-intersecting segment)
     int fDoneCount;  // number of processed spans (zero initially)
     SkPath::Verb fVerb;
+    SkDCubic::CubicType fCubicType;
     bool fVisited;  // used by missing coincidence check
     SkDEBUGCODE(int fID);
 };
 
 #endif