Removed all GSList occurences in .h files

17 files changed, 181 insertions, 239 deletions

diff --git a/src/ui/dialog/spellcheck.cpp b/src/ui/dialog/spellcheck.cpp
index 4f7657f4f..3318b5e6b 100644
--- a/src/ui/dialog/spellcheck.cpp
+++ b/src/ui/dialog/spellcheck.cpp
@@ -50,8 +50,6 @@ namespace Dialog {
 
 SpellCheck::SpellCheck (void) :
     UI::Widget::Panel ("", "/dialogs/spellcheck/", SP_VERB_DIALOG_SPELLCHECK),
-    _rects(NULL),
-    _seen_objects(NULL),
     _text(NULL),
     _layout(NULL),
     _stops(0),
@@ -196,12 +194,11 @@ void SpellCheck::setTargetDesktop(SPDesktop *desktop)
 
 void SpellCheck::clearRects()
 {
-    for (GSList *it = _rects; it; it = it->next) {
-        sp_canvas_item_hide(SP_CANVAS_ITEM(it->data));
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(it->data));
+    for(auto t : _rects) {
+        sp_canvas_item_hide(t);
+        sp_canvas_item_destroy(t);
     }
-    g_slist_free(_rects);
-    _rects = NULL;
+    _rects.clear();
 }
 
 void SpellCheck::disconnect()
@@ -214,47 +211,39 @@ void SpellCheck::disconnect()
     }
 }
 
-GSList *SpellCheck::allTextItems (SPObject *r, GSList *l, bool hidden, bool locked)
+void SpellCheck::allTextItems (SPObject *r, std::vector<SPItem *> &l, bool hidden, bool locked)
 {
     if (!desktop)
-        return l; // no desktop to check
+        return; // no desktop to check
 
     if (SP_IS_DEFS(r))
-        return l; // we're not interested in items in defs
+        return; // we're not interested in items in defs
 
     if (!strcmp(r->getRepr()->name(), "svg:metadata")) {
-        return l; // we're not interested in metadata
+        return; // we're not interested in metadata
     }
 
     for (auto& child: r->children) {
         if (SP_IS_ITEM (&child) && !child.cloned && !desktop->isLayer(SP_ITEM(&child))) {
                 if ((hidden || !desktop->itemIsHidden(SP_ITEM(&child))) && (locked || !SP_ITEM(&child)->isLocked())) {
                     if (SP_IS_TEXT(&child) || SP_IS_FLOWTEXT(&child))
-                        l = g_slist_prepend (l, &child);
+                        l.push_back(static_cast<SPItem*>(&child));
                 }
         }
-        l = allTextItems (&child, l, hidden, locked);
+        allTextItems (&child, l, hidden, locked);
     }
-    return l;
+    return;
 }
 
 bool
 SpellCheck::textIsValid (SPObject *root, SPItem *text)
 {
-    GSList *l = NULL;
-    l = allTextItems (root, l, false, true);
-    for (GSList *i = l; i; i = i->next) {
-        SPItem *item = static_cast<SPItem *>(i->data);
-        if (item == text) {
-            g_slist_free (l);
-            return true;
-        }
-    }
-    g_slist_free (l);
-    return false;
+    std::vector<SPItem*> l;
+    allTextItems (root, l, false, true);
+    return (std::find(l.begin(), l.end(), text) != l.end());
 }
 
