Removed all GSList occurences in .h files

8 files changed, 84 insertions, 104 deletions

diff --git a/src/ui/tools/calligraphic-tool.cpp b/src/ui/tools/calligraphic-tool.cpp
index 3e00fe69c..ca94ac75f 100644
--- a/src/ui/tools/calligraphic-tool.cpp
+++ b/src/ui/tools/calligraphic-tool.cpp
@@ -421,10 +421,9 @@ void CalligraphicTool::cancel() {
     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), 0);
 
 	/* Remove all temporary line segments */
-	while (this->segments) {
-		sp_canvas_item_destroy(SP_CANVAS_ITEM(this->segments->data));
-		this->segments = g_slist_remove(this->segments, this->segments->data);
-	}
+    for (auto i:this->segments)
+        sp_canvas_item_destroy(SP_CANVAS_ITEM(i));
+    this->segments.clear();
 
 	/* reset accumulated curve */
 	this->accumulated->reset();
@@ -731,10 +730,9 @@ bool CalligraphicTool::root_handler(GdkEvent* event) {
             this->apply(motion_dt);
 
             /* Remove all temporary line segments */
-            while (this->segments) {
-                sp_canvas_item_destroy(SP_CANVAS_ITEM(this->segments->data));
-                this->segments = g_slist_remove(this->segments, this->segments->data);
-            }
+            for (auto i:this->segments)
+                sp_canvas_item_destroy(SP_CANVAS_ITEM(i));
+            this->segments.clear();
 
             /* Create object */
             this->fit_and_split(true);
@@ -1089,7 +1087,7 @@ void CalligraphicTool::fit_and_split(bool release) {
                     this->currentcurve->curveto(bp2[2], bp2[1], bp2[0]);
                 }
                 // FIXME: dc->segments is always NULL at this point??
-                if (!this->segments) { // first segment
+                if (this->segments.empty()) { // first segment
                     add_cap(this->currentcurve, b2[0], b1[0], this->cap_rounding);
                 }
                 this->currentcurve->closepath();
@@ -1143,8 +1141,8 @@ void CalligraphicTool::fit_and_split(bool release) {
             sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cbp), 0x00000000, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
             /* fixme: Cannot we cascade it to root more clearly? */
             g_signal_connect(G_OBJECT(cbp), "event", G_CALLBACK(sp_desktop_root_handler), desktop);
-
-            this->segments = g_slist_prepend(this->segments, cbp);
+            
+            this->segments.push_back(cbp);
         }
 
         this->point1[0] = this->point1[this->npoints - 1];
diff --git a/src/ui/tools/dynamic-base.cpp b/src/ui/tools/dynamic-base.cpp
index bb4989333..1026c26c6 100644
--- a/src/ui/tools/dynamic-base.cpp
+++ b/src/ui/tools/dynamic-base.cpp
@@ -21,7 +21,6 @@ namespace Tools {
 DynamicBase::DynamicBase(gchar const *const *cursor_shape)
     : ToolBase(cursor_shape)
     , accumulated(NULL)
-    , segments(NULL)
     , currentshape(NULL)
     , currentcurve(NULL)
     , cal1(NULL)
@@ -62,10 +61,10 @@ DynamicBase::~DynamicBase() {
         this->accumulated = 0;
     }
 
-    while (this->segments) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(this->segments->data));
-        this->segments = g_slist_remove(this->segments, this->segments->data);
+    for (auto i:segments) {
+        sp_canvas_item_destroy(SP_CANVAS_ITEM(i));
     }
+    segments.clear();
 
     if (this->currentcurve) {
         this->currentcurve = this->currentcurve->unref();
diff --git a/src/ui/tools/dynamic-base.h b/src/ui/tools/dynamic-base.h
index e270052f3..b9ffd71ce 100644
--- a/src/ui/tools/dynamic-base.h
+++ b/src/ui/tools/dynamic-base.h
@@ -20,6 +20,7 @@
  */
 
 #include "ui/tools/tool-base.h"
+#include "display/sp-canvas-item.h"
 
 struct SPCanvasItem;
 class SPCurve;
@@ -48,7 +49,7 @@ protected:
     SPCurve *accumulated;
 
     /** canvas items for "committed" segments */
-    GSList *segments;
+    std::vector<SPCanvasItem*> segments;
 
     /** canvas item for red "leading" segment */
     SPCanvasItem *currentshape;
diff --git a/src/ui/tools/eraser-tool.cpp b/src/ui/tools/eraser-tool.cpp
index b919c138c..83039be18 100644
--- a/src/ui/tools/eraser-tool.cpp
+++ b/src/ui/tools/eraser-tool.cpp
@@ -360,10 +360,9 @@ void EraserTool::cancel() {
     this->is_drawing = false;
     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), 0);
             /* Remove all temporary line segments */
-            while (this->segments) {
-                sp_canvas_item_destroy(SP_CANVAS_ITEM(this->segments->data));
-                this->segments = g_slist_remove(this->segments, this->segments->data);
-            }
+    for (auto i : this->segments)
+        sp_canvas_item_destroy(SP_CANVAS_ITEM(i));
+    this->segments.clear();
             /* reset accumulated curve */
             this->accumulated->reset();
             this->clear_current();
@@ -464,10 +463,9 @@ bool EraserTool::root_handler(GdkEvent* event) {
             this->apply(motion_dt);
 
             /* Remove all temporary line segments */
-            while (this->segments) {
-                sp_canvas_item_destroy(SP_CANVAS_ITEM(this->segments->data));
-                this->segments = g_slist_remove(this->segments, this->segments->data);
-            }
+            for (auto i : this->segments)
+                sp_canvas_item_destroy(SP_CANVAS_ITEM(i));
+            this->segments.clear();
 
             /* Create object */
             this->fit_and_split(true);
@@ -1015,7 +1013,7 @@ void EraserTool::fit_and_split(bool release) {
                 }
 
                 // FIXME: this->segments is always NULL at this point??
-                if (!this->segments) { // first segment
+                if (this->segments.empty()) { // first segment
                     add_cap(this->currentcurve, b2[1], b2[0], b1[0], b1[1], this->cap_rounding);
                 }
 
@@ -1072,7 +1070,7 @@ void EraserTool::fit_and_split(bool release) {
             /* fixme: Cannot we cascade it to root more clearly? */
             g_signal_connect(G_OBJECT(cbp), "event", G_CALLBACK(sp_desktop_root_handler), desktop);
 
-            this->segments = g_slist_prepend(this->segments, cbp);
+            this->segments.push_back(cbp);
 
             if (eraser_mode == ERASER_MODE_DELETE) {
                 sp_canvas_item_hide(cbp);
diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp
index fce17542a..a85c89400 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -76,13 +76,10 @@ FreehandBase::FreehandBase(gchar const *const *cursor_shape)
     , red_curve(NULL)
     , blue_bpath(NULL)
     , blue_curve(NULL)
-    , green_bpaths(NULL)
     , green_curve(NULL)
     , green_anchor(NULL)
     , green_closed(false)
     , white_item(NULL)
-    , white_curves(NULL)
-    , white_anchors(NULL)
     , overwrite_curve(NULL)
     , sa(NULL)
     , ea(NULL)
@@ -558,22 +555,20 @@ static void spdc_attach_selection(FreehandBase *dc, Inkscape::Selection */*sel*/
         SPCurve *norm = SP_PATH(item)->get_curve_for_edit();
         norm->transform((dc->white_item)->i2dt_affine());
         g_return_if_fail( norm != NULL );
-        dc->white_curves = g_slist_reverse(norm->split());
+        dc->white_curves = norm->split();
         norm->unref();
 
         // Anchor list
-        for (GSList *l = dc->white_curves; l != NULL; l = l->next) {
-            SPCurve *c;
-            c = static_cast<SPCurve*>(l->data);
+        for (auto c:dc->white_curves) {
             g_return_if_fail( c->get_segment_count() > 0 );
             if ( !c->is_closed() ) {
                 SPDrawAnchor *a;
                 a = sp_draw_anchor_new(dc, c, TRUE, *(c->first_point()));
                 if (a)
-                    dc->white_anchors = g_slist_prepend(dc->white_anchors, a);
+                    dc->white_anchors.push_back(a);
                 a = sp_draw_anchor_new(dc, c, FALSE, *(c->last_point()));
                 if (a)
-                    dc->white_anchors = g_slist_prepend(dc->white_anchors, a);
+                    dc->white_anchors.push_back(a);
             }
         }
         // fixme: recalculate active anchor?
@@ -645,10 +640,9 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     // Green
     dc->green_curve = new SPCurve();
-    while (dc->green_bpaths) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(dc->green_bpaths->data));
-        dc->green_bpaths = g_slist_remove(dc->green_bpaths, dc->green_bpaths->data);
-    }
+    for (auto i : dc->green_bpaths)
+        sp_canvas_item_destroy(i);
+    dc->green_bpaths.clear();
 
     // Blue
     c->append_continuous(dc->blue_curve, 0.0625);
@@ -698,8 +692,8 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
             c->unref();
             dc->overwrite_curve->closepath_current();
             if(dc->sa){
-                dc->white_curves = g_slist_remove(dc->white_curves, dc->sa->curve);
-                dc->white_curves = g_slist_append(dc->white_curves, dc->overwrite_curve);
+                dc->white_curves.erase(std::find(dc->white_curves.begin(),dc->white_curves.end(), dc->sa->curve));
+                dc->white_curves.push_back(dc->overwrite_curve);
             }
         }else{
             dc->sa->curve->append_continuous(c, 0.0625);
@@ -713,7 +707,7 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
     // Step C - test start
     if (dc->sa) {
         SPCurve *s = dc->sa->curve;
-        dc->white_curves = g_slist_remove(dc->white_curves, s);
+        dc->white_curves.erase(std::find(dc->white_curves.begin(),dc->white_curves.end(), s));
         if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || 
             prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){
                 s = dc->overwrite_curve;
@@ -726,7 +720,7 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
         c = s;
     } else /* Step D - test end */ if (dc->ea) {
         SPCurve *e = dc->ea->curve;
-        dc->white_curves = g_slist_remove(dc->white_curves, e);
+        dc->white_curves.erase(std::find(dc->white_curves.begin(),dc->white_curves.end(), e));
         if (!dc->ea->start) {
             e = reverse_then_unref(e);
         }
@@ -766,11 +760,10 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
 static void spdc_flush_white(FreehandBase *dc, SPCurve *gc)
 {
     SPCurve *c;
-    if (dc->white_curves) {
+    if (! dc->white_curves.empty()) {
         g_assert(dc->white_item);
         c = SPCurve::concat(dc->white_curves);
-        g_slist_free(dc->white_curves);
-        dc->white_curves = NULL;
+        dc->white_curves.clear();
         if (gc) {
             c->append(gc, FALSE);
         }
@@ -856,8 +849,8 @@ SPDrawAnchor *spdc_test_inside(FreehandBase *dc, Geom::Point p)
         active = sp_draw_anchor_test(dc->green_anchor, p, TRUE);
     }
 
-    for (GSList *l = dc->white_anchors; l != NULL; l = l->next) {
-        SPDrawAnchor *na = sp_draw_anchor_test(static_cast<SPDrawAnchor*>(l->data), p, !active);
+    for (auto i:dc->white_anchors) {
+        SPDrawAnchor *na = sp_draw_anchor_test(i, p, !active);
         if ( !active && na ) {
             active = na;
         }
@@ -871,14 +864,12 @@ static void spdc_reset_white(FreehandBase *dc)
         // We do not hold refcount
         dc->white_item = NULL;
     }
-    while (dc->white_curves) {
-        reinterpret_cast<SPCurve *>(dc->white_curves->data)->unref();
-        dc->white_curves = g_slist_remove(dc->white_curves, dc->white_curves->data);
-    }
-    while (dc->white_anchors) {
-        sp_draw_anchor_destroy(static_cast<SPDrawAnchor*>(dc->white_anchors->data));
-        dc->white_anchors = g_slist_remove(dc->white_anchors, dc->white_anchors->data);
-    }
+    for (auto i: dc->white_curves)
+        i->unref();
+    dc->white_curves.clear();
+    for (auto i:dc->white_anchors)
+        sp_draw_anchor_destroy(i);
+    dc->white_anchors.clear();
 }
 
 static void spdc_free_colors(FreehandBase *dc)
@@ -902,10 +893,9 @@ static void spdc_free_colors(FreehandBase *dc)
     }
 
     // Green
-    while (dc->green_bpaths) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(dc->green_bpaths->data));
-        dc->green_bpaths = g_slist_remove(dc->green_bpaths, dc->green_bpaths->data);
-    }
+    for (auto i : dc->green_bpaths)
+        sp_canvas_item_destroy(i);
+    dc->green_bpaths.clear();
     if (dc->green_curve) {
         dc->green_curve = dc->green_curve->unref();
     }
@@ -918,14 +908,12 @@ static void spdc_free_colors(FreehandBase *dc)
         // We do not hold refcount
         dc->white_item = NULL;
     }
-    while (dc->white_curves) {
-        reinterpret_cast<SPCurve *>(dc->white_curves->data)->unref();
-        dc->white_curves = g_slist_remove(dc->white_curves, dc->white_curves->data);
-    }
-    while (dc->white_anchors) {
-        sp_draw_anchor_destroy(static_cast<SPDrawAnchor *>(dc->white_anchors->data));
-        dc->white_anchors = g_slist_remove(dc->white_anchors, dc->white_anchors->data);
-    }
+    for (auto i: dc->white_curves)
+        i->unref();
+    dc->white_curves.clear();
+    for (auto i:dc->white_anchors)
+        sp_draw_anchor_destroy(i);
+    dc->white_anchors.clear();
 }
 
 void spdc_create_single_dot(ToolBase *ec, Geom::Point const &pt, char const *tool, guint event_state) {
diff --git a/src/ui/tools/freehand-base.h b/src/ui/tools/freehand-base.h
index a3069aa09..dc114ef68 100644
--- a/src/ui/tools/freehand-base.h
+++ b/src/ui/tools/freehand-base.h
@@ -66,15 +66,15 @@ public:
     SPCurve *blue_curve;
 
     // Green
-    GSList *green_bpaths;
+    std::vector<SPCanvasItem*> green_bpaths;
     SPCurve *green_curve;
     SPDrawAnchor *green_anchor;
     gboolean green_closed; // a flag meaning we hit the green anchor, so close the path on itself
 
     // White
     SPItem *white_item;
-    GSList *white_curves;
-    GSList *white_anchors;
+    std::list<SPCurve *> white_curves;
+    std::vector<SPDrawAnchor*> white_anchors;
 
     // Alternative curve to use on continuing the exisiting curve in case of
     // bspline or spirolive, because using anchor curves gives random memory
diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp
index 0db5c3954..f8dfd7a10 100644
--- a/src/ui/tools/pen-tool.cpp
+++ b/src/ui/tools/pen-tool.cpp
@@ -860,18 +860,18 @@ bool PenTool::_handle2ButtonPress(GdkEventButton const &bevent) {
 
 void PenTool::_redrawAll() {
     // green
-    if (this->green_bpaths) {
+    if (! this->green_bpaths.empty()) {
         // remove old piecewise green canvasitems
-        while (this->green_bpaths) {
-            sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-            this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+        for (auto i : this->green_bpaths){
+            sp_canvas_item_destroy(i);
         }
+        this->green_bpaths.clear();
         // one canvas bpath for all of green_curve
         SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve, true);
         sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
         sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO);
 
-        this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
+        this->green_bpaths.push_back(canvas_shape);
     }
     if (this->green_anchor) {
         SP_CTRL(this->green_anchor->ctrl)->moveto(this->green_anchor->dp);
@@ -1253,10 +1253,10 @@ void PenTool::_resetColors() {
     this->blue_curve->reset();
     sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), NULL, true);
     // Green
-    while (this->green_bpaths) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-        this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+    for (auto i:this->green_bpaths) {
+        sp_canvas_item_destroy(i);
     }
+    this->green_bpaths.clear();
     this->green_curve->reset();
     if (this->green_anchor) {
         this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
@@ -1332,17 +1332,17 @@ void PenTool::_bsplineSpiroColor()
     }
     //We erase all the "green_bpaths" to recreate them after with the colour
     //transparency recently modified
-    if (this->green_bpaths) {
+    if (!this->green_bpaths.empty()) {
         // remove old piecewise green canvasitems
-        while (this->green_bpaths) {
-            sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-            this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+        for (auto i:this->green_bpaths) {
+            sp_canvas_item_destroy(i);
         }
+        this->green_bpaths.clear();
         // one canvas bpath for all of green_curve
         SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve, true);
         sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
         sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO);
-        this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
+        this->green_bpaths.push_back(canvas_shape);
     }
     sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(this->red_bpath), this->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 }
@@ -1555,18 +1555,18 @@ void PenTool::_bsplineSpiroMotion(guint const state){
                     this->overwrite_curve = tmp_curve->copy();
                 }
             }
-            if (this->green_bpaths) {
+            if (!this->green_bpaths.empty()) {
                 this->green_curve = tmp_curve->copy();
                 // remove old piecewise green canvasitems
-                while (this->green_bpaths) {
-                    sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-                    this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+                for (auto i: this->green_bpaths) {
+                    sp_canvas_item_destroy(i);
                 }
+                this->green_bpaths.clear();
                 // one canvas bpath for all of green_curve
                 SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve, true);
                 sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
                 sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO);
-                this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
+                this->green_bpaths.push_back(canvas_shape);
             }
         }
         if (cubic) {
@@ -1927,7 +1927,7 @@ void PenTool::_finishSegment(Geom::Point const p, guint const state) {
         curve->unref();
         sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 
-        this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
+        this->green_bpaths.push_back(canvas_shape);
 
         this->p[0] = this->p[3];
         this->p[1] = this->p[4];
@@ -1953,11 +1953,9 @@ bool PenTool::_undoLastPoint() {
         // Reset red curve
         this->red_curve->reset();
         // Destroy topmost green bpath
-        if (this->green_bpaths) {
-            if (this->green_bpaths->data) {
-                sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-            }
-            this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+        if (!this->green_bpaths.empty()) {
+            sp_canvas_item_destroy(this->green_bpaths.back());
+            this->green_bpaths.pop_back();
         }
         // Get last segment
         if ( this->green_curve->is_unset() ) {
@@ -1985,11 +1983,9 @@ bool PenTool::_undoLastPoint() {
         // delete the last segment of the green curve
         if (this->green_curve->get_segment_count() == 1) {
             this->npoints = 5;
-            if (this->green_bpaths) {
-                if (this->green_bpaths->data) {
-                    sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-                }
-                this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+            if (!this->green_bpaths.empty()) {
+                sp_canvas_item_destroy(this->green_bpaths.back());
+                this->green_bpaths.pop_back();
             }
             this->green_curve->reset();
         } else {
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index 99b8103c3..61799b306 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -437,10 +437,10 @@ void PencilTool::_cancel() {
 
     this->red_curve->reset();
     sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
-    while (this->green_bpaths) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
-        this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+    for (auto i:this->green_bpaths) {
+        sp_canvas_item_destroy(i);
     }
+    this->green_bpaths.clear();
     this->green_curve->reset();
     if (this->green_anchor) {
         this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
@@ -858,7 +858,7 @@ void PencilTool::_fitAndSplit() {
         }
         sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 
-        this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
+        this->green_bpaths.push_back(cshape);
 
         this->red_curve_is_valid = false;
     }