third batch

12 files changed, 121 insertions, 214 deletions

diff --git a/src/ege-color-prof-tracker.cpp b/src/ege-color-prof-tracker.cpp
index 3a91fee4d..8401b2cc3 100644
--- a/src/ege-color-prof-tracker.cpp
+++ b/src/ege-color-prof-tracker.cpp
@@ -40,6 +40,8 @@
 /* Note: this file should be kept compilable as both .cpp and .c */
 
 #include <string.h>
+#include <vector>
+#include <algorithm>
 
 #include <gtk/gtk.h>
 
@@ -63,14 +65,17 @@ enum {
 static void ege_color_prof_tracker_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
 static void ege_color_prof_tracker_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
 
-typedef struct _ScreenTrack {
+class ScreenTrack {
+    public:
 #ifdef GDK_WINDOWING_X11
     gboolean zeroSeen;
     gboolean otherSeen;
 #endif /* GDK_WINDOWING_X11 */
-    GSList* trackers;
+    std::vector<EgeColorProfTracker *> *trackers;
     GPtrArray* profiles;
-} ScreenTrack;
+    ~ScreenTrack(){ delete trackers; }
+};
+
 
 #ifdef GDK_WINDOWING_X11
 GdkFilterReturn x11_win_filter(GdkXEvent *xevent, GdkEvent *event, gpointer data);
@@ -86,7 +91,7 @@ static guint signals[LAST_SIGNAL] = {0};
 // There is only one GdkScreen in Gtk+ 3
 static ScreenTrack *tracked_screen = nullptr;
 
-static GSList* abstract_trackers = 0;
+static std::vector<EgeColorProfTracker *> abstract_trackers;
 
 struct _EgeColorProfTrackerPrivate
 {
@@ -182,7 +187,7 @@ EgeColorProfTracker* ege_color_prof_tracker_new( GtkWidget* target )
         target_hierarchy_changed_cb( target, 0, obj );
         target_screen_changed_cb( target, 0, obj );
     } else {
-        abstract_trackers = g_slist_append( abstract_trackers, obj );
+        abstract_trackers.push_back(tracker);
 
         if(tracked_screen) {
             for ( gint monitor = 0; monitor < (gint)tracked_screen->profiles->len; monitor++ ) {
@@ -280,9 +285,8 @@ void track_screen( GdkScreen* screen, EgeColorProfTracker* tracker )
 {
     if ( tracked_screen ) {
         /* We found the screen already being tracked */
-        GSList* trackHook = g_slist_find( tracked_screen->trackers, tracker );
-        if ( !trackHook ) {
-            tracked_screen->trackers = g_slist_append( tracked_screen->trackers, tracker );
+        if ( std::find(tracked_screen->trackers->begin(),tracked_screen->trackers->end(),tracker)==tracked_screen->trackers->end() ) {
+            tracked_screen->trackers->push_back(tracker);
         }
     } else {
         tracked_screen = g_new(ScreenTrack, 1);
@@ -299,7 +303,8 @@ void track_screen( GdkScreen* screen, EgeColorProfTracker* tracker )
         tracked_screen->zeroSeen = FALSE;
         tracked_screen->otherSeen = FALSE;
 #endif /* GDK_WINDOWING_X11 */
-        tracked_screen->trackers = g_slist_append( 0, tracker );
+        tracked_screen->trackers= new std::vector<EgeColorProfTracker *>;
+        tracked_screen->trackers->push_back(tracker );
         tracked_screen->profiles = g_ptr_array_new();
         for ( int i = 0; i < numMonitors; i++ ) {
             g_ptr_array_add( tracked_screen->profiles, 0 );
@@ -323,15 +328,12 @@ void target_finalized( gpointer data, GObject* where_the_object_was )
 {
     (void)data;
     if ( tracked_screen ) {
-        GSList* trackHook = tracked_screen->trackers;
-        while ( trackHook ) {
-            if ( (void*)(((EgeColorProfTracker*)(trackHook->data))->private_data->_target) == (void*)where_the_object_was ) {
+        for (auto i = tracked_screen->trackers->begin(); i != tracked_screen->trackers->end(); ++i) {
+            if ( (void*)((*i)->private_data->_target) == (void*)where_the_object_was ) {
                 /* The tracked widget is now gone, remove it */
-                ((EgeColorProfTracker*)trackHook->data)->private_data->_target = 0;
-                tracked_screen->trackers = g_slist_remove( tracked_screen->trackers, trackHook );
-                trackHook = 0;
-            } else {
-                trackHook = g_slist_next( trackHook );
+                (*i)->private_data->_target = 0;
+                tracked_screen->trackers->erase(i);
+                break;
             }
         }
     }
@@ -578,14 +580,10 @@ void add_x11_tracking_for_screen(GdkScreen* screen)
 void fire(gint monitor)
 {
     if ( tracked_screen ) {
-        GSList* trackHook = tracked_screen->trackers;
-
-        while ( trackHook ) {
-            EgeColorProfTracker* tracker = (EgeColorProfTracker*)(trackHook->data);
+        for (auto tracker:(*(tracked_screen->trackers))) {
             if ( (monitor == -1) || (tracker->private_data->_monitor == monitor) ) {
                 g_signal_emit( G_OBJECT(tracker), signals[CHANGED], 0 );
             }
-            trackHook = g_slist_next(trackHook);
         }
     }
 }
@@ -609,8 +607,6 @@ static void clear_profile( guint monitor )
 static void set_profile( guint monitor, const guint8* data, guint len )
 {
     if ( tracked_screen ) {
-        GSList* abstracts = 0;
-
         for ( guint i = tracked_screen->profiles->len; i <= monitor; i++ ) {
             g_ptr_array_add( tracked_screen->profiles, 0 );
         }
@@ -627,8 +623,8 @@ static void set_profile( guint monitor, const guint8* data, guint len )
             tracked_screen->profiles->pdata[monitor] = 0;
         }
 
-        for ( abstracts = abstract_trackers; abstracts; abstracts = g_slist_next(abstracts) ) {
-            g_signal_emit( G_OBJECT(abstracts->data), signals[MODIFIED], 0, monitor );
+        for (auto i:abstract_trackers) {
+            g_signal_emit( G_OBJECT(i), signals[MODIFIED], 0, monitor );
         }
     }
 }
diff --git a/src/extension/init.cpp b/src/extension/init.cpp
index 9830b0176..699c0382f 100644
--- a/src/extension/init.cpp
+++ b/src/extension/init.cpp
@@ -130,20 +130,9 @@ static void check_extensions();
  */
 static void
 update_pref(Glib::ustring const &pref_path,
-            gchar const *pref_default) // , GSList *extension_family)
+            gchar const *pref_default) 
 {
     Glib::ustring pref = Inkscape::Preferences::get()->getString(pref_path);
-    /*
-    gboolean missing=TRUE;
-    for (GSList *list = extension_family; list; list = g_slist_next(list)) {
-        g_assert( list->data );
-
-        Inkscape::Extension *extension;
-        extension = reinterpret_cast<Inkscape::Extension *>(list->data);
-
-        if (!strcmp(extension->get_id(),pref)) missing=FALSE;
-    }
-    */
     if (!Inkscape::Extension::db.get( pref.data() ) /*missing*/) {
         Inkscape::Preferences::get()->setString(pref_path, pref_default);
     }
diff --git a/src/extension/internal/gdkpixbuf-input.cpp b/src/extension/internal/gdkpixbuf-input.cpp
index e0dc90981..7af7927f2 100644
--- a/src/extension/internal/gdkpixbuf-input.cpp
+++ b/src/extension/internal/gdkpixbuf-input.cpp
@@ -1,4 +1,6 @@
 #include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/pixbufformat.h>
 
 #include <boost/scoped_ptr.hpp>
 #include <glib/gprintf.h>
@@ -163,14 +165,9 @@ GdkpixbufInput::open(Inkscape::Extension::Input *mod, char const *uri)
 void
 GdkpixbufInput::init(void)
 {
-    GSList * formatlist, * formatlisthead;
-
-    /* \todo I'm not sure if I need to free this list */
-    for (formatlist = formatlisthead = gdk_pixbuf_get_formats();
-         formatlist != NULL;
-         formatlist = g_slist_next(formatlist)) {
-
-        GdkPixbufFormat *pixformat = (GdkPixbufFormat *)formatlist->data;
+    static std::vector< Gdk::PixbufFormat > formatlist = Gdk::Pixbuf::get_formats();
+    for (auto i: formatlist) {
+        GdkPixbufFormat *pixformat = i.gobj();
 
         gchar *name =        gdk_pixbuf_format_get_name(pixformat);
         gchar *description = gdk_pixbuf_format_get_description(pixformat);
@@ -240,8 +237,6 @@ GdkpixbufInput::init(void)
         g_strfreev(mimetypes);
         g_strfreev(extensions);
     }
-
-    g_slist_free(formatlisthead);
 }
 
 } } }  /* namespace Inkscape, Extension, Implementation */
diff --git a/src/gradient-drag.cpp b/src/gradient-drag.cpp
index 103a3df9c..2af665ec5 100644
--- a/src/gradient-drag.cpp
+++ b/src/gradient-drag.cpp
@@ -2875,8 +2875,9 @@ void GrDrag::deleteSelected(bool just_one)
         SPGradient * vector;
     };
 
-    GSList *midstoplist = NULL;  // list of stops that must be deleted (will be deleted first)
-    GSList *endstoplist = NULL;  // list of stops that must be deleted
+    std::vector<SPStop *> midstoplist;// list of stops that must be deleted (will be deleted first)
+    std::vector<StructStopInfo *> endstoplist;// list of stops that must be deleted
+
     while (!selected.empty()) {
         GrDragger *dragger = *(selected.begin());
         for(std::vector<GrDraggable *>::const_iterator drgble = dragger->draggables.begin(); drgble != dragger->draggables.end(); ++drgble) {
@@ -2892,14 +2893,14 @@ void GrDrag::deleteSelected(bool just_one)
                         SPStop *stop = sp_get_stop_i(vector, draggable->point_i);
                         // check if already present in list. (e.g. when both RG_MID1 and RG_MID2 were selected)
                         bool present = false;
-                        for (GSList const * l = midstoplist; l != NULL; l = l->next) {
-                            if ( (SPStop*)l->data == stop ) {
+                        for (auto i:midstoplist) {
+                            if ( i == stop ) {
                                 present = true;
                                 break; // no need to search further.
                             }
                         }
                         if (!present)
-                            midstoplist = g_slist_append(midstoplist, stop);
+                            midstoplist.push_back(stop);
                     }
                     break;
                 case POINT_LG_BEGIN:
@@ -2922,14 +2923,14 @@ void GrDrag::deleteSelected(bool just_one)
                             stopinfo->vector = vector;
                             // check if already present in list. (e.g. when both R1 and R2 were selected)
                             bool present = false;
-                            for (GSList const * l = endstoplist; l != NULL; l = l->next) {
-                                if ( ((StructStopInfo*)l->data)->spstop == stopinfo->spstop ) {
+                            for (auto i : endstoplist) {
+                                if ( i->spstop == stopinfo->spstop ) {
                                     present = true;
                                     break; // no need to search further.
                                 }
                             }
                             if (!present)
-                                endstoplist = g_slist_append(endstoplist, stopinfo);
+                                endstoplist.push_back(stopinfo);
                         }
                     }
                     break;
@@ -2941,15 +2942,13 @@ void GrDrag::deleteSelected(bool just_one)
         selected.erase(dragger);
         if ( just_one ) break; // iterate once if just_one is set.
     }
-    while (midstoplist) {
-        SPStop *stop = (SPStop*) midstoplist->data;
+    for (auto stop:midstoplist) {
         document = stop->document;
         Inkscape::XML::Node * parent = stop->getRepr()->parent();
         parent->removeChild(stop->getRepr());
-        midstoplist = g_slist_remove(midstoplist, stop);
     }
-    while (endstoplist) {
-        StructStopInfo *stopinfo  = (StructStopInfo*) endstoplist->data;
+
+    for (auto stopinfo:endstoplist) {
         document = stopinfo->spstop->document;
 
         // 2 is the minimum, cannot delete more than that without deleting the whole vector
@@ -3096,7 +3095,6 @@ void GrDrag::deleteSelected(bool just_one)
             sp_repr_css_attr_unref (css);
         }
 
-        endstoplist = g_slist_remove(endstoplist, stopinfo);
         delete stopinfo;
     }
 
diff --git a/src/selection-chemistry.cpp b/src/selection-chemistry.cpp
index be0d7c7d8..863d8858a 100644
--- a/src/selection-chemistry.cpp
+++ b/src/selection-chemistry.cpp
@@ -2093,8 +2093,6 @@ std::vector<SPItem*> sp_get_same_object_type(SPItem *sel, std::vector<SPItem*> &
     return matches;
 }
 
-GSList *sp_get_same_fill_or_stroke_color(SPItem *sel, GSList *src, SPSelectStrokeStyleType type);
-
 /*
  * Find all items in src list that have the same stroke style as sel by type
  * Return the list of matching items
@@ -2331,14 +2329,15 @@ typedef struct Forward {
 
     static Iterator children(SPObject *o) { return o->firstChild(); }
     static Iterator siblings_after(SPObject *o) { return o->getNext(); }
-    static void dispose(Iterator /*i*/) {}
+    static void dispose(Iterator i) {}
 
     static SPObject *object(Iterator i) { return i; }
     static Iterator next(Iterator i) { return i->getNext(); }
+    static bool isNull(Iterator i) {return (!i);}
 } Forward;
 
 typedef struct ListReverse {
-    typedef GSList *Iterator;
+    typedef std::list<SPObject *> *Iterator;
 
     static Iterator children(SPObject *o) {
         return make_list(o, NULL);
@@ -2347,23 +2346,24 @@ typedef struct ListReverse {
         return make_list(o->parent, o);
     }
     static void dispose(Iterator i) {
-        g_slist_free(i);
+        delete i;
     }
 
     static SPObject *object(Iterator i) {
-        return reinterpret_cast<SPObject *>(i->data);
+        return *(i->begin());
     }
-    static Iterator next(Iterator i) { return i->next; }
+    static Iterator next(Iterator i) { i->pop_front(); return i; }
+    
+    static bool isNull(Iterator i) {return i->empty();}
 
 private:
-    static GSList *make_list(SPObject *object, SPObject *limit) {
-        GSList *list = NULL;
+    static std::list<SPObject *> *make_list(SPObject *object, SPObject *limit) {
+        auto list = new std::list<SPObject *>;
         for (auto &child: object->children) {
             if (&child == limit) {
                 break;
             }
-            list = g_slist_prepend(list, &child);
-
+            list->push_front(&child);
         }
         return list;
     }
@@ -2392,7 +2392,7 @@ SPItem *next_item(SPDesktop *desktop, std::vector<SPObject *> &path, SPObject *r
         iter = children = D::children(root);
     }
 
-    while ( iter && !found ) {
+    while ( !D::isNull(iter) && !found ) {
         SPObject *object=D::object(iter);
         if (desktop->isLayer(object)) {
             if (PREFS_SELECTION_LAYER != inlayer) { // recurse into sublayers
@@ -2546,41 +2546,11 @@ void sp_selection_next_patheffect_param(SPDesktop * dt)
 void ObjectSet::editMask(bool /*clip*/)
 {
     return;
-    /*if (!dt) return;
-    using namespace Inkscape::UI;
-
-    Inkscape::Selection *selection = dt->getSelection();
-    if (!selection || selection->isEmpty()) return;
-
-    GSList const *items = selection->itemList();
-    bool has_path = false;
-    for (GSList *i = const_cast<GSList*>(items); i; i= i->next) {
-        SPItem *item = SP_ITEM(i->data);
-        SPObject *search = clip
-            ? (item->clip_ref ? item->clip_ref->getObject() : NULL)
-            : item->mask_ref ? item->mask_ref->getObject() : NULL;
-        has_path |= has_path_recursive(search);
-        if (has_path) break;
-    }
-    if (has_path) {
-        if (!tools_isactive(dt, TOOLS_NODES)) {
-            tools_switch(dt, TOOLS_NODES);
-        }
-        ink_node_tool_set_mode(INK_NODE_TOOL(dt->event_context),
-            clip ? NODE_TOOL_EDIT_CLIPPING_PATHS : NODE_TOOL_EDIT_MASKS);
-    } else if (clip) {
-        dt->messageStack()->flash(Inkscape::WARNING_MESSAGE,
-            _("The selection has no applied clip path."));
-    } else {
-        dt->messageStack()->flash(Inkscape::WARNING_MESSAGE,
-            _("The selection has no applied mask."));
-    }*/
 }
 
 
 
 
-
 /**
  * If \a item is not entirely visible then adjust visible area to centre on the centre on of
  * \a item.
@@ -4083,7 +4053,7 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
     std::vector<SPItem*> items_(items().begin(), items().end());
     clear();
 
-    GSList *items_to_ungroup = NULL;
+    std::vector<SPGroup *> items_to_ungroup;
     std::vector<SPItem*> items_to_select(items_);
 
 
@@ -4116,7 +4086,7 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
 
                 // ungroup only groups we created when setting clip/mask
                 if (group->layerMode() == SPGroup::MASK_HELPER) {
-                    items_to_ungroup = g_slist_prepend(items_to_ungroup, group);
+                    items_to_ungroup.push_back(group);
                 }
 
         }
@@ -4125,7 +4095,7 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
     // restore mask objects into a document
     for ( std::map<SPObject*,SPItem*>::iterator it = referenced_objects.begin() ; it != referenced_objects.end() ; ++it) {
         SPObject *obj = (*it).first; // Group containing the clipped paths or masks
-        GSList *items_to_move = NULL;
+        std::vector<Inkscape::XML::Node *> items_to_move;
         for (auto& child: obj->children) {
             // Collect all clipped paths and masks within a single group
             Inkscape::XML::Node *copy = child.getRepr()->duplicate(xml_doc);
@@ -4133,7 +4103,7 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
             {
                 copy->setAttribute("d", copy->attribute("inkscape:original-d"));
             }
-            items_to_move = g_slist_prepend(items_to_move, copy);
+            items_to_move.push_back(copy);
         }
 
         if (!obj->isReferenced()) {
@@ -4146,8 +4116,8 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
         gint pos = ((*it).second)->getRepr()->position();
 
         // Iterate through all clipped paths / masks
-        for (GSList *i = items_to_move; NULL != i; i = i->next) {
-            Inkscape::XML::Node *repr = static_cast<Inkscape::XML::Node *>(i->data);
+        for (auto i=items_to_move.rbegin();i!=items_to_move.rend();++i) {
+            Inkscape::XML::Node *repr = *i;
 
             // insert into parent, restore pos
             parent->appendChild(repr);
@@ -4161,13 +4131,11 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
             transform *= (*it).second->transform;
             mask_item->doWriteTransform(transform);
         }
-
-        g_slist_free(items_to_move);
     }
 
     // ungroup marked groups added when setting mask
-    for (GSList *i = items_to_ungroup ; NULL != i ; i = i->next) {
-        SPGroup *group = dynamic_cast<SPGroup *>(static_cast<SPObject *>(i->data));
+    for (auto i=items_to_ungroup.rbegin();i!=items_to_ungroup.rend();++i) {
+        SPGroup *group = *i;
         if (group) {
             items_to_select.erase(std::remove(items_to_select.begin(), items_to_select.end(), group), items_to_select.end());
             std::vector<SPItem*> children;
@@ -4178,8 +4146,6 @@ void ObjectSet::unsetMask(const bool apply_clip_path, const bool skip_undo) {
         }
     }
 
-    g_slist_free(items_to_ungroup);
-
     // rebuild selection
     addList(items_to_select);
 
diff --git a/src/sp-defs.cpp b/src/sp-defs.cpp
index 865c6891e..619a27c0f 100644
--- a/src/sp-defs.cpp
+++ b/src/sp-defs.cpp
@@ -52,18 +52,13 @@ void SPDefs::modified(unsigned int flags) {
     }
 
     flags &= SP_OBJECT_MODIFIED_CASCADE;
-
-    GSList *l = NULL;
+    std::vector<SPObject *> l;
     for (auto& child: children) {
         sp_object_ref(&child);
-        l = g_slist_prepend(l, &child);
+        l.push_back(&child);
     }
 
-    l = g_slist_reverse(l);
-
-    while (l) {
-        SPObject *child = SP_OBJECT(l->data);
-        l = g_slist_remove(l, child);
+    for (auto child:l) {
         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
             child->emitModified(flags);
         }
@@ -78,20 +73,17 @@ Inkscape::XML::Node* SPDefs::write(Inkscape::XML::Document *xml_doc, Inkscape::X
             repr = xml_doc->createElement("svg:defs");
         }
 
-        GSList *l = NULL;
+        std::vector<Inkscape::XML::Node *> l;
         for (auto& child: children) {
             Inkscape::XML::Node *crepr = child.updateRepr(xml_doc, NULL, flags);
             if (crepr) {
-                l = g_slist_prepend(l, crepr);
+                l.push_back(crepr);
             }
         }
-
-        while (l) {
-            repr->addChild((Inkscape::XML::Node *) l->data, NULL);
-            Inkscape::GC::release((Inkscape::XML::Node *) l->data);
-            l = g_slist_remove(l, l->data);
+        for (auto i=l.rbegin();i!=l.rend();++i) {
+            repr->addChild(*i, NULL);
+            Inkscape::GC::release(*i);
         }
-
     } else {
         for (auto& child: children) {
             child.updateRepr(flags);
diff --git a/src/sp-filter.cpp b/src/sp-filter.cpp
index 052fa7fe2..2a5ec0755 100644
--- a/src/sp-filter.cpp
+++ b/src/sp-filter.cpp
@@ -267,19 +267,18 @@ Inkscape::XML::Node* SPFilter::write(Inkscape::XML::Document *doc, Inkscape::XML
             repr = doc->createElement("svg:filter");
         }
 
-        GSList *l = NULL;
+        std::vector<Inkscape::XML::Node *> l;
         for (auto& child: children) {
             Inkscape::XML::Node *crepr = child.updateRepr(doc, NULL, flags);
 
             if (crepr) {
-                l = g_slist_prepend (l, crepr);
+                l.push_back(crepr);
             }
         }
 
-        while (l) {
-            repr->addChild((Inkscape::XML::Node *) l->data, NULL);
-            Inkscape::GC::release((Inkscape::XML::Node *) l->data);
-            l = g_slist_remove (l, l->data);
+        for (auto i=l.rbegin();i!=l.rend();++i) {
+           repr->addChild(*i, NULL);
+            Inkscape::GC::release(*i);
         }
     } else {
         for (auto& child: children) {
diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index c1934dd92..feaa04e0f 100644
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
@@ -561,23 +561,16 @@ void SPGradient::modified(guint flags)
     flags &= SP_OBJECT_MODIFIED_CASCADE;
 
     // FIXME: climb up the ladder of hrefs
-    GSList *l = NULL;
-
+    std::vector<SPObject *> l;
     for (auto& child: children) {
         sp_object_ref(&child);
-        l = g_slist_prepend(l, &child);
+        l.push_back(&child);
     }
-
-    l = g_slist_reverse(l);
-
-    while (l) {
-        SPObject *child = SP_OBJECT(l->data);
-        l = g_slist_remove(l, child);
-
+ 
+    for (auto child:l) {
         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
             child->emitModified(flags);
         }
-
         sp_object_unref(child);
     }
 
@@ -621,20 +614,19 @@ Inkscape::XML::Node *SPGradient::write(Inkscape::XML::Document *xml_doc, Inkscap
     SPPaintServer::write(xml_doc, repr, flags);
 
     if (flags & SP_OBJECT_WRITE_BUILD) {
-        GSList *l = NULL;
+        std::vector<Inkscape::XML::Node *> l;
 
         for (auto& child: children) {
             Inkscape::XML::Node *crepr = child.updateRepr(xml_doc, NULL, flags);
 
             if (crepr) {
-                l = g_slist_prepend(l, crepr);
+                l.push_back(crepr);
             }
         }
 
-        while (l) {
-            repr->addChild((Inkscape::XML::Node *) l->data, NULL);
-            Inkscape::GC::release((Inkscape::XML::Node *) l->data);
-            l = g_slist_remove(l, l->data);
+        for (auto i=l.rbegin();i!=l.rend();++i) {
+            repr->addChild(*i, NULL);
+            Inkscape::GC::release(*i);
         }
     }
 
@@ -877,20 +869,19 @@ sp_gradient_repr_clear_vector(SPGradient *gr)
     Inkscape::XML::Node *repr = gr->getRepr();
 
     /* Collect stops from original repr */
-    GSList *sl = NULL;
+    std::vector<Inkscape::XML::Node *> l;
     for (Inkscape::XML::Node *child = repr->firstChild() ; child != NULL; child = child->next() ) {
         if (!strcmp(child->name(), "svg:stop")) {
-            sl = g_slist_prepend(sl, child);
+            l.push_back(child);
         }
     }
     /* Remove all stops */
-    while (sl) {
+    for (auto i=l.rbegin();i!=l.rend();++i) {
         /** \todo
          * fixme: This should work, unless we make gradient
          * into generic group.
          */
-        sp_repr_unparent((Inkscape::XML::Node *)sl->data);
-        sl = g_slist_remove(sl, sl->data);
+        sp_repr_unparent(*i);
     }
 }
 
@@ -908,7 +899,7 @@ sp_gradient_repr_write_vector(SPGradient *gr)
     Inkscape::XML::Node *repr = gr->getRepr();
 
     /* We have to be careful, as vector may be our own, so construct repr list at first */
-    GSList *cl = NULL;
+    std::vector<Inkscape::XML::Node *> l;
 
     for (guint i = 0; i < gr->vector.stops.size(); i++) {
         Inkscape::CSSOStringStream os;
@@ -919,17 +910,16 @@ sp_gradient_repr_write_vector(SPGradient *gr)
         os << "stop-color:" << gr->vector.stops[i].color.toString() << ";stop-opacity:" << gr->vector.stops[i].opacity;
         child->setAttribute("style", os.str().c_str());
         /* Order will be reversed here */
-        cl = g_slist_prepend(cl, child);
+        l.push_back(child);
     }
 
     sp_gradient_repr_clear_vector(gr);
 
     /* And insert new children from list */
-    while (cl) {
-        Inkscape::XML::Node *child = static_cast<Inkscape::XML::Node *>(cl->data);
+    for (auto i=l.rbegin();i!=l.rend();++i) {
+        Inkscape::XML::Node *child = *i;
         repr->addChild(child, NULL);
         Inkscape::GC::release(child);
-        cl = g_slist_remove(cl, child);
     }
 }
 
diff --git a/src/sp-item-group.cpp b/src/sp-item-group.cpp
index 4dbfa8ac3..27bee1541 100644
--- a/src/sp-item-group.cpp
+++ b/src/sp-item-group.cpp
@@ -226,7 +226,7 @@ void SPGroup::modified(guint flags) {
 
 Inkscape::XML::Node* SPGroup::write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
     if (flags & SP_OBJECT_WRITE_BUILD) {
-        GSList *l = NULL;
+        std::vector<Inkscape::XML::Node *> l;
 
         if (!repr) {
             if (dynamic_cast<SPSwitch *>(this)) {
@@ -236,22 +236,18 @@ Inkscape::XML::Node* SPGroup::write(Inkscape::XML::Document *xml_doc, Inkscape::
             }
         }
 
-        l = NULL;
-
         for (auto& child: children) {
             if ( !dynamic_cast<SPTitle *>(&child) && !dynamic_cast<SPDesc *>(&child) ) {
                 Inkscape::XML::Node *crepr = child.updateRepr(xml_doc, NULL, flags);
 
                 if (crepr) {
-                    l = g_slist_prepend (l, crepr);
+                    l.push_back(crepr);
                 }
             }
         }
-
-        while (l) {
-            repr->addChild((Inkscape::XML::Node *) l->data, NULL);
-            Inkscape::GC::release((Inkscape::XML::Node *) l->data);
-            l = g_slist_remove (l, l->data);
+        for (auto i=l.rbegin();i!=l.rend();++i) {
+            repr->addChild(*i, NULL);
+            Inkscape::GC::release(*i);
         }
     } else {
         for (auto& child: children) {
@@ -510,8 +506,8 @@ sp_item_group_ungroup (SPGroup *group, std::vector<SPItem*> &children, bool do_d
     group->removeAllPathEffects(false);
 
     /* Step 1 - generate lists of children objects */
-    GSList *items = NULL;
-    GSList *objects = NULL;
+    std::vector<Inkscape::XML::Node *> items;
+    std::vector<Inkscape::XML::Node *> objects;
     Geom::Affine const g(group->transform);
 
     for (auto& child: group->children) {
@@ -602,11 +598,11 @@ sp_item_group_ungroup (SPGroup *group, std::vector<SPItem*> &children, bool do_d
             }
             g_free(affinestr);
 
-            items = g_slist_prepend (items, nrepr);
+            items.push_back(nrepr);
 
         } else {
             Inkscape::XML::Node *nrepr = child.getRepr()->duplicate(prepr->document());
-            objects = g_slist_prepend (objects, nrepr);
+            objects.push_back(nrepr);
         }
     }
 
@@ -618,21 +614,20 @@ sp_item_group_ungroup (SPGroup *group, std::vector<SPItem*> &children, bool do_d
     group->deleteObject(true, false);
 
     /* Step 3 - add nonitems */
-    if (objects) {
+    if (!objects.empty()) {
         Inkscape::XML::Node *last_def = defs->getRepr()->lastChild();
-        while (objects) {
-            Inkscape::XML::Node *repr = (Inkscape::XML::Node *) objects->data;
+        for (auto i=objects.rbegin();i!=objects.rend();++i) {
+            Inkscape::XML::Node *repr = *i; 
             if (!sp_repr_is_meta_element(repr)) {
                 defs->getRepr()->addChild(repr, last_def);
             }
             Inkscape::GC::release(repr);
-            objects = g_slist_remove (objects, objects->data);
         }
     }
 
     /* Step 4 - add items */
-    while (items) {
-        Inkscape::XML::Node *repr = (Inkscape::XML::Node *) items->data;
+    for (auto i=items.rbegin();i!=items.rend();++i) {
+        Inkscape::XML::Node *repr = *i;
         // add item
         prepr->appendChild(repr);
         // restore position; since the items list was prepended (i.e. reverse), we now add
@@ -650,7 +645,6 @@ sp_item_group_ungroup (SPGroup *group, std::vector<SPItem*> &children, bool do_d
         }
 
         Inkscape::GC::release(repr);
-        items = g_slist_remove (items, items->data);
     }
 
     if (do_done) {
diff --git a/src/sp-mesh-patch.cpp b/src/sp-mesh-patch.cpp
index 9a173a8db..04a121c7a 100644
--- a/src/sp-mesh-patch.cpp
+++ b/src/sp-mesh-patch.cpp
@@ -94,23 +94,16 @@ void SPMeshpatch::set(unsigned int key, const gchar* value) {
 void SPMeshpatch::modified(unsigned int flags) {
 
     flags &= SP_OBJECT_MODIFIED_CASCADE;
-    GSList *l = NULL;
-
+    std::vector<SPObject *> l;
     for (auto& child: children) {
         sp_object_ref(&child);
-        l = g_slist_prepend(l, &child);
+        l.push_back(&child);
     }
 
-    l = g_slist_reverse(l);
-
-    while (l) {
-        SPObject *child = SP_OBJECT(l->data);
-        l = g_slist_remove(l, child);
-
+    for (auto child:l) {
         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
             child->emitModified(flags);
         }
-
         sp_object_unref(child);
     }
 }
diff --git a/src/sp-object-group.cpp b/src/sp-object-group.cpp
index 62c6f7a87..f8ef855e3 100644
--- a/src/sp-object-group.cpp
+++ b/src/sp-object-group.cpp
@@ -49,19 +49,17 @@ Inkscape::XML::Node *SPObjectGroup::write(Inkscape::XML::Document *xml_doc, Inks
             repr = xml_doc->createElement("svg:g");
         }
 
-        GSList *l = 0;
+        std::vector<Inkscape::XML::Node *> l;
         for (auto& child: children) {
             Inkscape::XML::Node *crepr = child.updateRepr(xml_doc, NULL, flags);
 
             if (crepr) {
-                l = g_slist_prepend(l, crepr);
+                l.push_back(crepr);
             }
         }
-
-        while (l) {
-            repr->addChild(static_cast<Inkscape::XML::Node *>(l->data), NULL);
-            Inkscape::GC::release(static_cast<Inkscape::XML::Node *>(l->data));
-            l = g_slist_remove(l, l->data);
+        for (auto i=l.rbegin();i!=l.rend();++i) {
+            repr->addChild(*i, NULL);
+            Inkscape::GC::release(*i);
         }
     } else {
         for (auto& child: children) {
diff --git a/src/text-chemistry.cpp b/src/text-chemistry.cpp
index bde269de7..2c84a00f3 100644
--- a/src/text-chemistry.cpp
+++ b/src/text-chemistry.cpp
@@ -140,9 +140,9 @@ text_put_on_path()
     text->getRepr()->setAttribute("transform", NULL);
 
     // make a list of text children
-    GSList *text_reprs = NULL;
+    std::vector<Inkscape::XML::Node *> text_reprs;
     for(auto& o: text->children) {
-        text_reprs = g_slist_prepend(text_reprs, o.getRepr());
+        text_reprs.push_back(o.getRepr());
     }
 
     // create textPath and put it into the text
@@ -158,9 +158,9 @@ text_put_on_path()
     }
     text->getRepr()->addChild(textpath, NULL);
 
-    for ( GSList *i = text_reprs ; i ; i = i->next ) {
+    for (auto i=text_reprs.rbegin();i!=text_reprs.rend();++i) {
         // Make a copy of each text child
-        Inkscape::XML::Node *copy = ((Inkscape::XML::Node *) i->data)->duplicate(xml_doc);
+        Inkscape::XML::Node *copy = (*i)->duplicate(xml_doc);
         // We cannot have multiline in textpath, so remove line attrs from tspans
         if (!strcmp(copy->name(), "svg:tspan")) {
             copy->setAttribute("sodipodi:role", NULL);
@@ -168,7 +168,7 @@ text_put_on_path()
             copy->setAttribute("y", NULL);
         }
         // remove the old repr from under text
-        text->getRepr()->removeChild(reinterpret_cast<Inkscape::XML::Node *>(i->data));
+        text->getRepr()->removeChild(*i);
         // put its copy into under textPath
         textpath->addChild(copy, NULL); // fixme: copy id
     }
@@ -179,7 +179,6 @@ text_put_on_path()
 
     DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, 
                        _("Put text on path"));
-    g_slist_free(text_reprs);
 }
 
 void
@@ -393,7 +392,7 @@ text_unflow ()
     }
 
     std::vector<SPItem*> new_objs;
-    GSList *old_objs = NULL;
+    std::vector<SPItem *> old_objs;
 
     auto items = selection->items();
     for(auto i=items.begin();i!=items.end();++i){
@@ -444,7 +443,7 @@ text_unflow ()
         text->_adjustFontsizeRecursive(text, ex);
 
         new_objs.push_back((SPItem*)text_object);
-        old_objs = g_slist_prepend (old_objs, flowtext);
+        old_objs.push_back(flowtext);
 
         Inkscape::GC::release(rtext);
         Inkscape::GC::release(rtspan);
@@ -454,12 +453,10 @@ text_unflow ()
     selection->clear();
     reverse(new_objs.begin(),new_objs.end());
     selection->setList(new_objs);
-    for (GSList *i = old_objs; i; i = i->next) {
-        SP_OBJECT(i->data)->deleteObject (true);
+    for (auto i:old_objs) {
+        i->deleteObject (true);
     }
 
-    g_slist_free (old_objs);
-
     DocumentUndo::done(doc, SP_VERB_CONTEXT_TEXT, 
                        _("Unflow flowed text"));
 }