-gint SpellCheck::compareTextBboxes (gconstpointer a, gconstpointer b)
+bool SpellCheck::compareTextBboxes (gconstpointer a, gconstpointer b)//returns a<b
 {
     SPItem *i1 = SP_ITEM(a);
     SPItem *i2 = SP_ITEM(b);
@@ -262,41 +251,28 @@ gint SpellCheck::compareTextBboxes (gconstpointer a, gconstpointer b)
     Geom::OptRect bbox1 = i1->desktopVisualBounds();
     Geom::OptRect bbox2 = i2->desktopVisualBounds();
     if (!bbox1 || !bbox2) {
-        return 0;
+        return false;
     }
 
     // vector between top left corners
     Geom::Point diff = Geom::Point(bbox2->min()[Geom::X], bbox2->max()[Geom::Y]) -
                        Geom::Point(bbox1->min()[Geom::X], bbox1->max()[Geom::Y]);
 
-    // sort top to bottom, left to right, but:
-    // if i2 is higher only 0.2 or less times it is righter than i1, put i1 first
-    if (diff[Geom::Y] > 0.2 * diff[Geom::X])
-        return 1;
-    else
-        return -1;
-
-    return 0;
+    return diff[Geom::Y] == 0 ? (diff[Geom::X] < 0) : (diff[Geom::Y] < 0);
 }
 
 // We regenerate and resort the list every time, because user could have changed it while the
 // dialog was waiting
 SPItem *SpellCheck::getText (SPObject *root)
 {
-    GSList *l = NULL;
-    l = allTextItems (root, l, false, true);
-    l = g_slist_sort(l, (GCompareFunc)SpellCheck::compareTextBboxes);
-
-    for (GSList *i = l; i; i = i->next) {
-        SPItem *item = static_cast<SPItem *>(i->data);
-        if (!g_slist_find (_seen_objects, item)) {
-            _seen_objects = g_slist_prepend(_seen_objects, item);
-            g_slist_free(l);
+    std::vector<SPItem*> l;
+    allTextItems (root, l, false, true);
+    std::sort(l.begin(),l.end(),SpellCheck::compareTextBboxes);
+
+    for (auto item:l) {
+        if(_seen_objects.insert(item).second)
             return item;
-        }
     }
-
-    g_slist_free(l);
     return NULL;
 }
 
@@ -402,8 +378,7 @@ SpellCheck::init(SPDesktop *d)
     _root = desktop->getDocument()->getRoot();
 
     // empty the list of objects we've checked
-    g_slist_free (_seen_objects);
-    _seen_objects = NULL;
+    _seen_objects.clear();
 
     // grab first text
     nextText();
@@ -456,8 +431,7 @@ SpellCheck::finished ()
         g_free(label);
     }
 
-    g_slist_free(_seen_objects);
-    _seen_objects = NULL;
+    _seen_objects.clear();
 
     desktop = NULL;
     _root = NULL;
@@ -615,7 +589,7 @@ SpellCheck::nextWord()
             curve->lineto(area.corner(0));
             sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(rect), curve);
             sp_canvas_item_show(rect);
-            _rects = g_slist_prepend(_rects, rect);
+            _rects.push_back(rect);
 
             // scroll to make it all visible
             Geom::Point const center = desktop->get_display_area().midpoint();
@@ -707,10 +681,10 @@ SpellCheck::nextWord()
 void
 SpellCheck::deleteLastRect ()
 {
-    if (_rects) {
-        sp_canvas_item_hide(SP_CANVAS_ITEM(_rects->data));
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(_rects->data));
-        _rects = _rects->next; // pop latest-prepended rect
+    if (!_rects.empty()) {
+        sp_canvas_item_hide(_rects.back());
+        sp_canvas_item_destroy(_rects.back());
+        _rects.pop_back(); // pop latest-prepended rect
     }
 }
 
@@ -861,7 +835,6 @@ SpellCheck::onStart ()
 }
 }
 
-
 /*
   Local Variables:
   mode:c++
diff --git a/src/ui/dialog/spellcheck.h b/src/ui/dialog/spellcheck.h
index 834f23c24..e7563ad1e 100644
--- a/src/ui/dialog/spellcheck.h
+++ b/src/ui/dialog/spellcheck.h
@@ -16,6 +16,9 @@
 # include <config.h>
 #endif
 
+#include <vector>
+#include <set>
+
 #include <gtkmm/box.h>
 #include <gtkmm/button.h>
 #include <gtkmm/buttonbox.h>
@@ -68,7 +71,7 @@ private:
     /**
      * Returns a list of all the text items in the SPObject
      */
-    GSList *allTextItems (SPObject *r, GSList *l, bool hidden, bool locked);
+    void allTextItems (SPObject *r, std::vector<SPItem *> &l, bool hidden, bool locked);
 
     /**
      * Is text inside the SPOject's tree
@@ -78,7 +81,7 @@ private:
     /**
      * Compare the visual bounds of 2 SPItems referred to by a and b
      */
-    static gint compareTextBboxes (gconstpointer a, gconstpointer b);
+    static bool compareTextBboxes (gconstpointer a, gconstpointer b);
     SPItem *getText (SPObject *root);
     void    nextText ();
 
@@ -165,12 +168,12 @@ private:
     /**
      * list of canvasitems (currently just rects) that mark misspelled things on canvas
      */
-    GSList *_rects;
+    std::vector<SPCanvasItem *> _rects;
 
     /**
      * list of text objects we have already checked in this session
      */
-    GSList *_seen_objects;
+    std::set<SPItem *> _seen_objects;
 
     /**
      *  the object currently being checked
diff --git a/src/ui/dialog/symbols.cpp b/src/ui/dialog/symbols.cpp
index b876fa98c..558b0b19e 100644
--- a/src/ui/dialog/symbols.cpp
+++ b/src/ui/dialog/symbols.cpp
@@ -617,52 +617,48 @@ void SymbolsDialog::get_symbols() {
     }
 }
 
-GSList* SymbolsDialog::symbols_in_doc_recursive (SPObject *r, GSList *l)
+void SymbolsDialog::symbols_in_doc_recursive (SPObject *r, std::vector<SPSymbol*> &l)
 {
-  g_return_val_if_fail(r != NULL, l);
+  if(!r) return;
 
   // Stop multiple counting of same symbol
   if ( dynamic_cast<SPUse *>(r) ) {
-    return l;
+    return;
   }
 
   if ( dynamic_cast<SPSymbol *>(r) ) {
-    l = g_slist_prepend (l, r);
+    l.push_back(dynamic_cast<SPSymbol *>(r));
   }
 
   for (auto& child: r->children) {
-    l = symbols_in_doc_recursive( &child, l );
+    symbols_in_doc_recursive( &child, l );
   }
-
-  return l;
 }
 
-GSList* SymbolsDialog::symbols_in_doc( SPDocument* symbolDocument ) {
+std::vector<SPSymbol*> SymbolsDialog::symbols_in_doc( SPDocument* symbolDocument )
+{
 
-  GSList *l = NULL;
-  l = symbols_in_doc_recursive (symbolDocument->getRoot(), l );
-  l = g_slist_reverse( l );
+  std::vector<SPSymbol*> l;
+  symbols_in_doc_recursive (symbolDocument->getRoot(), l );
   return l;
 }
 
-GSList* SymbolsDialog::use_in_doc_recursive (SPObject *r, GSList *l)
+void SymbolsDialog::use_in_doc_recursive (SPObject *r, std::vector<SPUse*> &l)
 {
 
   if ( dynamic_cast<SPUse *>(r) ) {
-    l = g_slist_prepend (l, r);
+    l.push_back(dynamic_cast<SPUse *>(r));
   }
 
   for (auto& child: r->children) {
-    l = use_in_doc_recursive( &child, l );
+    use_in_doc_recursive( &child, l );
   }
-
-  return l;
 }
 
-GSList* SymbolsDialog::use_in_doc( SPDocument* useDocument ) {
+std::vector<SPUse*> SymbolsDialog::use_in_doc( SPDocument* useDocument ) {
 
-  GSList *l = NULL;
-  l = use_in_doc_recursive (useDocument->getRoot(), l );
+  std::vector<SPUse*> l;
+  use_in_doc_recursive (useDocument->getRoot(), l);
   return l;
 }
 
@@ -671,10 +667,8 @@ GSList* SymbolsDialog::use_in_doc( SPDocument* useDocument ) {
 gchar const* SymbolsDialog::style_from_use( gchar const* id, SPDocument* document) {
 
   gchar const* style = 0;
-  GSList* l = use_in_doc( document );
-  for( ; l != NULL; l = l->next ) {
-    SPObject *obj = reinterpret_cast<SPObject *>(l->data);
-    SPUse *use = dynamic_cast<SPUse *>(obj);
+  std::vector<SPUse*> l = use_in_doc( document );
+  for( auto use:l ) {
     if ( use ) {
       gchar const *href = use->getRepr()->attribute("xlink:href");
       if( href ) {
@@ -693,10 +687,8 @@ gchar const* SymbolsDialog::style_from_use( gchar const* id, SPDocument* documen
 
 void SymbolsDialog::add_symbols( SPDocument* symbolDocument ) {
 
-  GSList* l = symbols_in_doc( symbolDocument );
-  for( ; l != NULL; l = l->next ) {
-    SPObject *obj = reinterpret_cast<SPObject *>(l->data);
-    SPSymbol *symbol = dynamic_cast<SPSymbol *>(obj);
+  std::vector<SPSymbol*> l = symbols_in_doc( symbolDocument );
+  for(auto symbol:l) {
     if (symbol) {
       add_symbol( symbol );
     }
diff --git a/src/ui/dialog/symbols.h b/src/ui/dialog/symbols.h
index 5dc1e3cad..747e5c6c9 100644
--- a/src/ui/dialog/symbols.h
+++ b/src/ui/dialog/symbols.h
@@ -14,10 +14,10 @@
 #define INKSCAPE_UI_DIALOG_SYMBOLS_H
 
 #include "display/drawing.h"
-
 #include "ui/dialog/desktop-tracker.h"
-
 #include "ui/widget/panel.h"
+#include "sp-symbol.h"
+#include "sp-use.h"
 
 #include <vector>
 
@@ -85,10 +85,10 @@ private:
     void add_symbol( SPObject* symbol_document );
     SPDocument* symbols_preview_doc();
 
-    GSList* symbols_in_doc_recursive(SPObject *r, GSList *l);
-    GSList* symbols_in_doc( SPDocument* document );
-    GSList* use_in_doc_recursive(SPObject *r, GSList *l);
-    GSList* use_in_doc( SPDocument* document );
+    void symbols_in_doc_recursive(SPObject *r, std::vector<SPSymbol*> &l);
+    std::vector<SPSymbol*> symbols_in_doc( SPDocument* document );
+    void use_in_doc_recursive(SPObject *r, std::vector<SPUse*> &l);
+    std::vector<SPUse*> use_in_doc( SPDocument* document );
     gchar const* style_from_use( gchar const* id, SPDocument* document);
 
     Glib::RefPtr<Gdk::Pixbuf> draw_symbol(SPObject *symbol);
diff --git a/src/ui/tool/manipulator.h b/src/ui/tool/manipulator.h
index 07e01a656..0f26c6de1 100644
--- a/src/ui/tool/manipulator.h
+++ b/src/ui/tool/manipulator.h
@@ -98,16 +98,17 @@ public:
     bool empty() {
         return _mmap.empty();
     }
-    void setItems(GSList const *list) {
+    
+    void setItems(std::vector<gpointer> list) { // this function is not called anywhere ... delete ?
         std::set<void*> to_remove;
         for (typename MapType::iterator mi = _mmap.begin(); mi != _mmap.end(); ++mi) {
             to_remove.insert(mi->first);
         }
-        for (GSList *i = const_cast<GSList*>(list); i; i = i->next) {
-            if (_isItemType(i->data)) {
+        for (auto i:list) {
+            if (_isItemType(i)) {
                 // erase returns the number of items removed
                 // if nothing was removed, it means this item did not have a manipulator - add it
-                if (!to_remove.erase(i->data)) addItem(i->data);
+                if (!to_remove.erase(i)) addItem(i);
             }
         }
         typedef typename std::set<void*>::iterator RmIter;
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;
     }
diff --git a/src/ui/widget/selected-style.cpp b/src/ui/widget/selected-style.cpp
index 68acddfcc..5d911e9d2 100644
--- a/src/ui/widget/selected-style.cpp
+++ b/src/ui/widget/selected-style.cpp
@@ -139,7 +139,6 @@ SelectedStyle::SelectedStyle(bool /*layout*/)
 
       _opacity_blocked (false),
 
-      _unit_mis(NULL),
       _sw_unit(NULL)
 {
     set_name("SelectedStyle");
@@ -336,7 +335,7 @@ SelectedStyle::SelectedStyle(bool /*layout*/)
         while(iter != m.end()) {
             Gtk::RadioMenuItem *mi = Gtk::manage(new Gtk::RadioMenuItem(_sw_group));
             mi->add(*(new Gtk::Label(iter->first, Gtk::ALIGN_START)));
-            _unit_mis = g_slist_append(_unit_mis, mi);
+            _unit_mis.push_back(mi);
             Inkscape::Util::Unit const *u = unit_table.getUnit(iter->first);
             mi->signal_activate().connect(sigc::bind<Inkscape::Util::Unit const *>(sigc::mem_fun(*this, &SelectedStyle::on_popup_units), u));
             _popup_sw.attach(*mi, 0,1, row, row+1);
@@ -449,6 +448,7 @@ SelectedStyle::~SelectedStyle()
     delete selection_modified_connection;
     subselection_changed_connection->disconnect();
     delete subselection_changed_connection;
+    _unit_mis.clear();
 
     for (int i = SS_FILL; i <= SS_STROKE; i++) {
         delete _color_preview[i];
@@ -488,9 +488,7 @@ SelectedStyle::setDesktop(SPDesktop *desktop)
     _sw_unit = desktop->getNamedView()->display_units;
 
     // Set the doc default unit active in the units list
-    gint length = g_slist_length(_unit_mis);
-    for (int i = 0; i < length; i++) {
-        Gtk::RadioMenuItem *mi = (Gtk::RadioMenuItem *) g_slist_nth_data(_unit_mis, i);
+    for ( auto mi:_unit_mis ) {
         if (mi && mi->get_label() == _sw_unit->abbr) {
             mi->set_active();
             break;
diff --git a/src/ui/widget/selected-style.h b/src/ui/widget/selected-style.h
index 065d745f0..b7f3d5dda 100644
--- a/src/ui/widget/selected-style.h
+++ b/src/ui/widget/selected-style.h
@@ -267,7 +267,7 @@ protected:
 
     Gtk::Menu _popup_sw; 
     Gtk::RadioButtonGroup _sw_group;
-    GSList *_unit_mis;
+    std::vector<Gtk::RadioMenuItem*> _unit_mis;
     void on_popup_units(Inkscape::Util::Unit const *u);
     void on_popup_preset(int i);
     Gtk::MenuItem _popup_sw_remove;
diff --git a/src/ui/widget/unit-tracker.cpp b/src/ui/widget/unit-tracker.cpp
index a1501c229..d36220b74 100644
--- a/src/ui/widget/unit-tracker.cpp
+++ b/src/ui/widget/unit-tracker.cpp
@@ -14,7 +14,7 @@
 
 #include "style-internal.h"
 #include "unit-tracker.h"
-#include "widgets/ege-select-one-action.h"
+//#include "widgets/ege-select-one-action.h"
 
 #define COLUMN_STRING 0
 
@@ -31,9 +31,6 @@ UnitTracker::UnitTracker(UnitType unit_type) :
     _activeUnit(NULL),
     _activeUnitInitialized(false),
     _store(0),
-    _unitList(0),
-    _actionList(0),
-    _adjList(0),
     _priorValues()
 {
     _store = gtk_list_store_new(1, G_TYPE_STRING);
@@ -58,17 +55,17 @@ UnitTracker::UnitTracker(UnitType unit_type) :
 UnitTracker::~UnitTracker()
 {
     // Unhook weak references to GtkActions
-    while (_actionList) {
-        g_signal_handlers_disconnect_by_func(G_OBJECT(_actionList->data), (gpointer) _unitChangedCB, this);
-        g_object_weak_unref(G_OBJECT(_actionList->data), _actionFinalizedCB, this);
-        _actionList = g_slist_delete_link(_actionList, _actionList);
+    for (auto i : _actionList) {
+        g_signal_handlers_disconnect_by_func(G_OBJECT(i), (gpointer) _unitChangedCB, this);
+        g_object_weak_unref(G_OBJECT(i), _actionFinalizedCB, this);
     }
+    _actionList.clear();
 
     // Unhook weak references to GtkAdjustments
-    while (_adjList) {
-        g_object_weak_unref(G_OBJECT(_adjList->data), _adjustmentFinalizedCB, this);
-        _adjList = g_slist_delete_link(_adjList, _adjList);
+    for (auto i : _adjList) {
+        g_object_weak_unref(G_OBJECT(i), _adjustmentFinalizedCB, this);
     }
+    _adjList.clear();
 }
 
 bool UnitTracker::isUpdating() const
@@ -109,9 +106,9 @@ void UnitTracker::setActiveUnitByAbbr(gchar const *abbr)
 
 void UnitTracker::addAdjustment(GtkAdjustment *adj)
 {
-    if (!g_slist_find(_adjList, adj)) {
+    if (std::find(_adjList.begin(),_adjList.end(),adj)!=_adjList.end()) {
         g_object_weak_ref(G_OBJECT(adj), _adjustmentFinalizedCB, this);
-        _adjList = g_slist_append(_adjList, adj);
+        _adjList.push_back(adj);
     }
 }
 
@@ -147,7 +144,7 @@ GtkAction *UnitTracker::createAction(gchar const *name, gchar const *label, gcha
     ege_select_one_action_set_appearance(act1, "minimal");
     g_object_weak_ref(G_OBJECT(act1), _actionFinalizedCB, this);
     g_signal_connect(G_OBJECT(act1), "changed", G_CALLBACK(_unitChangedCB), this);
-    _actionList = g_slist_append(_actionList, act1);
+    _actionList.push_back(act1);
 
     return GTK_ACTION(act1);
 }
@@ -180,9 +177,10 @@ void UnitTracker::_adjustmentFinalizedCB(gpointer data, GObject *where_the_objec
 
 void UnitTracker::_actionFinalized(GObject *where_the_object_was)
 {
-    GSList *target = g_slist_find(_actionList, where_the_object_was);
-    if (target) {
-        _actionList = g_slist_remove(_actionList, where_the_object_was);
+    EgeSelectOneAction* act = (EgeSelectOneAction*)(where_the_object_was);
+    auto it = std::find(_actionList.begin(),_actionList.end(), act);
+    if (it != _actionList.end()) {
+        _actionList.erase(it);
     } else {
         g_warning("Received a finalization callback for unknown object %p", where_the_object_was);
     }
@@ -190,9 +188,10 @@ void UnitTracker::_actionFinalized(GObject *where_the_object_was)
 
 void UnitTracker::_adjustmentFinalized(GObject *where_the_object_was)
 {
-    GSList *target = g_slist_find(_adjList, where_the_object_was);
-    if (target) {
-        _adjList = g_slist_remove(_adjList, where_the_object_was);
+    GtkAdjustment* adj = (GtkAdjustment*)(where_the_object_was);
+    auto it = std::find(_adjList.begin(),_adjList.end(), adj);
+    if (it != _adjList.end()) {
+        _adjList.erase(it);
     } else {
         g_warning("Received a finalization callback for unknown object %p", where_the_object_was);
     }
@@ -217,7 +216,7 @@ void UnitTracker::_setActive(gint active)
                 Inkscape::Util::Unit const *newUnit = unit_table.getUnit(newAbbr);
                 _activeUnit = newUnit;
 
-                if (_adjList) {
+                if (!_adjList.empty()) {
                     _fixupAdjustments(unit, newUnit);
                 }
 
@@ -230,11 +229,8 @@ void UnitTracker::_setActive(gint active)
 
         _active = active;
 
-        for ( GSList *cur = _actionList ; cur ; cur = g_slist_next(cur) ) {
-            if (IS_EGE_SELECT_ONE_ACTION(cur->data)) {
-                EgeSelectOneAction *act = EGE_SELECT_ONE_ACTION(cur->data);
-                ege_select_one_action_set_active(act, active);
-            }
+        for (auto act:_actionList) {
+            ege_select_one_action_set_active(act, active);
         }
         
         _activeUnitInitialized = true;
@@ -244,8 +240,7 @@ void UnitTracker::_setActive(gint active)
 void UnitTracker::_fixupAdjustments(Inkscape::Util::Unit const *oldUnit, Inkscape::Util::Unit const *newUnit)
 {
     _isUpdating = true;
-    for ( GSList *cur = _adjList ; cur ; cur = g_slist_next(cur) ) {
-        GtkAdjustment *adj = GTK_ADJUSTMENT(cur->data);
+    for ( auto adj : _adjList ) {
         gdouble oldVal = gtk_adjustment_get_value(adj);
         gdouble val = oldVal;
 
diff --git a/src/ui/widget/unit-tracker.h b/src/ui/widget/unit-tracker.h
index 8fa9ff304..643ac4e51 100644
--- a/src/ui/widget/unit-tracker.h
+++ b/src/ui/widget/unit-tracker.h
@@ -17,6 +17,7 @@
 
 #include <map>
 #include "util/units.h"
+#include "widgets/ege-select-one-action.h"
 
 using Inkscape::Util::Unit;
 using Inkscape::Util::UnitType;
@@ -65,9 +66,8 @@ private:
     Inkscape::Util::Unit const *_activeUnit;
     bool _activeUnitInitialized;
     GtkListStore *_store;
-    GSList *_unitList;
-    GSList *_actionList;
-    GSList *_adjList;
+    std::vector<EgeSelectOneAction*> _actionList;
+    std::vector<GtkAdjustment*> _adjList;
     std::map <GtkAdjustment *, gdouble> _priorValues;
 };