Merge lp:~mc.../inkscape/SelContainer into lp:~inkscape.dev/inkscape/trunk

[Mc]

Hi all,

This branch is a proposal to replace a lot of GSLists with std::vectors, more specifically in all the places that deal with the selection.

Basically, selection->itemList() and similar methods now return a reference to a vector of SPItem* instead of a GSList (and similarly for other getters and setters from the selection)

[lp:~mc.../inkscape/SelContainer]

13929. By Marc Jeanmougin <email address hidden> on 2015-02-23

Removed eclipse files, added removed pot file

13930. By Marc Jeanmougin <email address hidden> on 2015-02-23

Merge, resolved conflicts

13931. By Marc Jeanmougin <email address hidden> on 2015-02-23

should replace buggy pot file

[Liam P. White (liampwhite)]

I added some fancy new diff comments that should help show where things need fixing.

review: Needs Fixing (code)

[Mc (mc...)]

> I added some fancy new diff comments that should help show where things need
> fixing.

Thanks a lot for your comments !

I actually meant to change the semantics of SPObject::childList : It used to return a GSList, whose *last* element was the first child, and to be reversed in many places.

Now it returns a vector whose *first* element is the first child, so that allows us to actually simplify a lot of things (use push_back instead of insert in all the places that deals with childList)

I'll try to apply your comments as soon as i can.

[Krzysztof Kosinski (tweenk)]

Converting Selection to a vector is not the best thing to do. Selection
should be a data structure equivalent to Java's LinkedHashSet, because the
most common operation is lookup (whether something is in the selection) and
we also need to remember the selection's order for purposes such as Boolean
operations.

Regards, Krzysztof

2015-02-24 12:08 GMT+01:00 Mc <email address hidden>:

> > I added some fancy new diff comments that should help show where things
> need
> > fixing.
>
> Thanks a lot for your comments !
>
> I actually meant to change the semantics of SPObject::childList : It used
> to return a GSList, whose *last* element was the first child, and to be
> reversed in many places.
>
> Now it returns a vector whose *first* element is the first child, so that
> allows us to actually simplify a lot of things (use push_back instead of
> insert in all the places that deals with childList)
>
> I'll try to apply your comments as soon as i can.
> --
> https://code.launchpad.net/~mc.../inkscape/SelContainer/+merge/250681
> You are subscribed to branch lp:inkscape.
>

[Mc (mc...)]

This is not contradictory: since only the selection object needs to be able to do the lookups, this data structure can be internal to Selection, and does not need to be whatever is sent to anyone who calls itemList() (I don't really favor introducing iteration over boost objects everywhere just for that, stl is enough for stuff out of the selection class (ie: iterate) )

(I actually also added a std::set to make lookups logarithmic, alongside with the vectors change. I agree that it could be made one container, internally to the selection class, but vector+set prevents to do the copying from the boost thing)

> Converting Selection to a vector is not the best thing to do. Selection
> should be a data structure equivalent to Java's LinkedHashSet, because the
> most common operation is lookup (whether something is in the selection) and
> we also need to remember the selection's order for purposes such as Boolean
> operations.
>
> Regards, Krzysztof

[Krzysztof Kosinski (tweenk)]

Some more comments.

1. Please follow the coding style.
https://inkscape.org/en/develop/coding-style/

2. I don't really understand what you mean by "introducing iteration over boost objects".

3. While simply replacing GSList with vectors is an obvious improvement, I think the correct approach is to make a new data structure, that will encapsulate what we mean by a selection of objects (a list of unique items none of which is a descendant of any other), but which will not be tied to the GUI concept of selection. One could use Boost MultiIndex for this. Then you would return this structure (or references to it) instead of std::vector. The new structure could be a template called SelectionSet, with typedefs SelectionSet<SPObject> = ObjectSet and SelectionSet<SPItem> = ItemSet. Still, I would not be opposed to incorporating the simple GSList -> vector change first and introducing selection sets later.

[Liam P. White (liampwhite)]

> I would not be opposed to incorporating the simple GSList -> vector change first and introducing selection sets later.

Then let's do that.

[lp:~mc.../inkscape/SelContainer]

13932. By Marc Jeanmougin <email address hidden> on 2015-02-27

corrected the casts (hopefully)

13933. By Marc Jeanmougin <email address hidden> on 2015-02-27

more cast cleanup

13934. By Marc Jeanmougin <email address hidden> on 2015-04-26

merge

13935. By Marc Jeanmougin <email address hidden> on 2015-04-26

merging

13936. By Marc Jeanmougin <email address hidden> on 2015-04-26

fix

13937. By Marc Jeanmougin <email address hidden> on 2015-04-26

Just reread the entire diff against trunk. Given the diff size, i must have forgotten things, but hopefully, there are only very few changes of semantics:
->childList is now in the intuitive order (childList()[0] is now firstChild)
-> sp_selection_paste_impl is now in the opposite order (change is local to selection-chemistry.cpp, and simplify a few things)
-> selection.setReprList now takes the list in the opposite order. It was always the case (the list was always reversed before handing to it)
-> a few comparison functions now work "the c++ way": the C way was to return -1 if a<b, 0 if a==b and 1 if a>b, now they return (bool)(a<b)

13938. By Marc Jeanmougin <email address hidden> on 2015-04-27

removed a few "using Inkscape::Util::GSListConstIterator"

13939. By Marc Jeanmougin <email address hidden> on 2015-04-27

removed a few useless SP_OBJECT() casts

13940. By Marc Jeanmougin <email address hidden> on 2015-04-27

merge with trunk

[Liam P. White (liampwhite)]

Approving for merge — may need some small post-merge cleanups but otherwise don't see any issues obstructing merge at this point.

review: Approve

[lp:~mc.../inkscape/SelContainer]

13941. By Marc Jeanmougin <email address hidden> on 2015-04-29

updated with trunk

13942. By Marc Jeanmougin <email address hidden> on 2015-04-29

corrected test file

[Alex Valavanis (valavanisalex)]

This introduces a build failure if using --enable-dbusapi configuration flag. This is because the src/extension/dbus/* tree hasn't yet been migrated to the new selection API.

review: Needs Fixing

=== modified file 'AUTHORS'
--- AUTHORS	2014-05-12 22:02:09 +0000
+++ AUTHORS	2015-04-29 21:03:59 +0000
@@ -80,6 +80,7 @@
 Jean-Olivier Irisson
 Bob Jamison
 Ted Janeczko
+Marc Jeanmougin
 jEsuSdA
 Lauris Kaplinski
 Lynn Kerby

=== modified file 'src/conn-avoid-ref.cpp'
--- src/conn-avoid-ref.cpp	2014-12-21 21:58:32 +0000
+++ src/conn-avoid-ref.cpp	2015-04-29 21:03:59 +0000
@@ -252,8 +252,9 @@
     {
         SPGroup* group = SP_GROUP(item);
         // consider all first-order children
-        for (GSList const* i = sp_item_group_item_list(group); i != NULL; i = i->next) {
-            SPItem* child_item = SP_ITEM(i->data);
+        std::vector<SPItem*> itemlist = sp_item_group_item_list(group);
+        for (std::vector<SPItem*>::const_iterator i = itemlist.begin(); i != itemlist.end(); i++) {
+            SPItem* child_item = *i;
             std::vector<Geom::Point> child_points = approxItemWithPoints(child_item, item_transform * child_item->transform);
             poly_points.insert(poly_points.end(), child_points.begin(), child_points.end());
         }

=== modified file 'src/desktop-style.cpp'
--- src/desktop-style.cpp	2015-02-22 18:04:11 +0000
+++ src/desktop-style.cpp	2015-04-29 21:03:59 +0000
@@ -194,10 +194,10 @@
         sp_repr_css_merge(css_write, css);
         sp_css_attr_unset_uris(css_write);
         prefs->mergeStyle("/desktop/style", css_write);
-
-        for (const GSList *i = desktop->selection->itemList(); i != NULL; i = i->next) {
+        std::vector<SPItem*> const itemlist = desktop->selection->itemList();
+        for (std::vector<SPItem*>::const_iterator i = itemlist.begin(); i!= itemlist.end(); i++) {
             /* last used styles for 3D box faces are stored separately */
-            SPObject *obj = reinterpret_cast<SPObject *>(i->data); // TODO unsafe until Selection is refactored.
+            SPObject *obj = *i;
             Box3DSide *side = dynamic_cast<Box3DSide *>(obj);
             if (side) {
                 const char * descr  = box3d_side_axes_string(side);
@@ -234,8 +234,9 @@
         sp_repr_css_merge(css_no_text, css);
         css_no_text = sp_css_attr_unset_text(css_no_text);
 
-        for (GSList const *i = desktop->selection->itemList(); i != NULL; i = i->next) {
-            SPItem *item = reinterpret_cast<SPItem *>(i->data);
+        std::vector<SPItem*> const itemlist = desktop->selection->itemList();
+        for (std::vector<SPItem*>::const_iterator i = itemlist.begin(); i!= itemlist.end(); i++) {
+            SPItem *item = *i;
 
             // If not text, don't apply text attributes (can a group have text attributes? Yes! FIXME)
             if (isTextualItem(item)) {
@@ -438,18 +439,16 @@
 /** Determine average stroke width, simple method */
 // see TODO in dialogs/stroke-style.cpp on how to get rid of this eventually
 gdouble
-stroke_average_width (GSList const *objects)
+stroke_average_width (const std::vector<SPItem*> &objects)
 {
-    if (g_slist_length ((GSList *) objects) == 0)
+    if (objects.empty())
         return Geom::infinity();
 
     gdouble avgwidth = 0.0;
     bool notstroked = true;
     int n_notstroked = 0;
-
-    for (GSList const *l = objects; l != NULL; l = l->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(l->data);
-        SPItem *item = dynamic_cast<SPItem *>(obj);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPItem *item = *i;
         if (!item) {
             continue;
         }
@@ -471,7 +470,7 @@
     if (notstroked)
         return Geom::infinity();
 
-    return avgwidth / (g_slist_length ((GSList *) objects) - n_notstroked);
+    return avgwidth / (objects.size() - n_notstroked);
 }
 
 static bool vectorsClose( std::vector<double> const &lhs, std::vector<double> const &rhs )
@@ -492,9 +491,9 @@
  * Write to style_res the average fill or stroke of list of objects, if applicable.
  */
 int
-objects_query_fillstroke (GSList *objects, SPStyle *style_res, bool const isfill)
+objects_query_fillstroke (const std::vector<SPItem*> &objects, SPStyle *style_res, bool const isfill)
 {
-    if (g_slist_length(objects) == 0) {
+    if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -514,8 +513,8 @@
     prev[0] = prev[1] = prev[2] = 0.0;
     bool same_color = true;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+        for (std::vector<SPItem*>::const_iterator i = objects.begin(); i!= objects.end(); i++) {
+        SPObject *obj = *i;
         if (!obj) {
             continue;
         }
@@ -674,7 +673,7 @@
     }
 
     // Not color
-    if (g_slist_length(objects) > 1) {
+    if (objects.size() > 1) {
         return QUERY_STYLE_MULTIPLE_SAME;
     } else {
         return QUERY_STYLE_SINGLE;
@@ -685,9 +684,9 @@
  * Write to style_res the average opacity of a list of objects.
  */
 int
-objects_query_opacity (GSList *objects, SPStyle *style_res)
+objects_query_opacity (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
-    if (g_slist_length(objects) == 0) {
+    if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -698,8 +697,8 @@
     guint opacity_items = 0;
 
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!obj) {
             continue;
         }
@@ -739,9 +738,9 @@
  * Write to style_res the average stroke width of a list of objects.
  */
 int
-objects_query_strokewidth (GSList *objects, SPStyle *style_res)
+objects_query_strokewidth (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
-    if (g_slist_length(objects) == 0) {
+    if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -754,8 +753,8 @@
 
     int n_stroked = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!obj) {
             continue;
         }
@@ -815,9 +814,9 @@
  * Write to style_res the average miter limit of a list of objects.
  */
 int
-objects_query_miterlimit (GSList *objects, SPStyle *style_res)
+objects_query_miterlimit (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
-    if (g_slist_length(objects) == 0) {
+    if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -828,8 +827,8 @@
     gdouble prev_ml = -1;
     bool same_ml = true;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!dynamic_cast<SPItem *>(obj)) {
             continue;
         }
@@ -875,9 +874,9 @@
  * Write to style_res the stroke cap of a list of objects.
  */
 int
-objects_query_strokecap (GSList *objects, SPStyle *style_res)
+objects_query_strokecap (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
-    if (g_slist_length(objects) == 0) {
+    if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -887,8 +886,8 @@
     bool same_cap = true;
     int n_stroked = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!dynamic_cast<SPItem *>(obj)) {
             continue;
         }
@@ -929,9 +928,9 @@
  * Write to style_res the stroke join of a list of objects.
  */
 int
-objects_query_strokejoin (GSList *objects, SPStyle *style_res)
+objects_query_strokejoin (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
-    if (g_slist_length(objects) == 0) {
+    if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -941,8 +940,8 @@
     bool same_join = true;
     int n_stroked = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!dynamic_cast<SPItem *>(obj)) {
             continue;
         }
@@ -984,7 +983,7 @@
  * Write to style_res the average font size and spacing of objects.
  */
 int
-objects_query_fontnumbers (GSList *objects, SPStyle *style_res)
+objects_query_fontnumbers (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
     bool different = false;
 
@@ -1004,8 +1003,8 @@
     int texts = 0;
     int no_size = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
 
         if (!isTextualItem(obj)) {
             continue;
@@ -1116,15 +1115,15 @@
  * Write to style_res the average font style of objects.
  */
 int
-objects_query_fontstyle (GSList *objects, SPStyle *style_res)
+objects_query_fontstyle (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
     bool different = false;
     bool set = false;
 
     int texts = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
 
         if (!isTextualItem(obj)) {
             continue;
@@ -1173,7 +1172,7 @@
  * Write to style_res the baseline numbers.
  */
 static int
-objects_query_baselines (GSList *objects, SPStyle *style_res)
+objects_query_baselines (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
     bool different = false;
 
@@ -1192,8 +1191,8 @@
 
     int texts = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
 
         if (!isTextualItem(obj)) {
             continue;
@@ -1269,7 +1268,7 @@
  * Write to style_res the average font family of objects.
  */
 int
-objects_query_fontfamily (GSList *objects, SPStyle *style_res)
+objects_query_fontfamily (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
     bool different = false;
     int texts = 0;
@@ -1280,8 +1279,8 @@
     }
     style_res->font_family.set = FALSE;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
 
         // std::cout << "  " << reinterpret_cast<SPObject*>(i->data)->getId() << std::endl;
         if (!isTextualItem(obj)) {
@@ -1325,7 +1324,7 @@
 }
 
 static int
-objects_query_fontspecification (GSList *objects, SPStyle *style_res)
+objects_query_fontspecification (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
     bool different = false;
     int texts = 0;
@@ -1336,8 +1335,8 @@
     }
     style_res->font_specification.set = FALSE;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
 
         // std::cout << "  " << reinterpret_cast<SPObject*>(i->data)->getId() << std::endl;
         if (!isTextualItem(obj)) {
@@ -1385,7 +1384,7 @@
 }
 
 static int
-objects_query_blend (GSList *objects, SPStyle *style_res)
+objects_query_blend (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
     const int empty_prev = -2;
     const int complex_filter = 5;
@@ -1394,8 +1393,8 @@
     bool same_blend = true;
     guint items = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!obj) {
             continue;
         }
@@ -1471,9 +1470,9 @@
  * Write to style_res the average blurring of a list of objects.
  */
 int
-objects_query_blur (GSList *objects, SPStyle *style_res)
+objects_query_blur (const std::vector<SPItem*> &objects, SPStyle *style_res)
 {
-   if (g_slist_length(objects) == 0) {
+   if (objects.empty()) {
         /* No objects, set empty */
         return QUERY_STYLE_NOTHING;
     }
@@ -1484,8 +1483,8 @@
     guint blur_items = 0;
     guint items = 0;
 
-    for (GSList const *i = objects; i != NULL; i = i->next) {
-        SPObject *obj = reinterpret_cast<SPObject *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = objects.begin(); i != objects.end(); i++) {
+        SPObject *obj = *i;
         if (!obj) {
             continue;
         }
@@ -1553,7 +1552,7 @@
  * the result to style, return appropriate flag.
  */
 int
-sp_desktop_query_style_from_list (GSList *list, SPStyle *style, int property)
+sp_desktop_query_style_from_list (const std::vector<SPItem*> &list, SPStyle *style, int property)
 {
     if (property == QUERY_STYLE_PROPERTY_FILL) {
         return objects_query_fillstroke (list, style, true);
@@ -1606,7 +1605,7 @@
 
     // otherwise, do querying and averaging over selection
     if (desktop->selection != NULL) {
-        return sp_desktop_query_style_from_list ((GSList *) desktop->selection->itemList(), style, property);
+        return sp_desktop_query_style_from_list (desktop->selection->itemList(), style, property);
     }
 
     return QUERY_STYLE_NOTHING;

=== modified file 'src/desktop-style.h'
--- src/desktop-style.h	2014-10-08 02:22:03 +0000
+++ src/desktop-style.h	2015-04-29 21:03:59 +0000
@@ -17,6 +17,7 @@
 class SPCSSAttr;
 class SPDesktop;
 class SPObject;
+class SPItem;
 class SPStyle;
 typedef struct _GSList GSList;
 namespace Inkscape {
@@ -64,21 +65,21 @@
 double sp_desktop_get_font_size_tool (SPDesktop *desktop);
 void sp_desktop_apply_style_tool(SPDesktop *desktop, Inkscape::XML::Node *repr, Glib::ustring const &tool, bool with_text);
 
-gdouble stroke_average_width (GSList const *objects);
-
-int objects_query_fillstroke (GSList *objects, SPStyle *style_res, bool const isfill);
-int objects_query_fontnumbers (GSList *objects, SPStyle *style_res);
-int objects_query_fontstyle (GSList *objects, SPStyle *style_res);
-int objects_query_fontfamily (GSList *objects, SPStyle *style_res);
-int objects_query_opacity (GSList *objects, SPStyle *style_res);
-int objects_query_strokewidth (GSList *objects, SPStyle *style_res);
-int objects_query_miterlimit (GSList *objects, SPStyle *style_res);
-int objects_query_strokecap (GSList *objects, SPStyle *style_res);
-int objects_query_strokejoin (GSList *objects, SPStyle *style_res);
-
-int objects_query_blur (GSList *objects, SPStyle *style_res);
-
-int sp_desktop_query_style_from_list (GSList *list, SPStyle *style, int property);
+gdouble stroke_average_width (const std::vector<SPItem*> &objects);
+
+int objects_query_fillstroke (const std::vector<SPItem*> &objects, SPStyle *style_res, bool const isfill);
+int objects_query_fontnumbers (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_fontstyle (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_fontfamily (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_opacity (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_strokewidth (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_miterlimit (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_strokecap (const std::vector<SPItem*> &objects, SPStyle *style_res);
+int objects_query_strokejoin (const std::vector<SPItem*> &objects, SPStyle *style_res);
+
+int objects_query_blur (const std::vector<SPItem*> &objects, SPStyle *style_res);
+
+int sp_desktop_query_style_from_list (const std::vector<SPItem*> &list, SPStyle *style, int property);
 int sp_desktop_query_style(SPDesktop *desktop, SPStyle *style, int property);
 bool sp_desktop_query_style_all (SPDesktop *desktop, SPStyle *query);
 

=== modified file 'src/desktop.cpp'
--- src/desktop.cpp	2015-02-25 01:04:28 +0000
+++ src/desktop.cpp	2015-04-29 21:03:59 +0000
@@ -716,7 +716,7 @@
 /**
  * \see SPDocument::getItemFromListAtPointBottom()
  */
-SPItem *SPDesktop::getItemFromListAtPointBottom(const GSList *list, Geom::Point const &p) const
+SPItem *SPDesktop::getItemFromListAtPointBottom(const std::vector<SPItem*> &list, Geom::Point const &p) const
 {
     g_return_val_if_fail (doc() != NULL, NULL);
     return SPDocument::getItemFromListAtPointBottom(dkey, doc()->getRoot(), list, p);

=== modified file 'src/desktop.h'
--- src/desktop.h	2014-12-21 21:58:32 +0000
+++ src/desktop.h	2015-04-29 21:03:59 +0000
@@ -319,7 +319,7 @@
     //void push_event_context (GType type, const gchar *config, unsigned int key);
 
     void set_coordinate_status (Geom::Point p);
-    SPItem *getItemFromListAtPointBottom(const GSList *list, Geom::Point const &p) const;
+    SPItem *getItemFromListAtPointBottom(const std::vector<SPItem*> &list, Geom::Point const &p) const;
     SPItem *getItemAtPoint(Geom::Point const &p, bool into_groups, SPItem *upto = NULL) const;
     SPItem *getGroupAtPoint(Geom::Point const &p) const;
     Geom::Point point() const;

=== modified file 'src/document.cpp'
--- src/document.cpp	2015-03-21 11:41:01 +0000
+++ src/document.cpp	2015-04-29 21:03:59 +0000
@@ -1266,7 +1266,7 @@
     return area.intersects(box);
 }
 
-static GSList *find_items_in_area(GSList *s, SPGroup *group, unsigned int dkey, Geom::Rect const &area,
+static std::vector<SPItem*> &find_items_in_area(std::vector<SPItem*> &s, SPGroup *group, unsigned int dkey, Geom::Rect const &area,
                                   bool (*test)(Geom::Rect const &, Geom::Rect const &), bool take_insensitive = false)
 {
     g_return_val_if_fail(SP_IS_GROUP(group), s);
@@ -1279,7 +1279,7 @@
                 SPItem *child = SP_ITEM(o);
                 Geom::OptRect box = child->desktopVisualBounds();
                 if ( box && test(area, *box) && (take_insensitive || child->isVisibleAndUnlocked(dkey))) {
-                    s = g_slist_append(s, child);
+                    s.push_back(child);
                 }
             }
         }
@@ -1306,7 +1306,7 @@
     return inGroup;
 }
 
-SPItem *SPDocument::getItemFromListAtPointBottom(unsigned int dkey, SPGroup *group, GSList const *list,Geom::Point const &p, bool take_insensitive)
+SPItem *SPDocument::getItemFromListAtPointBottom(unsigned int dkey, SPGroup *group, std::vector<SPItem*> const &list,Geom::Point const &p, bool take_insensitive)
 {
     g_return_val_if_fail(group, NULL);
     SPItem *bottomMost = 0;
@@ -1320,7 +1320,7 @@
             Inkscape::DrawingItem *arenaitem = item->get_arenaitem(dkey);
             if (arenaitem && arenaitem->pick(p, delta, 1) != NULL
                 && (take_insensitive || item->isVisibleAndUnlocked(dkey))) {
-                if (g_slist_find((GSList *) list, item) != NULL) {
+                if (find(list.begin(),list.end(),item)!=list.end() ) {
                     bottomMost = item;
                 }
             }
@@ -1422,11 +1422,11 @@
  * Assumes box is normalized (and g_asserts it!)
  *
  */
-GSList *SPDocument::getItemsInBox(unsigned int dkey, Geom::Rect const &box) const
+std::vector<SPItem*> SPDocument::getItemsInBox(unsigned int dkey, Geom::Rect const &box) const
 {
-    g_return_val_if_fail(this->priv != NULL, NULL);
-
-    return find_items_in_area(NULL, SP_GROUP(this->root), dkey, box, is_within);
+    std::vector<SPItem*> x;
+    g_return_val_if_fail(this->priv != NULL, x);
+    return find_items_in_area(x, SP_GROUP(this->root), dkey, box, is_within);
 }
 
 /*
@@ -1436,16 +1436,16 @@
  *
  */
 
-GSList *SPDocument::getItemsPartiallyInBox(unsigned int dkey, Geom::Rect const &box) const
+std::vector<SPItem*> SPDocument::getItemsPartiallyInBox(unsigned int dkey, Geom::Rect const &box) const
 {
-    g_return_val_if_fail(this->priv != NULL, NULL);
-
-    return find_items_in_area(NULL, SP_GROUP(this->root), dkey, box, overlaps);
+    std::vector<SPItem*> x;
+    g_return_val_if_fail(this->priv != NULL, x);
+    return find_items_in_area(x, SP_GROUP(this->root), dkey, box, overlaps);
 }
 
-GSList *SPDocument::getItemsAtPoints(unsigned const key, std::vector<Geom::Point> points) const
+std::vector<SPItem*> SPDocument::getItemsAtPoints(unsigned const key, std::vector<Geom::Point> points) const
 {
-    GSList *items = NULL;
+    std::vector<SPItem*> items;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     // When picking along the path, we don't want small objects close together
@@ -1454,11 +1454,11 @@
     gdouble saved_delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
     prefs->setDouble("/options/cursortolerance/value", 0.25);
 
-    for(unsigned int i = 0; i < points.size(); i++) {
+    for(int i = points.size()-1;i>=0; i--) {
         SPItem *item = getItemAtPoint(key, points[i],
                                                  false, NULL);
-        if (item && !g_slist_find(items, item))
-            items = g_slist_prepend (items, item);
+        if (item && items.end()==find(items.begin(),items.end(), item))
+            items.push_back(item);
     }
 
     // and now we restore it back

=== modified file 'src/document.h'
--- src/document.h	2015-03-21 11:41:01 +0000
+++ src/document.h	2015-04-29 21:03:59 +0000
@@ -232,7 +232,7 @@
     /**
      * Returns the bottommost item from the list which is at the point, or NULL if none.
      */
-    static SPItem *getItemFromListAtPointBottom(unsigned int dkey, SPGroup *group, const GSList *list, Geom::Point const &p, bool take_insensitive = false);
+    static SPItem *getItemFromListAtPointBottom(unsigned int dkey, SPGroup *group, const std::vector<SPItem*> &list, Geom::Point const &p, bool take_insensitive = false);
 
     static SPDocument *createDoc(Inkscape::XML::Document *rdoc, char const *uri,
             char const *base, char const *name, unsigned int keepalive,
@@ -259,10 +259,10 @@
     bool addResource(char const *key, SPObject *object);
     bool removeResource(char const *key, SPObject *object);
     const GSList *getResourceList(char const *key) const;
-    GSList *getItemsInBox(unsigned int dkey, Geom::Rect const &box) const;
-    GSList *getItemsPartiallyInBox(unsigned int dkey, Geom::Rect const &box) const;
+    std::vector<SPItem*> getItemsInBox(unsigned int dkey, Geom::Rect const &box) const;
+    std::vector<SPItem*> getItemsPartiallyInBox(unsigned int dkey, Geom::Rect const &box) const;
     SPItem *getItemAtPoint(unsigned int key, Geom::Point const &p, bool into_groups, SPItem *upto = NULL) const;
-    GSList *getItemsAtPoints(unsigned const key, std::vector<Geom::Point> points) const;
+    std::vector<SPItem*> getItemsAtPoints(unsigned const key, std::vector<Geom::Point> points) const;
     SPItem *getGroupAtPoint(unsigned int key,  Geom::Point const &p) const;
 
     void changeUriAndHrefs(char const *uri);

=== modified file 'src/extension/execution-env.cpp'
--- src/extension/execution-env.cpp	2015-04-27 23:38:31 +0000
+++ src/extension/execution-env.cpp	2015-04-29 21:03:59 +0000
@@ -60,14 +60,12 @@
     sp_namedview_document_from_window(desktop);
 
     if (desktop != NULL) {
-        Inkscape::Util::GSListConstIterator<SPItem *> selected =
-             desktop->getSelection()->itemList();
-        while ( selected != NULL ) {
+    	std::vector<SPItem*> selected = desktop->getSelection()->itemList();
+        for(std::vector<SPItem*>::const_iterator x = selected.begin(); x != selected.end(); x++){
             Glib::ustring selected_id;
-            selected_id = (*selected)->getId();
+            selected_id = (*x)->getId();
             _selected.insert(_selected.end(), selected_id);
             //std::cout << "Selected: " << selected_id << std::endl;
-            ++selected;
         }
     }
 

=== modified file 'src/extension/implementation/implementation.cpp'
--- src/extension/implementation/implementation.cpp	2014-12-21 21:58:32 +0000
+++ src/extension/implementation/implementation.cpp	2015-04-29 21:03:59 +0000
@@ -47,12 +47,10 @@
 
     SPDocument * current_document = view->doc();
 
-    using Inkscape::Util::GSListConstIterator;
-    // FIXME very unsafe cast
-    GSListConstIterator<SPItem *> selected = ((SPDesktop *)view)->getSelection()->itemList();
+    std::vector<SPItem*> selected = ((SPDesktop *)view)->getSelection()->itemList();
     Inkscape::XML::Node const* first_select = NULL;
-    if (selected != NULL) {
-        const SPItem * item = *selected;
+    if (!selected.empty()) {
+        const SPItem * item = selected[0];
         first_select = item->getRepr();
     }
 

=== modified file 'src/extension/implementation/script.cpp'
--- src/extension/implementation/script.cpp	2015-04-27 16:01:19 +0000
+++ src/extension/implementation/script.cpp	2015-04-29 21:03:59 +0000
@@ -689,14 +689,13 @@
         return;
     }
 
-    Inkscape::Util::GSListConstIterator<SPItem *> selected =
+    std::vector<SPItem*> selected =
         desktop->getSelection()->itemList(); //desktop should not be NULL since doc was checked and desktop is a casted pointer
-    while ( selected != NULL ) {
+    for(std::vector<SPItem*>::const_iterator x = selected.begin(); x != selected.end(); x++){
         Glib::ustring selected_id;
         selected_id += "--id=";
-        selected_id += (*selected)->getId();
+        selected_id += (*x)->getId();
         params.insert(params.begin(), selected_id);
-        ++selected;
     }
 
     file_listener fileout;

=== modified file 'src/extension/internal/bitmap/imagemagick.cpp'
--- src/extension/internal/bitmap/imagemagick.cpp	2015-04-27 23:38:31 +0000
+++ src/extension/internal/bitmap/imagemagick.cpp	2015-04-29 21:03:59 +0000
@@ -66,8 +66,8 @@
     _imageItems(NULL)
 {
     SPDesktop *desktop = (SPDesktop*)view;
-    const GSList *selectedItemList = desktop->selection->itemList();
-    int selectCount = g_slist_length((GSList *)selectedItemList);
+    const std::vector<SPItem*> selectedItemList = desktop->selection->itemList();
+    int selectCount = selectedItemList.size();
     
     // Init the data-holders
     _nodes = new Inkscape::XML::Node*[selectCount];
@@ -79,9 +79,8 @@
     _imageItems = new SPItem*[selectCount];
 
     // Loop through selected items
-    for (; selectedItemList != NULL; selectedItemList = g_slist_next(selectedItemList))
-    {
-        SPItem *item = SP_ITEM(selectedItemList->data);
+    for (std::vector<SPItem*>::const_iterator i = selectedItemList.begin(); i != selectedItemList.end(); i++) {
+        SPItem *item = *i;
         Inkscape::XML::Node *node = reinterpret_cast<Inkscape::XML::Node *>(item->getRepr());
         if (!strcmp(node->name(), "image") || !strcmp(node->name(), "svg:image"))
         {
@@ -237,13 +236,10 @@
 {
     SPDocument * current_document = view->doc();
 
-    using Inkscape::Util::GSListConstIterator;
-
-    // FIXME very unsafe cast
-    GSListConstIterator<SPItem *> selected = ((SPDesktop *)view)->getSelection()->itemList();
+    std::vector<SPItem*> selected = ((SPDesktop *)view)->getSelection()->itemList();
     Inkscape::XML::Node * first_select = NULL;
-    if (selected != NULL) {
-        first_select = (*selected)->getRepr();
+    if (!selected.empty()) {
+        first_select = (selected.front())->getRepr();
     }
 
     return module->autogui(current_document, first_select, changeSignal);

=== modified file 'src/extension/internal/bluredge.cpp'
--- src/extension/internal/bluredge.cpp	2014-03-27 01:33:44 +0000
+++ src/extension/internal/bluredge.cpp	2015-04-29 21:03:59 +0000
@@ -63,13 +63,11 @@
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double old_offset = prefs->getDouble("/options/defaultoffsetwidth/value", 1.0, "px");
 
-    using Inkscape::Util::GSListConstIterator;
     // TODO need to properly refcount the items, at least
-    std::list<SPItem *> items;
-    items.insert<GSListConstIterator<SPItem *> >(items.end(), selection->itemList(), NULL);
+    std::vector<SPItem*> items(selection->itemList());
     selection->clear();
 
-    for(std::list<SPItem *>::iterator item = items.begin();
+    for(std::vector<SPItem*>::iterator item = items.begin();
             item != items.end(); ++item) {
         SPItem * spitem = *item;
 

=== modified file 'src/extension/internal/cairo-renderer.cpp'
--- src/extension/internal/cairo-renderer.cpp	2015-03-17 17:09:10 +0000
+++ src/extension/internal/cairo-renderer.cpp	2015-04-29 21:03:59 +0000
@@ -294,14 +294,12 @@
     CairoRenderer *renderer = ctx->getRenderer();
     TRACE(("sp_group_render opacity: %f\n", SP_SCALE24_TO_FLOAT(item->style->opacity.value)));
 
-    GSList *l = g_slist_reverse(group->childList(false));
-    while (l) {
-        SPObject *o = reinterpret_cast<SPObject *>(l->data);
-        SPItem *item = dynamic_cast<SPItem *>(o);
+    std::vector<SPObject*> l(group->childList(false));
+    for(std::vector<SPObject*>::const_iterator x = l.begin(); x!= l.end(); x++){
+        SPItem *item = static_cast<SPItem*>(*x);
         if (item) {
             renderer->renderItem(ctx, item);
         }
-        l = g_slist_remove (l, o);
     }
 }
 

=== modified file 'src/extension/internal/filter/filter.cpp'
--- src/extension/internal/filter/filter.cpp	2014-03-27 01:33:44 +0000
+++ src/extension/internal/filter/filter.cpp	2015-04-29 21:03:59 +0000
@@ -125,15 +125,13 @@
 	//printf("Calling filter effect\n");
     Inkscape::Selection * selection = ((SPDesktop *)document)->selection;
 
-    using Inkscape::Util::GSListConstIterator;
     // TODO need to properly refcount the items, at least
-    std::list<SPItem *> items;
-    items.insert<GSListConstIterator<SPItem *> >(items.end(), selection->itemList(), NULL);
+    std::vector<SPItem*> items(selection->itemList());
 
 	Inkscape::XML::Document * xmldoc = document->doc()->getReprDoc();
 	Inkscape::XML::Node * defsrepr = document->doc()->getDefs()->getRepr();
 
-    for(std::list<SPItem *>::iterator item = items.begin();
+    for(std::vector<SPItem*>::iterator item = items.begin();
             item != items.end(); ++item) {
         SPItem * spitem = *item;
 	Inkscape::XML::Node * node = spitem->getRepr();

=== modified file 'src/extension/internal/grid.cpp'
--- src/extension/internal/grid.cpp	2015-04-27 23:38:31 +0000
+++ src/extension/internal/grid.cpp	2015-04-29 21:03:59 +0000
@@ -186,13 +186,10 @@
 {
     SPDocument * current_document = view->doc();
 
-    using Inkscape::Util::GSListConstIterator;
-
-    // FIXME very unsafe cast
-    GSListConstIterator<SPItem *> selected = ((SPDesktop *)view)->getSelection()->itemList();
+    std::vector<SPItem*> selected = ((SPDesktop *)view)->getSelection()->itemList();
     Inkscape::XML::Node * first_select = NULL;
-    if (selected != NULL) {
-        first_select = (*selected)->getRepr();
+    if (!selected.empty()) {
+        first_select = selected[0]->getRepr();
     }
 
     return module->autogui(current_document, first_select, changeSignal);

=== modified file 'src/extension/internal/latex-text-renderer.cpp'
--- src/extension/internal/latex-text-renderer.cpp	2014-11-10 17:39:33 +0000
+++ src/extension/internal/latex-text-renderer.cpp	2015-04-29 21:03:59 +0000
@@ -228,14 +228,12 @@
 
 void LaTeXTextRenderer::sp_group_render(SPGroup *group)
 {
-    GSList *l = g_slist_reverse(group->childList(false));
-    while (l) {
-        SPObject *o = reinterpret_cast<SPObject *>(l->data);
-        SPItem *item = dynamic_cast<SPItem *>(o);
+	std::vector<SPObject*> l = (group->childList(false));
+    for(std::vector<SPObject*>::const_iterator x = l.begin(); x != l.end(); x++){
+        SPItem *item = static_cast<SPItem*>(*x);
         if (item) {
             renderItem(item);
         }
-        l = g_slist_remove (l, o);
     }
 }
 

=== modified file 'src/file.cpp'
--- src/file.cpp	2015-02-23 16:48:29 +0000
+++ src/file.cpp	2015-04-29 21:03:59 +0000
@@ -1069,7 +1069,7 @@
     desktop->doc()->importDefs(clipdoc);
 
     // copy objects
-    GSList *pasted_objects = NULL;
+    std::vector<Inkscape::XML::Node*> pasted_objects;
     for (Inkscape::XML::Node *obj = root->firstChild() ; obj ; obj = obj->next()) {
         // Don't copy metadata, defs, named views and internal clipboard contents to the document
         if (!strcmp(obj->name(), "svg:defs")) {
@@ -1088,9 +1088,8 @@
         target_parent->appendChild(obj_copy);
         Inkscape::GC::release(obj_copy);
 
-        pasted_objects = g_slist_prepend(pasted_objects, (gpointer) obj_copy);
+        pasted_objects.push_back(obj_copy);
     }
-
     // Change the selection to the freshly pasted objects
     Inkscape::Selection *selection = desktop->getSelection();
     selection->setReprList(pasted_objects);
@@ -1129,8 +1128,6 @@
 
         sp_selection_move_relative(selection, offset);
     }
-
-    g_slist_free(pasted_objects);
 }
 
 

=== modified file 'src/gradient-chemistry.cpp'
--- src/gradient-chemistry.cpp	2015-03-01 08:57:53 +0000
+++ src/gradient-chemistry.cpp	2015-04-29 21:03:59 +0000
@@ -1570,8 +1570,9 @@
 {
     Inkscape::Selection *selection = desktop->getSelection();
 
-    for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
-        sp_item_gradient_invert_vector_color(SP_ITEM(i->data), fill_or_stroke);
+    const std::vector<SPItem*> list=selection->itemList();
+    for (std::vector<SPItem*>::const_iterator i = list.begin(); i != list.end(); i++) {
+        sp_item_gradient_invert_vector_color(*i, fill_or_stroke);
     }
 
     // we did an undoable action
@@ -1594,9 +1595,10 @@
     if (drag && drag->selected) {
         drag->selected_reverse_vector();
     } else { // If no drag or no dragger selected, act on selection (both fill and stroke gradients)
-        for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
-            sp_item_gradient_reverse_vector(SP_ITEM(i->data), Inkscape::FOR_FILL);
-            sp_item_gradient_reverse_vector(SP_ITEM(i->data), Inkscape::FOR_STROKE);
+        const std::vector<SPItem*> list=selection->itemList();
+        for (std::vector<SPItem*>::const_iterator i = list.begin(); i != list.end(); i++) {
+            sp_item_gradient_reverse_vector(*i, Inkscape::FOR_FILL);
+            sp_item_gradient_reverse_vector(*i, Inkscape::FOR_STROKE);
         }
     }
 

=== modified file 'src/gradient-drag.cpp'
--- src/gradient-drag.cpp	2015-03-01 08:57:53 +0000
+++ src/gradient-drag.cpp	2015-04-29 21:03:59 +0000
@@ -2082,9 +2082,9 @@
     this->draggers = NULL;
 
     g_return_if_fail(this->selection != NULL);
-
-    for (GSList const* i = this->selection->itemList(); i != NULL; i = i->next) {
-        SPItem *item = SP_ITEM(i->data);
+    std::vector<SPItem*> list = this->selection->itemList();
+    for (std::vector<SPItem*>::const_iterator i = list.begin(); i != list.end(); i++) {
+        SPItem *item = *i;
         SPStyle *style = item->style;
 
         if (style && (style->fill.isPaintserver())) {
@@ -2151,9 +2151,9 @@
 
     g_return_if_fail(this->selection != NULL);
 
-    for (GSList const* i = this->selection->itemList(); i != NULL; i = i->next) {
-
-        SPItem *item = SP_ITEM(i->data);
+    std::vector<SPItem*> list = this->selection->itemList();
+    for (std::vector<SPItem*>::const_iterator i = list.begin(); i != list.end(); i++) {
+        SPItem *item = *i;
 
         SPStyle *style = item->style;
 
@@ -2295,8 +2295,9 @@
 
     g_return_if_fail (this->selection != NULL);
 
-    for (GSList const* i = this->selection->itemList(); i != NULL; i = i->next) {
-        SPItem *item = SP_ITEM(i->data);
+    std::vector<SPItem*> list = this->selection->itemList();
+    for (std::vector<SPItem*>::const_iterator i = list.begin(); i != list.end(); i++) {
+        SPItem *item = *i;
         Geom::OptRect rect = item->desktopVisualBounds();
         if (rect) {
             // Remember the edges of the bbox and the center axis

=== modified file 'src/graphlayout.cpp'
--- src/graphlayout.cpp	2014-11-26 01:35:57 +0000
+++ src/graphlayout.cpp	2015-04-29 21:03:59 +0000
@@ -88,9 +88,9 @@
  * Scans the items list and places those items that are
  * not connectors in filtered
  */
-void filterConnectors(GSList const *const items, list<SPItem *> &filtered) {
-    for(GSList *i=(GSList *)items; i!=NULL; i=i->next) {
-        SPItem *item=SP_ITEM(i->data);
+void filterConnectors(std::vector<SPItem*> const &items, list<SPItem *> &filtered) {
+    for(std::vector<SPItem*>::const_iterator i = items.begin();i !=items.end(); i++){
+        SPItem *item = *i;
         if(!isConnector(item)) {
             filtered.push_back(item);
         }
@@ -101,8 +101,8 @@
 * connectors between them, and uses graph layout techniques to find
 * a nice layout
 */
-void graphlayout(GSList const *const items) {
-    if(!items) {
+void graphlayout(std::vector<SPItem*> const &items) {
+    if(items.empty()) {
         return;
     }
 

=== modified file 'src/graphlayout.h'
--- src/graphlayout.h	2014-10-08 02:22:03 +0000
+++ src/graphlayout.h	2015-04-29 21:03:59 +0000
@@ -19,10 +19,10 @@
 typedef struct _GSList GSList;
 class SPItem;
 
-void graphlayout(GSList const *const items);
+void graphlayout(std::vector<SPItem*> const &items);
 
 bool isConnector(SPItem const *const item);
 
-void filterConnectors(GSList const *const items, std::list<SPItem *> &filtered);
+void filterConnectors(std::vector<SPItem*> const &items, std::list<SPItem *> &filtered);
 
 #endif // SEEN_GRAPHLAYOUT_H

=== modified file 'src/helper/png-write.cpp'
--- src/helper/png-write.cpp	2014-10-05 16:38:15 +0000
+++ src/helper/png-write.cpp	2015-04-29 21:03:59 +0000
@@ -361,19 +361,19 @@
 /**
  * Hide all items that are not listed in list, recursively, skipping groups and defs.
  */
-static void hide_other_items_recursively(SPObject *o, GSList *list, unsigned dkey)
+static void hide_other_items_recursively(SPObject *o, const std::vector<SPItem*> &list, unsigned dkey)
 {
     if ( SP_IS_ITEM(o)
          && !SP_IS_DEFS(o)
          && !SP_IS_ROOT(o)
          && !SP_IS_GROUP(o)
-         && !g_slist_find(list, o) )
+         && list.end()==find(list.begin(),list.end(),o))
     {
         SP_ITEM(o)->invoke_hide(dkey);
     }
 
     // recurse
-    if (!g_slist_find(list, o)) {
+    if (list.end()==find(list.begin(),list.end(),o)) {
         for ( SPObject *child = o->firstChild() ; child; child = child->getNext() ) {
             hide_other_items_recursively(child, list, dkey);
         }
@@ -387,7 +387,7 @@
                                 unsigned long bgcolor,
                                 unsigned int (*status) (float, void *),
                                 void *data, bool force_overwrite,
-                                GSList *items_only)
+                                const std::vector<SPItem*> &items_only)
 {
     return sp_export_png_file(doc, filename, Geom::Rect(Geom::Point(x0,y0),Geom::Point(x1,y1)),
                               width, height, xdpi, ydpi, bgcolor, status, data, force_overwrite, items_only);
@@ -399,7 +399,7 @@
                                 unsigned long bgcolor,
                                 unsigned (*status)(float, void *),
                                 void *data, bool force_overwrite,
-                                GSList *items_only)
+                                const std::vector<SPItem*> &items_only)
 {
     g_return_val_if_fail(doc != NULL, EXPORT_ERROR);
     g_return_val_if_fail(filename != NULL, EXPORT_ERROR);
@@ -457,7 +457,7 @@
 
     // We show all and then hide all items we don't want, instead of showing only requested items,
     // because that would not work if the shown item references something in defs
-    if (items_only) {
+    if (!items_only.empty()) {
         hide_other_items_recursively(doc->getRoot(), items_only, dkey);
     }
 

=== modified file 'src/helper/png-write.h'
--- src/helper/png-write.h	2014-03-27 01:33:44 +0000
+++ src/helper/png-write.h	2015-04-29 21:03:59 +0000
@@ -14,8 +14,9 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glib.h>
 #include <2geom/forward.h>
+
+
 class SPDocument;
 
 enum ExportResult {
@@ -33,12 +34,12 @@
 				double x0, double y0, double x1, double y1,
 				unsigned long int width, unsigned long int height, double xdpi, double ydpi,
 				unsigned long bgcolor,
-				unsigned int (*status) (float, void *), void *data, bool force_overwrite = false, GSList *items_only = NULL);
+				unsigned int (*status) (float, void *), void *data, bool force_overwrite = false, const std::vector<SPItem*> &items_only = std::vector<SPItem*>());
 
 ExportResult sp_export_png_file(SPDocument *doc, gchar const *filename,
 				Geom::Rect const &area,
 				unsigned long int width, unsigned long int height, double xdpi, double ydpi,
 				unsigned long bgcolor,
-				unsigned int (*status) (float, void *), void *data, bool force_overwrite = false, GSList *items_only = NULL);
+				unsigned int (*status) (float, void *), void *data, bool force_overwrite = false, const std::vector<SPItem*> &items_only = std::vector<SPItem*>());
 
 #endif // SEEN_SP_PNG_WRITE_H

=== modified file 'src/live_effects/lpe-knot.cpp'
--- src/live_effects/lpe-knot.cpp	2015-03-08 16:10:20 +0000
+++ src/live_effects/lpe-knot.cpp	2015-04-29 21:03:59 +0000
@@ -505,9 +505,9 @@
 static void
 collectPathsAndWidths (SPLPEItem const *lpeitem, std::vector<Geom::Path> &paths, std::vector<double> &stroke_widths){
     if (SP_IS_GROUP(lpeitem)) {
-        GSList const *item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
-        for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-            SPObject *subitem = static_cast<SPObject *>(iter->data);
+    	std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
+        for ( std::vector<SPItem*>::const_iterator iter = item_list.begin(); iter != item_list.end(); iter++) {
+            SPObject *subitem = *iter;
             if (SP_IS_LPE_ITEM(subitem)) {
                 collectPathsAndWidths(SP_LPE_ITEM(subitem), paths, stroke_widths);
             }

=== modified file 'src/main.cpp'
--- src/main.cpp	2015-02-26 02:49:35 +0000
+++ src/main.cpp	2015-04-29 21:03:59 +0000
@@ -1156,7 +1156,7 @@
             }
             if (sp_export_svg) {
                 if (sp_export_text_to_path) {
-                    GSList *items = NULL;
+                	std::vector<SPItem*> items;
                     SPRoot *root = doc->getRoot();
                     doc->ensureUpToDate();
                     for ( SPObject *iter = root->firstChild(); iter ; iter = iter->getNext()) {
@@ -1166,17 +1166,14 @@
                         }
 
                         te_update_layout_now_recursive(item);
-                        items = g_slist_append(items, item);
+                        items.push_back(item);
                     }
 
-                    GSList *selected = NULL;
-                    GSList *to_select = NULL;
-
-                    sp_item_list_to_curves(items, &selected, &to_select);
-
-                    g_slist_free (items);
-                    g_slist_free (selected);
-                    g_slist_free (to_select);
+                    std::vector<SPItem*> selected;
+                    std::vector<Inkscape::XML::Node*> to_select;
+
+                    sp_item_list_to_curves(items, selected, to_select);
+
                 }
                 if(sp_export_id) {
                     doc->ensureUpToDate();
@@ -1435,7 +1432,7 @@
         g_warning ("--export-use-hints can only be used with --export-id or --export-area-drawing; ignored.");
     }
 
-    GSList *items = NULL;
+    std::vector<SPItem*> items;
 
     Geom::Rect area;
     if (sp_export_id || sp_export_area_drawing) {
@@ -1459,7 +1456,7 @@
                 return 1;
             }
 
-            items = g_slist_prepend (items, SP_ITEM(o));
+            items.push_back(SP_ITEM(o));
 
             if (sp_export_id_only) {
                 g_print("Exporting only object with id=\"%s\"; all other objects hidden\n", sp_export_id);
@@ -1644,10 +1641,12 @@
         g_print("Background RRGGBBAA: %08x\n", bgcolor);
 
         g_print("Area %g:%g:%g:%g exported to %lu x %lu pixels (%g dpi)\n", area[Geom::X][0], area[Geom::Y][0], area[Geom::X][1], area[Geom::Y][1], width, height, dpi);
-
+        
+        reverse(items.begin(),items.end());
+        
         if ((width >= 1) && (height >= 1) && (width <= PNG_UINT_31_MAX) && (height <= PNG_UINT_31_MAX)) {
             if( sp_export_png_file(doc, path.c_str(), area, width, height, dpi,
-              dpi, bgcolor, NULL, NULL, true, sp_export_id_only ? items : NULL) == 1 ) {
+              dpi, bgcolor, NULL, NULL, true, sp_export_id_only ? items : std::vector<SPItem*>()) == 1 ) {
                 g_print("Bitmap saved as: %s\n", filename.c_str());
             } else {
                 g_warning("Bitmap failed to save to: %s", filename.c_str());
@@ -1657,7 +1656,6 @@
         }
     }
 
-    g_slist_free (items);
     return retcode;
 }
 

=== modified file 'src/object-snapper.cpp'
--- src/object-snapper.cpp	2014-11-10 17:39:33 +0000
+++ src/object-snapper.cpp	2015-04-29 21:03:59 +0000
@@ -237,8 +237,9 @@
                 // current selection (see the comment in SelTrans::centerRequest())
                 bool old_pref2 = _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_ROTATION_CENTER);
                 if (old_pref2) {
-                    for ( GSList const *itemlist = _snapmanager->getRotationCenterSource(); itemlist != NULL; itemlist = g_slist_next(itemlist) ) {
-                        if ((*i).item == reinterpret_cast<SPItem*>(itemlist->data)) {
+                	std::vector<SPItem*> rotationSource=_snapmanager->getRotationCenterSource();
+                    for ( std::vector<SPItem*>::const_iterator itemlist = rotationSource.begin(); itemlist != rotationSource.end(); itemlist++) {
+                        if ((*i).item == *itemlist) {
                             // don't snap to this item's rotation center
                             _snapmanager->snapprefs.setTargetSnappable(SNAPTARGET_ROTATION_CENTER, false);
                             break;

=== modified file 'src/object-test.h'
--- src/object-test.h	2015-02-21 16:23:30 +0000
+++ src/object-test.h	2015-04-29 21:03:59 +0000
@@ -204,7 +204,8 @@
         assert(n_group != NULL);
 
         begin = clock();
-        sp_item_group_ungroup(n_group, NULL, false);
+        std::vector<SPItem*> ch;
+        sp_item_group_ungroup(n_group, ch, false);
         end = clock();
 
         std::cout << "Took " << double(end - begin) / double(CLOCKS_PER_SEC) << " seconds to ungroup a <g> with " << num_elements << " elements\n";

=== modified file 'src/path-chemistry.cpp'
--- src/path-chemistry.cpp	2015-04-28 14:26:17 +0000
+++ src/path-chemistry.cpp	2015-04-29 21:03:59 +0000
@@ -44,13 +44,22 @@
 
 using Inkscape::DocumentUndo;
 
+
+inline bool less_than_items(SPItem const *first, SPItem const *second)
+{
+    return sp_repr_compare_position(first->getRepr(),
+                                    second->getRepr())<0;
+}
+
 void
 sp_selected_path_combine(SPDesktop *desktop)
 {
     Inkscape::Selection *selection = desktop->getSelection();
     SPDocument *doc = desktop->getDocument();
+
+    std::vector<SPItem*> items(selection->itemList());
     
-    if (g_slist_length((GSList *) selection->itemList()) < 1) {
+    if (items.size() < 1) {
         desktop->getMessageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to combine."));
         return;
     }
@@ -59,28 +68,23 @@
     // set "busy" cursor
     desktop->setWaitingCursor();
 
-    GSList *items = g_slist_copy((GSList *) selection->itemList());
-
     items = sp_degroup_list (items); // descend into any groups in selection
 
-    GSList *to_paths = NULL;
-    for (GSList *i = items; i != NULL; i = i->next) {
-        SPItem *item = (SPItem *) i->data;
-        if (!dynamic_cast<SPPath *>(item) && !dynamic_cast<SPGroup *>(item)) {
-            to_paths = g_slist_prepend(to_paths, item);
+    std::vector<SPItem*> to_paths;
+    for (std::vector<SPItem*>::const_reverse_iterator i = items.rbegin(); i != items.rend(); i++) {
+        if (!dynamic_cast<SPPath *>(*i) && !dynamic_cast<SPGroup *>(*i)) {
+            to_paths.push_back(*i);
         }
     }
-    GSList *converted = NULL;
-    bool did = sp_item_list_to_curves(to_paths, &items, &converted);
-    g_slist_free(to_paths);
-    for (GSList *i = converted; i != NULL; i = i->next)
-        items = g_slist_prepend(items, doc->getObjectByRepr((Inkscape::XML::Node*)(i->data)));
+    std::vector<Inkscape::XML::Node*> converted;
+    bool did = sp_item_list_to_curves(to_paths, items, converted);
+    for (std::vector<Inkscape::XML::Node*>::const_iterator i = converted.begin(); i != converted.end(); i++)
+        items.push_back((SPItem*)doc->getObjectByRepr(*i));
 
     items = sp_degroup_list (items); // converting to path may have added more groups, descend again
 
-    items = g_slist_sort(items, (GCompareFunc) sp_item_repr_compare_position);
-    items = g_slist_reverse(items);
-    assert(items); // cannot be NULL because of list length check at top of function
+    sort(items.begin(),items.end(),less_than_items);
+    assert(!items.empty()); // cannot be NULL because of list length check at top of function
 
     // remember the position, id, transform and style of the topmost path, they will be assigned to the combined one
     gint position = 0;
@@ -97,9 +101,9 @@
         selection->clear();
     }
 
-    for (GSList *i = items; i != NULL; i = i->next) {  // going from top to bottom
+    for (std::vector<SPItem*>::const_reverse_iterator i = items.rbegin(); i != items.rend(); i++){
 
-        SPItem *item = (SPItem *) i->data;
+        SPItem *item = *i;
         SPPath *path = dynamic_cast<SPPath *>(item);
         if (!path) {
             continue;
@@ -136,7 +140,6 @@
         }
     }
 
-    g_slist_free(items);
 
     if (did) {
         first->deleteObject(false);
@@ -200,11 +203,10 @@
 
     bool did = false;
 
-    for (GSList *items = g_slist_copy((GSList *) selection->itemList());
-         items != NULL;
-         items = items->next) {
+    std::vector<SPItem*> itemlist(selection->itemList());
+    for (std::vector<SPItem*>::const_iterator i = itemlist.begin(); i != itemlist.end(); i++){
 
-        SPItem *item = (SPItem *) items->data;
+        SPItem *item = *i;
 
         SPPath *path = dynamic_cast<SPPath *>(item);
         if (!path) {
@@ -241,7 +243,7 @@
 
         curve->unref();
 
-        GSList *reprs = NULL;
+        std::vector<Inkscape::XML::Node*> reprs;
         for (GSList *l = list; l != NULL; l = l->next) {
             curve = (SPCurve *) l->data;
 
@@ -267,14 +269,12 @@
             if (l == list)
                 repr->setAttribute("id", id);
 
-            reprs = g_slist_prepend (reprs, repr);
+            reprs.push_back(repr);
 
             Inkscape::GC::release(repr);
         }
-
         selection->setReprList(reprs);
 
-        g_slist_free(reprs);
         g_slist_free(list);
         g_free(style);
         g_free(path_effect);
@@ -307,18 +307,15 @@
         desktop->setWaitingCursor();
     }
 
-    GSList *selected = g_slist_copy((GSList *) selection->itemList());
-    GSList *to_select = NULL;
+    std::vector<SPItem*> selected(selection->itemList());
+    std::vector<Inkscape::XML::Node*> to_select;
     selection->clear();
-    GSList *items = g_slist_copy(selected);
-
-    did = sp_item_list_to_curves(items, &selected, &to_select);
-
-    g_slist_free (items);
+    std::vector<SPItem*> items(selected);
+
+    did = sp_item_list_to_curves(items, selected, to_select);
+
     selection->setReprList(to_select);
     selection->addList(selected);
-    g_slist_free (to_select);
-    g_slist_free (selected);
 
     if (interactive && desktop) {
         desktop->clearWaitingCursor();
@@ -341,33 +338,24 @@
         return;
     }
 
-    GSList *selected = g_slist_copy((GSList *) selection->itemList());
-    GSList *to_select = NULL;
+    std::vector<SPItem*> selected(selection->itemList());
+    std::vector<Inkscape::XML::Node*> to_select;
     selection->clear();
-    GSList *items = g_slist_copy(selected);
-
-    sp_item_list_to_curves(items, &selected, &to_select, true);
-
-    g_slist_free(items);
-    items = 0;
+    std::vector<SPItem*> items(selected);
+
+
+    sp_item_list_to_curves(items, selected, to_select, true);
+
     selection->setReprList(to_select);
     selection->addList(selected);
-    g_slist_free(to_select);
-    to_select = 0;
-    g_slist_free(selected);
-    selected = 0;
 }
 
 bool
-sp_item_list_to_curves(const GSList *items, GSList **selected, GSList **to_select, bool skip_all_lpeitems)
+sp_item_list_to_curves(const std::vector<SPItem*> &items, std::vector<SPItem*>& selected, std::vector<Inkscape::XML::Node*> &to_select, bool skip_all_lpeitems)
 {
     bool did = false;
-
-    for (;
-         items != NULL;
-         items = items->next) {
-
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(items->data));
+    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++){
+        SPItem *item = *i;
         g_assert(item != NULL);
         SPDocument *document = item->document;
 
@@ -398,9 +386,9 @@
             Inkscape::XML::Node *repr = box3d_convert_to_group(box)->getRepr();
             
             if (repr) {
-                *to_select = g_slist_prepend (*to_select, repr);
+                to_select.insert(to_select.begin(),repr);
                 did = true;
-                *selected = g_slist_remove (*selected, item);
+                selected.erase(find(selected.begin(),selected.end(),item));
             }
 
             continue;
@@ -408,17 +396,14 @@
         
         if (group) {
             group->removeAllPathEffects(true);
-            GSList *item_list = sp_item_group_item_list(group);
-            
-            GSList *item_to_select = NULL;
-            GSList *item_selected = NULL;
-            
-            if (sp_item_list_to_curves(item_list, &item_selected, &item_to_select))
+            std::vector<SPItem*> item_list = sp_item_group_item_list(group);
+            
+            std::vector<Inkscape::XML::Node*> item_to_select;
+            std::vector<SPItem*> item_selected;
+            
+            if (sp_item_list_to_curves(item_list, item_selected, item_to_select))
                 did = true;
 
-            g_slist_free(item_list);
-            g_slist_free(item_to_select);
-            g_slist_free(item_selected);
 
             continue;
         }
@@ -428,7 +413,7 @@
             continue;
 
         did = true;
-        *selected = g_slist_remove (*selected, item);
+        selected.erase(find(selected.begin(),selected.end(),item));
 
         // remember the position of the item
         gint pos = item->getRepr()->position();
@@ -470,7 +455,7 @@
 
         /* Buglet: We don't re-add the (new version of the) object to the selection of any other
          * desktops where it was previously selected. */
-        *to_select = g_slist_prepend (*to_select, repr);
+        to_select.insert(to_select.begin(),repr);
         Inkscape::GC::release(repr);
     }
     
@@ -622,9 +607,9 @@
 sp_selected_path_reverse(SPDesktop *desktop)
 {
     Inkscape::Selection *selection = desktop->getSelection();
-    GSList *items = (GSList *) selection->itemList();
+    std::vector<SPItem*> items = selection->itemList();
 
-    if (!items) {
+    if (items.empty()) {
         desktop->getMessageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>path(s)</b> to reverse."));
         return;
     }
@@ -636,9 +621,9 @@
     bool did = false;
     desktop->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Reversing paths..."));
 
-    for (GSList *i = items; i != NULL; i = i->next) {
+    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++){
 
-        SPPath *path = dynamic_cast<SPPath *>(static_cast<SPObject *>(i->data));
+        SPPath *path = dynamic_cast<SPPath *>(*i);
         if (!path) {
             continue;
         }

=== modified file 'src/path-chemistry.h'
--- src/path-chemistry.h	2014-10-08 02:22:03 +0000
+++ src/path-chemistry.h	2015-04-29 21:03:59 +0000
@@ -33,7 +33,7 @@
 void sp_selected_to_lpeitems(SPDesktop *desktop);
 Inkscape::XML::Node *sp_selected_item_to_curved_repr(SPItem *item, guint32 text_grouping_policy);
 void sp_selected_path_reverse (SPDesktop *desktop);
-bool sp_item_list_to_curves(const GSList *items, GSList **selected, GSList **to_select, bool skip_all_lpeitems = false);
+bool sp_item_list_to_curves(const std::vector<SPItem*> &items, std::vector<SPItem*> &selected, std::vector<Inkscape::XML::Node*> &to_select, bool skip_all_lpeitems = false);
 
 #endif // SEEN_PATH_CHEMISTRY_H
 

=== modified file 'src/removeoverlap.cpp'
--- src/removeoverlap.cpp	2014-03-27 01:33:44 +0000
+++ src/removeoverlap.cpp	2015-04-29 21:03:59 +0000
@@ -38,20 +38,19 @@
 * such that rectangular bounding boxes are separated by at least xGap
 * horizontally and yGap vertically
 */
-void removeoverlap(GSList const *const items, double const xGap, double const yGap) {
-	using Inkscape::Util::GSListConstIterator;
-	std::list<SPItem *> selected;
-	selected.insert<GSListConstIterator<SPItem *> >(selected.end(), items, NULL);
+void removeoverlap(std::vector<SPItem*> const &items, double const xGap, double const yGap) {
+	std::vector<SPItem*> selected(items);
 	std::vector<Record> records;
 	std::vector<Rectangle *> rs;
 
 	Geom::Point const gap(xGap, yGap);
-	for (std::list<SPItem *>::iterator it(selected.begin());
+	for (std::vector<SPItem*>::iterator it(selected.begin());
 		it != selected.end();
 		++it)
 	{
+    	SPItem* item = *it;
 		using Geom::X; using Geom::Y;
-		Geom::OptRect item_box((*it)->desktopVisualBounds());
+		Geom::OptRect item_box((item)->desktopVisualBounds());
 		if (item_box) {
 			Geom::Point min(item_box->min() - .5*gap);
 			Geom::Point max(item_box->max() + .5*gap);
@@ -67,7 +66,7 @@
 				min[Y] = max[Y] = (min[Y] + max[Y])/2;
 			}
 			Rectangle *vspc_rect = new Rectangle(min[X], max[X], min[Y], max[Y]);
-			records.push_back(Record(*it, item_box->midpoint(), vspc_rect));
+			records.push_back(Record(item, item_box->midpoint(), vspc_rect));
 			rs.push_back(vspc_rect);
 		}
 	}

=== modified file 'src/removeoverlap.h'
--- src/removeoverlap.h	2014-10-08 02:22:03 +0000
+++ src/removeoverlap.h	2015-04-29 21:03:59 +0000
@@ -15,6 +15,6 @@
 
 typedef struct _GSList GSList;
 
-void removeoverlap(GSList const *items, double xGap, double yGap);
+void removeoverlap(std::vector<SPItem*> const &items, double xGap, double yGap);
 
 #endif // SEEN_REMOVEOVERLAP_H

=== modified file 'src/selcue.cpp'
--- src/selcue.cpp	2014-12-21 21:58:32 +0000
+++ src/selcue.cpp	2015-04-29 21:03:59 +0000
@@ -96,15 +96,16 @@
 
 void Inkscape::SelCue::_updateItemBboxes(gint mode, int prefs_bbox)
 {
-    GSList const *items = _selection->itemList();
-    if (_item_bboxes.size() != g_slist_length((GSList *) items)) {
+    const std::vector<SPItem*> items = _selection->itemList();
+    if (_item_bboxes.size() != items.size()) {
         _newItemBboxes();
         return;
     }
 
     int bcount = 0;
-    for (GSList const *l = _selection->itemList(); l != NULL; l = l->next) {
-        SPItem *item = static_cast<SPItem *>(l->data);
+    std::vector<SPItem*> ll=_selection->itemList();
+    for (std::vector<SPItem*>::const_iterator l = ll.begin(); l != ll.end(); l++) {
+        SPItem *item = *l;
         SPCanvasItem* box = _item_bboxes[bcount ++];
 
         if (box) {
@@ -145,8 +146,9 @@
 
     int prefs_bbox = prefs->getBool("/tools/bounding_box");
     
-    for (GSList const *l = _selection->itemList(); l != NULL; l = l->next) {
-        SPItem *item = static_cast<SPItem *>(l->data);
+    std::vector<SPItem*> ll=_selection->itemList();
+    for (std::vector<SPItem*>::const_iterator l = ll.begin(); l != ll.end(); l++) {
+        SPItem *item = *l;
 
         Geom::OptRect const b = (prefs_bbox == 0) ?
             item->desktopVisualBounds() : item->desktopGeometricBounds();
@@ -199,8 +201,9 @@
     }
     _text_baselines.clear();
 
-    for (GSList const *l = _selection->itemList(); l != NULL; l = l->next) {
-        SPItem *item = static_cast<SPItem *>(l->data);
+    std::vector<SPItem*> ll = _selection->itemList();
+    for (std::vector<SPItem*>::const_iterator l=ll.begin();l!=ll.end();l++) {
+        SPItem *item = *l;
 
         SPCanvasItem* baseline_point = NULL;
         if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) { // visualize baseline

=== modified file 'src/selection-chemistry.cpp'
--- src/selection-chemistry.cpp	2015-02-21 16:23:30 +0000
+++ src/selection-chemistry.cpp	2015-04-29 21:03:59 +0000
@@ -279,25 +279,21 @@
 
     Inkscape::Selection *selection = dt->getSelection();
     
-    GSList *items = NULL;
-
-    GSList const *selList = selection->itemList();
-
-    for( GSList const *i = selList; i; i = i->next ) {
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(i->data));
+    std::vector<SPItem*> items ;
+
+    std::vector<SPItem*> const selList = selection->itemList();
+
+    for( std::vector<SPItem*>::const_reverse_iterator i = selList.rbegin(); i != selList.rend(); i++ ) {
+        SPItem *item = *i;
         if( item &&
             !dt->isLayer(item) &&
             (!item->isLocked()))
         {
-            items = g_slist_prepend(items, item);
+            items.push_back(item);
         }
     }
 
     selection->setList(items);
-
-    if(items) {
-        g_slist_free(items);
-    }
 }
 
 } // namespace Inkscape
@@ -307,7 +303,7 @@
  * Copies repr and its inherited css style elements, along with the accumulated transform 'full_t',
  * then prepends the copy to 'clip'.
  */
-static void sp_selection_copy_one(Inkscape::XML::Node *repr, Geom::Affine full_t, GSList **clip, Inkscape::XML::Document* xml_doc)
+static void sp_selection_copy_one(Inkscape::XML::Node *repr, Geom::Affine full_t, std::vector<Inkscape::XML::Node*> &clip, Inkscape::XML::Document* xml_doc)
 {
     Inkscape::XML::Node *copy = repr->duplicate(xml_doc);
 
@@ -323,41 +319,39 @@
     copy->setAttribute("transform", affinestr);
     g_free(affinestr);
 
-    *clip = g_slist_prepend(*clip, copy);
+    clip.insert(clip.begin(),copy);
 }
 
-static void sp_selection_copy_impl(GSList const *items, GSList **clip, Inkscape::XML::Document* xml_doc)
+static void sp_selection_copy_impl(std::vector<SPItem*> const &items, std::vector<Inkscape::XML::Node*> &clip, Inkscape::XML::Document* xml_doc)
 {
     // Sort items:
-    GSList *sorted_items = g_slist_copy(const_cast<GSList *>(items));
-    sorted_items = g_slist_sort(static_cast<GSList *>(sorted_items), (GCompareFunc) sp_object_compare_position);
+    std::vector<SPItem*> sorted_items(items);
+    sort(sorted_items.begin(),sorted_items.end(),sp_object_compare_position);
 
     // Copy item reprs:
-    for (GSList *i = sorted_items; i != NULL; i = i->next) {
-        SPItem *item = dynamic_cast<SPItem *>(SP_OBJECT(i->data));
+    for (std::vector<SPItem*>::const_iterator i = sorted_items.begin(); i != sorted_items.end(); i++) {
+        SPItem *item = *i;
         if (item) {
             sp_selection_copy_one(item->getRepr(), item->i2doc_affine(), clip, xml_doc);
         } else {
             g_assert_not_reached();
         }
     }
-
-    *clip = g_slist_reverse(*clip);
-    g_slist_free(static_cast<GSList *>(sorted_items));
+    reverse(clip.begin(),clip.end());
 }
 
 // TODO check if parent parameter should be changed to SPItem, of if the code should handle non-items.
-static GSList *sp_selection_paste_impl(SPDocument *doc, SPObject *parent, GSList **clip)
+static std::vector<Inkscape::XML::Node*> sp_selection_paste_impl(SPDocument *doc, SPObject *parent, std::vector<Inkscape::XML::Node*> &clip)
 {
     Inkscape::XML::Document *xml_doc = doc->getReprDoc();
 
     SPItem *parentItem = dynamic_cast<SPItem *>(parent);
     g_assert(parentItem != NULL);
 
-    GSList *copied = NULL;
+    std::vector<Inkscape::XML::Node*> copied;
     // add objects to document
-    for (GSList *l = *clip; l != NULL; l = l->next) {
-        Inkscape::XML::Node *repr = static_cast<Inkscape::XML::Node *>(l->data);
+    for (std::vector<Inkscape::XML::Node*>::const_iterator l = clip.begin(); l != clip.end(); l++) {
+        Inkscape::XML::Node *repr = *l;
         Inkscape::XML::Node *copy = repr->duplicate(xml_doc);
 
         // premultiply the item transform by the accumulated parent transform in the paste layer
@@ -375,19 +369,19 @@
         }
 
         parent->appendChildRepr(copy);
-        copied = g_slist_prepend(copied, copy);
+        copied.push_back(copy);
         Inkscape::GC::release(copy);
     }
     return copied;
 }
 
-static void sp_selection_delete_impl(GSList const *items, bool propagate = true, bool propagate_descendants = true)
+static void sp_selection_delete_impl(std::vector<SPItem*> const &items, bool propagate = true, bool propagate_descendants = true)
 {
-    for (GSList const *i = items ; i ; i = i->next ) {
-        sp_object_ref(static_cast<SPItem *>(i->data), NULL);
+    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++) {
+        sp_object_ref(*i, NULL);
     }
-    for (GSList const *i = items; i != NULL; i = i->next) {
-        SPItem *item = static_cast<SPItem *>(i->data);
+    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++) {
+        SPItem *item = *i;
         item->deleteObject(propagate, propagate_descendants);
         sp_object_unref(item, NULL);
     }
@@ -414,11 +408,9 @@
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("<b>Nothing</b> was deleted."));
         return;
     }
-
-    GSList *selected = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> selected(selection->itemList());
     selection->clear();
     sp_selection_delete_impl(selected);
-    g_slist_free(selected);
     desktop->currentLayer()->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 
     /* a tool may have set up private information in it's selection context
@@ -461,16 +453,15 @@
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to duplicate."));
         return;
     }
-
-    GSList *reprs = g_slist_copy(const_cast<GSList *>(selection->reprList()));
+    std::vector<Inkscape::XML::Node*> reprs(selection->reprList());
 
     selection->clear();
 
     // sorting items from different parents sorts each parent's subset without possibly mixing
     // them, just what we need
-    reprs = g_slist_sort(reprs, (GCompareFunc) sp_repr_compare_position);
+    sort(reprs.begin(),reprs.end(),sp_repr_compare_position);
 
-    GSList *newsel = NULL;
+    std::vector<Inkscape::XML::Node*> newsel;
 
     std::vector<const gchar *> old_ids;
     std::vector<const gchar *> new_ids;
@@ -478,8 +469,8 @@
     bool relink_clones = prefs->getBool("/options/relinkclonesonduplicate/value");
     const bool fork_livepatheffects = prefs->getBool("/options/forklpeonduplicate/value", true);
 
-    while (reprs) {
-        Inkscape::XML::Node *old_repr = static_cast<Inkscape::XML::Node *>(reprs->data);
+    for(std::vector<Inkscape::XML::Node*>::const_reverse_iterator i=reprs.rbegin();i!=reprs.rend();i++){
+        Inkscape::XML::Node *old_repr = *i;
         Inkscape::XML::Node *parent = old_repr->parent();
         Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);
 
@@ -500,8 +491,7 @@
             }
         }
 
-        newsel = g_slist_prepend(newsel, copy);
-        reprs = g_slist_remove(reprs, reprs->data);
+        newsel.push_back(copy);
         Inkscape::GC::release(copy);
     }
 
@@ -547,8 +537,6 @@
     }
 
     selection->setReprList(newsel);
-
-    g_slist_free(newsel);
 }
 
 void sp_edit_clear_all(Inkscape::Selection *selection)
@@ -561,11 +549,10 @@
 
     SPGroup *group = dynamic_cast<SPGroup *>(selection->layers()->currentLayer());
     g_return_if_fail(group != NULL);
-    GSList *items = sp_item_group_item_list(group);
+    std::vector<SPItem*> items = sp_item_group_item_list(group);
 
-    while (items) {
-        reinterpret_cast<SPObject*>(items->data)->deleteObject();
-        items = g_slist_remove(items, items->data);
+    for(unsigned int i = 0; i < items.size(); i++){
+        items[i]->deleteObject();
     }
 
     DocumentUndo::done(doc, SP_VERB_EDIT_CLEAR_ALL,
@@ -582,7 +569,7 @@
  * onlysensitive - TRUE includes only non-locked items
  * ingroups - TRUE to recursively get grouped items children
  */
-GSList *get_all_items(GSList *list, SPObject *from, SPDesktop *desktop, bool onlyvisible, bool onlysensitive, bool ingroups, GSList const *exclude)
+std::vector<SPItem*> &get_all_items(std::vector<SPItem*> &list, SPObject *from, SPDesktop *desktop, bool onlyvisible, bool onlysensitive, bool ingroups, std::vector<SPItem*> const &exclude)
 {
     for ( SPObject *child = from->firstChild() ; child; child = child->getNext() ) {
         SPItem *item = dynamic_cast<SPItem *>(child);
@@ -590,10 +577,10 @@
             !desktop->isLayer(item) &&
             (!onlysensitive || !item->isLocked()) &&
             (!onlyvisible || !desktop->itemIsHidden(item)) &&
-            (!exclude || !g_slist_find(const_cast<GSList *>(exclude), child))
+            (exclude.empty() || exclude.end() == std::find(exclude.begin(),exclude.end(),child))
             )
         {
-            list = g_slist_prepend(list, item);
+            list.insert(list.begin(),item);
         }
 
         if (ingroups || (item && desktop->isLayer(item))) {
@@ -618,9 +605,9 @@
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
 
-    GSList *items = NULL;
+    std::vector<SPItem*> items ;
 
-    GSList const *exclude = NULL;
+    std::vector<SPItem*> exclude;
     if (invert) {
         exclude = selection->itemList();
     }
@@ -634,40 +621,38 @@
              (onlyvisible && dt->itemIsHidden(dynamic_cast<SPItem *>(dt->currentLayer()))) )
         return;
 
-        GSList *all_items = sp_item_group_item_list(dynamic_cast<SPGroup *>(dt->currentLayer()));
+        std::vector<SPItem*> all_items = sp_item_group_item_list(dynamic_cast<SPGroup *>(dt->currentLayer()));
 
-        for (GSList *i = all_items; i; i = i->next) {
-            SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(i->data));
+        for (std::vector<SPItem*>::const_reverse_iterator i=all_items.rbegin();i!=all_items.rend();i++) {
+            SPItem *item = *i;
 
             if (item && (!onlysensitive || !item->isLocked())) {
                 if (!onlyvisible || !dt->itemIsHidden(item)) {
                     if (!dt->isLayer(item)) {
-                        if (!invert || !g_slist_find(const_cast<GSList *>(exclude), item)) {
-                            items = g_slist_prepend(items, item); // leave it in the list
+                        if (!invert || exclude.end() == std::find(exclude.begin(),exclude.end(),item)) {
+                            items.push_back(item); // leave it in the list
                         }
                     }
                 }
             }
         }
 
-        g_slist_free(all_items);
             break;
         }
         case PREFS_SELECTION_LAYER_RECURSIVE: {
-            items = get_all_items(NULL, dt->currentLayer(), dt, onlyvisible, onlysensitive, FALSE, exclude);
+        	std::vector<SPItem*> x;
+            items = get_all_items(x, dt->currentLayer(), dt, onlyvisible, onlysensitive, FALSE, exclude);
             break;
         }
         default: {
-        items = get_all_items(NULL, dt->currentRoot(), dt, onlyvisible, onlysensitive, FALSE, exclude);
+            std::vector<SPItem*> x;
+            items = get_all_items(x, dt->currentRoot(), dt, onlyvisible, onlysensitive, FALSE, exclude);
             break;
     }
     }
 
     selection->setList(items);
 
-    if (items) {
-        g_slist_free(items);
-    }
 }
 
 void sp_edit_select_all(SPDesktop *desktop)
@@ -690,16 +675,16 @@
     sp_edit_select_all_full(desktop, true, true);
 }
 
-static void sp_selection_group_impl(GSList *p, Inkscape::XML::Node *group, Inkscape::XML::Document *xml_doc, SPDocument *doc) {
+static void sp_selection_group_impl(std::vector<Inkscape::XML::Node*> p, Inkscape::XML::Node *group, Inkscape::XML::Document *xml_doc, SPDocument *doc) {
 
-    p = g_slist_sort(p, (GCompareFunc) sp_repr_compare_position);
+    sort(p.begin(),p.end(),sp_repr_compare_position);
 
     // Remember the position and parent of the topmost object.
-    gint topmost = (static_cast<Inkscape::XML::Node *>(g_slist_last(p)->data))->position();
-    Inkscape::XML::Node *topmost_parent = (static_cast<Inkscape::XML::Node *>(g_slist_last(p)->data))->parent();
+    gint topmost = p.back()->position();
+    Inkscape::XML::Node *topmost_parent = p.back()->parent();
 
-    while (p) {
-        Inkscape::XML::Node *current = static_cast<Inkscape::XML::Node *>(p->data);
+    for(std::vector<Inkscape::XML::Node*>::const_iterator i = p.begin(); i != p.end(); i++){
+        Inkscape::XML::Node *current = *i;
 
         if (current->parent() == topmost_parent) {
             Inkscape::XML::Node *spnew = current->duplicate(xml_doc);
@@ -708,7 +693,7 @@
             Inkscape::GC::release(spnew);
             topmost --; // only reduce count for those items deleted from topmost_parent
         } else { // move it to topmost_parent first
-            GSList *temp_clip = NULL;
+            std::vector<Inkscape::XML::Node*> temp_clip;
 
             // At this point, current may already have no item, due to its being a clone whose original is already moved away
             // So we copy it artificially calculating the transform from its repr->attr("transform") and the parent transform
@@ -724,15 +709,15 @@
             // then, if this is clone, looking up its original in that array and pre-multiplying
             // it by the inverse of that original's transform diff.
 
-            sp_selection_copy_one(current, item_t, &temp_clip, xml_doc);
+            sp_selection_copy_one(current, item_t, temp_clip, xml_doc);
             sp_repr_unparent(current);
 
             // paste into topmost_parent (temporarily)
-            GSList *copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), &temp_clip);
-            if (temp_clip) g_slist_free(temp_clip);
-            if (copied) { // if success,
+            std::vector<Inkscape::XML::Node*> copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), temp_clip);
+            if (!temp_clip.empty())temp_clip.clear() ;
+            if (!copied.empty()) { // if success,
                 // take pasted object (now in topmost_parent)
-                Inkscape::XML::Node *in_topmost = static_cast<Inkscape::XML::Node *>(copied->data);
+                Inkscape::XML::Node *in_topmost = copied.back();
                 // make a copy
                 Inkscape::XML::Node *spnew = in_topmost->duplicate(xml_doc);
                 // remove pasted
@@ -740,10 +725,9 @@
                 // put its copy into group
                 group->appendChild(spnew);
                 Inkscape::GC::release(spnew);
-                g_slist_free(copied);
+                copied.clear();
             }
         }
-        p = g_slist_remove(p, current);
     }
 
     // Add the new group to the topmost members' parent
@@ -764,9 +748,7 @@
         return;
     }
 
-    GSList const *l = const_cast<GSList *>(selection->reprList());
-
-    GSList *p = g_slist_copy(const_cast<GSList *>(l));
+    std::vector<Inkscape::XML::Node*> p (selection->reprList());
 
     selection->clear();
 
@@ -802,11 +784,11 @@
     }
 
     // first check whether there is anything to ungroup
-    GSList *old_select = const_cast<GSList *>(selection->itemList());
-    GSList *new_select = NULL;
+    std::vector<SPItem*> old_select = selection->itemList();
+    std::vector<SPItem*> new_select;
     GSList *groups = NULL;
-    for (GSList *item = old_select; item; item = item->next) {
-        SPItem *obj = static_cast<SPItem*>(item->data);
+    for (std::vector<SPItem*>::const_iterator item = old_select.begin(); item!=old_select.end(); item++) {
+        SPItem *obj = *item;
         if (dynamic_cast<SPGroup *>(obj)) {
             groups = g_slist_prepend(groups, obj);
         }
@@ -818,14 +800,14 @@
         return;
     }
 
-    GSList *items = g_slist_copy(old_select);
+    std::vector<SPItem*> items(old_select);
     selection->clear();
 
     // If any of the clones refer to the groups, unlink them and replace them with successors
     // in the items list.
     GSList *clones_to_unlink = NULL;
-    for (GSList *item = items; item; item = item->next) {
-        SPUse *use = dynamic_cast<SPUse *>(static_cast<SPItem *>(item->data));
+    for (std::vector<SPItem*>::const_iterator item = items.begin(); item != items.end(); item++) {
+        SPUse *use = dynamic_cast<SPUse *>(*item);
 
         SPItem *original = use;
         while (dynamic_cast<SPUse *>(original)) {
@@ -833,7 +815,7 @@
         }
 
         if (g_slist_find(groups, original) != NULL) {
-            clones_to_unlink = g_slist_prepend(clones_to_unlink, item->data);
+            clones_to_unlink = g_slist_prepend(clones_to_unlink, *item);
         }
     }
 
@@ -844,57 +826,53 @@
 
     for (GSList *item = clones_to_unlink; item; item = item->next) {
         SPUse *use = static_cast<SPUse *>(item->data);
-        GSList *items_node = g_slist_find(items, item->data);
-        items_node->data = use->unlink();
+        std::vector<SPItem*>::iterator items_node = std::find(items.begin(),items.end(), item->data);
+        *items_node = use->unlink();
     }
     g_slist_free(clones_to_unlink);
 
     // do the actual work
-    for (GSList *item = items; item; item = item->next) {
-        SPItem *obj = static_cast<SPItem *>(item->data);
+    for (std::vector<SPItem*>::iterator item = items.begin(); item != items.end(); item++) {
+        SPItem *obj = *item;
 
         // ungroup only the groups marked earlier
-        if (g_slist_find(groups, item->data) != NULL) {
-            GSList *children = NULL;
-            sp_item_group_ungroup(dynamic_cast<SPGroup *>(obj), &children, false);
+        if (g_slist_find(groups, *item) != NULL) {
+        	std::vector<SPItem*> children;
+            sp_item_group_ungroup(dynamic_cast<SPGroup *>(obj), children, false);
             // add the items resulting from ungrouping to the selection
-            new_select = g_slist_concat(new_select, children);
-            item->data = NULL; // zero out the original pointer, which is no longer valid
+            new_select.insert(new_select.end(),children.begin(),children.end());
+            *item = NULL; // zero out the original pointer, which is no longer valid
         } else {
             // if not a group, keep in the selection
-            new_select = g_slist_append(new_select, item->data);
+            new_select.push_back(*item);
         }
     }
 
     selection->addList(new_select);
-    g_slist_free(new_select);
-    g_slist_free(items);
 
     DocumentUndo::done(selection->layers()->getDocument(), SP_VERB_SELECTION_UNGROUP,
                        _("Ungroup"));
 }
 
 /** Replace all groups in the list with their member objects, recursively; returns a new list, frees old */
-GSList *
-sp_degroup_list(GSList *items)
+std::vector<SPItem*>
+sp_degroup_list(std::vector<SPItem*> &items)
 {
-    GSList *out = NULL;
+	std::vector<SPItem*> out;
     bool has_groups = false;
-    for (GSList *item = items; item; item = item->next) {
-        SPGroup *group = dynamic_cast<SPGroup *>(static_cast<SPObject *>(item->data));
+    for (std::vector<SPItem*>::const_iterator item=items.begin();item!=items.end();item++) {
+        SPGroup *group = dynamic_cast<SPGroup *>(*item);
         if (!group) {
-            out = g_slist_prepend(out, item->data);
+            out.push_back(*item);
         } else {
             has_groups = true;
-            GSList *members = sp_item_group_item_list(group);
-            for (GSList *member = members; member; member = member->next) {
-                out = g_slist_prepend(out, member->data);
+            std::vector<SPItem*> members = sp_item_group_item_list(group);
+            for (std::vector<SPItem*>::const_iterator member=members.begin();member!=members.end();member++) {
+                out.push_back(*member);
             }
-            g_slist_free(members);
+            members.clear();
         }
     }
-    out = g_slist_reverse(out);
-    g_slist_free(items);
 
     if (has_groups) { // recurse if we unwrapped a group - it may have contained others
         out = sp_degroup_list(out);
@@ -906,18 +884,19 @@
 
 /** If items in the list have a common parent, return it, otherwise return NULL */
 static SPGroup *
-sp_item_list_common_parent_group(GSList const *items)
+sp_item_list_common_parent_group(std::vector<SPItem*> const items)
 {
-    if (!items) {
+    if (items.empty()) {
         return NULL;
     }
-    SPObject *parent = SP_OBJECT(items->data)->parent;
+    SPObject *parent = items[0]->parent;
     // Strictly speaking this CAN happen, if user selects <svg> from Inkscape::XML editor
     if (!dynamic_cast<SPGroup *>(parent)) {
         return NULL;
     }
-    for (items = items->next; items; items = items->next) {
-        if (SP_OBJECT(items->data)->parent != parent) {
+    for (std::vector<SPItem*>::const_iterator item=items.begin();item!=items.end();item++) {
+    	if((*item)==items[0])continue;
+        if ((*item)->parent != parent) {
             return NULL;
         }
     }
@@ -927,13 +906,13 @@
 
 /** Finds out the minimum common bbox of the selected items. */
 static Geom::OptRect
-enclose_items(GSList const *items)
+enclose_items(std::vector<SPItem*> const &items)
 {
-    g_assert(items != NULL);
+    g_assert(!items.empty());
 
     Geom::OptRect r;
-    for (GSList const *i = items; i; i = i->next) {
-        r.unionWith(static_cast<SPItem *>(i->data)->desktopVisualBounds());
+    for (std::vector<SPItem*>::const_iterator i = items.begin();i!=items.end();i++) {
+        r.unionWith((*i)->desktopVisualBounds());
     }
     return r;
 }
@@ -948,11 +927,17 @@
     return prev;
 }
 
+int sp_item_repr_compare_position_obj(SPObject const *first, SPObject const *second)
+{
+    return sp_repr_compare_position(((SPItem*)first)->getRepr(),
+    		((SPItem*)second)->getRepr())<0;
+}
+
 void
 sp_selection_raise(Inkscape::Selection *selection, SPDesktop *desktop)
 {
-    GSList const *items = const_cast<GSList *>(selection->itemList());
-    if (!items) {
+    std::vector<SPItem*> items= selection->itemList();
+    if (items.empty()) {
         selection_display_message(desktop, Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to raise."));
         return;
     }
@@ -966,16 +951,16 @@
     Inkscape::XML::Node *grepr = const_cast<Inkscape::XML::Node *>(group->getRepr());
 
     /* Construct reverse-ordered list of selected children. */
-    GSList *rev = g_slist_copy(const_cast<GSList *>(items));
-    rev = g_slist_sort(rev, (GCompareFunc) sp_item_repr_compare_position);
+    std::vector<SPItem*> rev(items);
+    sort(rev.begin(),rev.end(),sp_item_repr_compare_position);
 
     // Determine the common bbox of the selected items.
     Geom::OptRect selected = enclose_items(items);
 
     // Iterate over all objects in the selection (starting from top).
     if (selected) {
-        while (rev) {
-            SPObject *child = reinterpret_cast<SPObject*>(rev->data);
+        for (std::vector<SPItem*>::const_iterator item=rev.begin();item!=rev.end();item++) {
+            SPObject *child = *item;
             // for each selected object, find the next sibling
             for (SPObject *newref = child->next; newref; newref = newref->next) {
                 // if the sibling is an item AND overlaps our selection,
@@ -984,7 +969,7 @@
                     Geom::OptRect newref_bbox = newItem->desktopVisualBounds();
                     if ( newref_bbox && selected->intersects(*newref_bbox) ) {
                         // AND if it's not one of our selected objects,
-                        if (!g_slist_find(const_cast<GSList *>(items), newref)) {
+                        if ( std::find(items.begin(),items.end(),newref)==items.end()) {
                             // move the selected object after that sibling
                             grepr->changeOrder(child->getRepr(), newref->getRepr());
                         }
@@ -992,12 +977,8 @@
                     }
                 }
             }
-            rev = g_slist_remove(rev, child);
         }
-    } else {
-        g_slist_free(rev);
     }
-
     DocumentUndo::done(selection->layers()->getDocument(), SP_VERB_SELECTION_RAISE,
                        //TRANSLATORS: "Raise" means "to raise an object" in the undo history
                        C_("Undo action", "Raise"));
@@ -1012,7 +993,7 @@
         return;
     }
 
-    GSList const *items = const_cast<GSList *>(selection->itemList());
+    std::vector<SPItem*> items = selection->itemList();
 
     SPGroup const *group = sp_item_list_common_parent_group(items);
     if (!group) {
@@ -1020,24 +1001,22 @@
         return;
     }
 
-    GSList *rl = g_slist_copy(const_cast<GSList *>(selection->reprList()));
-    rl = g_slist_sort(rl, (GCompareFunc) sp_repr_compare_position);
+    std::vector<Inkscape::XML::Node*> rl(selection->reprList());
+    sort(rl.begin(),rl.end(),sp_repr_compare_position);
 
-    for (GSList *l = rl; l != NULL; l = l->next) {
-        Inkscape::XML::Node *repr = static_cast<Inkscape::XML::Node *>(l->data);
+    for (std::vector<Inkscape::XML::Node*>::const_iterator l=rl.begin(); l!=rl.end();l++) {
+        Inkscape::XML::Node *repr =(*l);
         repr->setPosition(-1);
     }
 
-    g_slist_free(rl);
-
     DocumentUndo::done(document, SP_VERB_SELECTION_TO_FRONT,
                        _("Raise to top"));
 }
 
 void sp_selection_lower(Inkscape::Selection *selection, SPDesktop *desktop)
 {
-    GSList const *items = const_cast<GSList *>(selection->itemList());
-    if (!items) {
+    std::vector<SPItem*> items = selection->itemList();
+    if (items.empty()) {
         selection_display_message(desktop, Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to lower."));
         return;
     }
@@ -1054,14 +1033,13 @@
     Geom::OptRect selected = enclose_items(items);
 
     /* Construct direct-ordered list of selected children. */
-    GSList *rev = g_slist_copy(const_cast<GSList *>(items));
-    rev = g_slist_sort(rev, (GCompareFunc) sp_item_repr_compare_position);
-    rev = g_slist_reverse(rev);
+    std::vector<SPItem*> rev(items);
+    sort(rev.begin(),rev.end(),sp_item_repr_compare_position);
 
     // Iterate over all objects in the selection (starting from top).
     if (selected) {
-        while (rev) {
-            SPObject *child = reinterpret_cast<SPObject*>(rev->data);
+        for (std::vector<SPItem*>::const_reverse_iterator item=rev.rbegin();item!=rev.rend();item++) {
+            SPObject *child = *item;
             // for each selected object, find the prev sibling
             for (SPObject *newref = prev_sibling(child); newref; newref = prev_sibling(newref)) {
                 // if the sibling is an item AND overlaps our selection,
@@ -1070,7 +1048,7 @@
                     Geom::OptRect ref_bbox = newItem->desktopVisualBounds();
                     if ( ref_bbox && selected->intersects(*ref_bbox) ) {
                         // AND if it's not one of our selected objects,
-                        if (!g_slist_find(const_cast<GSList *>(items), newref)) {
+                        if (items.end()==std::find(items.begin(),items.end(),newref)) {
                             // move the selected object before that sibling
                             SPObject *put_after = prev_sibling(newref);
                             if (put_after)
@@ -1082,10 +1060,7 @@
                     }
                 }
             }
-            rev = g_slist_remove(rev, child);
         }
-    } else {
-        g_slist_free(rev);
     }
 
     DocumentUndo::done(selection->layers()->getDocument(), SP_VERB_SELECTION_LOWER,
@@ -1102,7 +1077,7 @@
         return;
     }
 
-    GSList const *items = const_cast<GSList *>(selection->itemList());
+    std::vector<SPItem*> items =selection->itemList();
 
     SPGroup const *group = sp_item_list_common_parent_group(items);
     if (!group) {
@@ -1110,15 +1085,13 @@
         return;
     }
 
-    GSList *rl;
-    rl = g_slist_copy(const_cast<GSList *>(selection->reprList()));
-    rl = g_slist_sort(rl, (GCompareFunc) sp_repr_compare_position);
-    rl = g_slist_reverse(rl);
+    std::vector<Inkscape::XML::Node*> rl(selection->reprList());
+    sort(rl.begin(),rl.end(),sp_repr_compare_position);
 
-    for (GSList *l = rl; l != NULL; l = l->next) {
+    for (std::vector<Inkscape::XML::Node*>::const_reverse_iterator l=rl.rbegin();l!=rl.rend();l++) {
         gint minpos;
         SPObject *pp, *pc;
-        Inkscape::XML::Node *repr = static_cast<Inkscape::XML::Node *>(l->data);
+        Inkscape::XML::Node *repr = (*l);
         pp = document->getObjectByRepr(repr->parent());
         minpos = 0;
         g_assert(dynamic_cast<SPGroup *>(pp));
@@ -1130,8 +1103,6 @@
         repr->setPosition(minpos);
     }
 
-    g_slist_free(rl);
-
     DocumentUndo::done(document, SP_VERB_SELECTION_TO_BACK,
                        _("Lower to bottom"));
 }
@@ -1269,9 +1240,9 @@
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to remove live path effects from."));
         return;
     }
-
-    for ( GSList const *itemlist = selection->itemList(); itemlist != NULL; itemlist = g_slist_next(itemlist) ) {
-        SPItem *item = reinterpret_cast<SPItem*>(itemlist->data);
+    std::vector<SPItem*> list=selection->itemList();
+    for ( std::vector<SPItem*>::const_iterator itemlist=list.begin();itemlist!=list.end();itemlist++) {
+        SPItem *item = *itemlist;
 
         sp_selection_remove_livepatheffect_impl(item);
 
@@ -1325,10 +1296,10 @@
  * Ensures that the clones of objects are not modified when moving objects between layers.
  * Calls the same function as ungroup
  */
-void sp_selection_change_layer_maintain_clones(GSList const *items,SPObject *where)
+void sp_selection_change_layer_maintain_clones(std::vector<SPItem*> const &items,SPObject *where)
 {
-    for (const GSList *i = items; i != NULL; i = i->next) {
-        SPItem *item = dynamic_cast<SPItem *>(SP_OBJECT(i->data));
+    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++) {
+        SPItem *item = *i;
         if (item) {
             SPItem *oldparent = dynamic_cast<SPItem *>(item->parent);
             SPItem *newparent = dynamic_cast<SPItem *>(where);
@@ -1350,26 +1321,24 @@
         return;
     }
 
-    GSList const *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
 
     bool no_more = false; // Set to true, if no more layers above
     SPObject *next=Inkscape::next_layer(dt->currentRoot(), dt->currentLayer());
     if (next) {
         sp_selection_change_layer_maintain_clones(items,next);
-        GSList *temp_clip = NULL;
-        sp_selection_copy_impl(items, &temp_clip, dt->doc()->getReprDoc());
+        std::vector<Inkscape::XML::Node*> temp_clip;
+        sp_selection_copy_impl(items, temp_clip, dt->doc()->getReprDoc());
         sp_selection_delete_impl(items, false, false);
         next=Inkscape::next_layer(dt->currentRoot(), dt->currentLayer()); // Fixes bug 1482973: crash while moving layers
-        GSList *copied;
+        std::vector<Inkscape::XML::Node*> copied;
         if (next) {
-            copied = sp_selection_paste_impl(dt->getDocument(), next, &temp_clip);
+            copied = sp_selection_paste_impl(dt->getDocument(), next, temp_clip);
         } else {
-            copied = sp_selection_paste_impl(dt->getDocument(), dt->currentLayer(), &temp_clip);
+            copied = sp_selection_paste_impl(dt->getDocument(), dt->currentLayer(), temp_clip);
             no_more = true;
         }
-        selection->setReprList((GSList const *) copied);
-        g_slist_free(copied);
-        if (temp_clip) g_slist_free(temp_clip);
+        selection->setReprList(copied);
         if (next) dt->setCurrentLayer(next);
         if ( !suppressDone ) {
             DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO_NEXT,
@@ -1383,7 +1352,6 @@
         dt->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No more layers above."));
     }
 
-    g_slist_free(const_cast<GSList *>(items));
 }
 
 void sp_selection_to_prev_layer(SPDesktop *dt, bool suppressDone)
@@ -1396,26 +1364,24 @@
         return;
     }
 
-    GSList const *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    const std::vector<SPItem*> items(selection->itemList());
 
     bool no_more = false; // Set to true, if no more layers below
     SPObject *next=Inkscape::previous_layer(dt->currentRoot(), dt->currentLayer());
     if (next) {
         sp_selection_change_layer_maintain_clones(items,next);
-        GSList *temp_clip = NULL;
-        sp_selection_copy_impl(items, &temp_clip, dt->doc()->getReprDoc()); // we're in the same doc, so no need to copy defs
+        std::vector<Inkscape::XML::Node*> temp_clip;
+        sp_selection_copy_impl(items, temp_clip, dt->doc()->getReprDoc()); // we're in the same doc, so no need to copy defs
         sp_selection_delete_impl(items, false, false);
         next=Inkscape::previous_layer(dt->currentRoot(), dt->currentLayer()); // Fixes bug 1482973: crash while moving layers
-        GSList *copied;
+        std::vector<Inkscape::XML::Node*> copied;
         if (next) {
-            copied = sp_selection_paste_impl(dt->getDocument(), next, &temp_clip);
+            copied = sp_selection_paste_impl(dt->getDocument(), next, temp_clip);
         } else {
-            copied = sp_selection_paste_impl(dt->getDocument(), dt->currentLayer(), &temp_clip);
+            copied = sp_selection_paste_impl(dt->getDocument(), dt->currentLayer(), temp_clip);
             no_more = true;
         }
-        selection->setReprList((GSList const *) copied);
-        g_slist_free(copied);
-        if (temp_clip) g_slist_free(temp_clip);
+        selection->setReprList( copied);
         if (next) dt->setCurrentLayer(next);
         if ( !suppressDone ) {
             DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO_PREV,
@@ -1428,8 +1394,6 @@
     if (no_more) {
         dt->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No more layers below."));
     }
-
-    g_slist_free(const_cast<GSList *>(items));
 }
 
 void sp_selection_to_layer(SPDesktop *dt, SPObject *moveto, bool suppressDone)
@@ -1442,25 +1406,22 @@
         return;
     }
 
-    GSList const *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
 
     if (moveto) {
         sp_selection_change_layer_maintain_clones(items,moveto);
-        GSList *temp_clip = NULL;
-        sp_selection_copy_impl(items, &temp_clip, dt->doc()->getReprDoc()); // we're in the same doc, so no need to copy defs
+        std::vector<Inkscape::XML::Node*> temp_clip;
+        sp_selection_copy_impl(items, temp_clip, dt->doc()->getReprDoc()); // we're in the same doc, so no need to copy defs
         sp_selection_delete_impl(items, false, false);
-        GSList *copied = sp_selection_paste_impl(dt->getDocument(), moveto, &temp_clip);
-        selection->setReprList((GSList const *) copied);
-        g_slist_free(copied);
-        if (temp_clip) g_slist_free(temp_clip);
+        std::vector<Inkscape::XML::Node*> copied = sp_selection_paste_impl(dt->getDocument(), moveto, temp_clip);
+        selection->setReprList(copied);
+        if (!temp_clip.empty()) temp_clip.clear();
         if (moveto) dt->setCurrentLayer(moveto);
         if ( !suppressDone ) {
             DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO,
                                _("Move selection to layer"));
         }
     }
-
-    g_slist_free(const_cast<GSList *>(items));
 }
 
 static bool
@@ -1495,8 +1456,9 @@
 selection_contains_both_clone_and_original(Inkscape::Selection *selection)
 {
     bool clone_with_original = false;
-    for (GSList const *l = selection->itemList(); l != NULL; l = l->next) {
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(l->data));
+    std::vector<SPItem*> items = selection->itemList();
+    for (std::vector<SPItem*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+        SPItem *item = *l;
         if (item) {
             clone_with_original |= selection_contains_original(item, selection);
             if (clone_with_original)
@@ -1539,9 +1501,9 @@
 
         persp3d_apply_affine_transformation(transf_persp, affine);
     }
-
-    for (GSList const *l = selection->itemList(); l != NULL; l = l->next) {
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(l->data));
+    std::vector<SPItem*> items = selection->itemList();
+    for (std::vector<SPItem*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+        SPItem *item = *l;
 
         if( dynamic_cast<SPRoot *>(item) ) {
             // An SVG element cannot have a transform. We could change 'x' and 'y' in response
@@ -1710,10 +1672,9 @@
 
     Inkscape::Selection *selection = desktop->getSelection();
 
-    GSList const *l = const_cast<GSList *>(selection->reprList());
-    while (l != NULL) {
-        ((Inkscape::XML::Node*)l->data)->setAttribute("transform", NULL, false);
-        l = l->next;
+    std::vector<Inkscape::XML::Node*> items = selection->reprList();
+    for (std::vector<Inkscape::XML::Node*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+        (*l)->setAttribute("transform", NULL, false);
     }
 
     DocumentUndo::done(desktop->getDocument(), SP_VERB_OBJECT_FLATTEN,
@@ -1811,10 +1772,10 @@
     if (selection->isEmpty())
         return;
 
-    GSList const *l = selection->itemList();
+    std::vector<SPItem*> items = selection->itemList();
     Geom::Rotate const rot_90(Geom::Point(0, ccw ? 1 : -1)); // pos. or neg. rotation, depending on the value of ccw
-    for (GSList const *l2 = l ; l2 != NULL ; l2 = l2->next) {
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(l2->data));
+    for (std::vector<SPItem*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+        SPItem *item = *l;
         if (item) {
             sp_item_rotate_rel(item, rot_90);
         } else {
@@ -1870,15 +1831,15 @@
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
     bool ingroups = TRUE;
-
-    GSList *all_list = get_all_items(NULL, desktop->currentRoot(), desktop, onlyvisible, onlysensitive, ingroups, NULL);
-    GSList *all_matches = NULL;
+    std::vector<SPItem*> x,y;
+    std::vector<SPItem*> all_list = get_all_items(x, desktop->currentRoot(), desktop, onlyvisible, onlysensitive, ingroups, y);
+    std::vector<SPItem*> all_matches;
 
     Inkscape::Selection *selection = desktop->getSelection();
-
-    for (GSList const* sel_iter = selection->itemList(); sel_iter; sel_iter = sel_iter->next) {
-        SPItem *sel = dynamic_cast<SPItem *>(static_cast<SPObject *>(sel_iter->data));
-        GSList *matches = all_list;
+    std::vector<SPItem*> items = selection->itemList();
+    for (std::vector<SPItem*>::const_iterator sel_iter=items.begin();sel_iter!=items.end();sel_iter++) {
+        SPItem *sel = *sel_iter;
+        std::vector<SPItem*> matches = all_list;
         if (fill && stroke && style) {
             matches = sp_get_same_style(sel, matches);
         }
@@ -1891,19 +1852,12 @@
         else if (style) {
             matches = sp_get_same_style(sel, matches,SP_STROKE_STYLE_ALL);
         }
-        all_matches = g_slist_concat (all_matches, matches);
+        all_matches.insert(all_matches.end(), matches.begin(),matches.end());
     }
 
     selection->clear();
     selection->setList(all_matches);
 
-    if (all_matches) {
-        g_slist_free(all_matches);
-    }
-    if (all_list) {
-        g_slist_free(all_list);
-    }
-
 }
 
 
@@ -1924,14 +1878,15 @@
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
     bool ingroups = TRUE;
-
-    GSList *all_list = get_all_items(NULL, desktop->currentRoot(), desktop, onlyvisible, onlysensitive, ingroups, NULL);
-    GSList *matches = all_list;
+    std::vector<SPItem*> x,y;
+    std::vector<SPItem*> all_list = get_all_items(x, desktop->currentRoot(), desktop, onlyvisible, onlysensitive, ingroups, y);
+    std::vector<SPItem*> matches = all_list;
 
     Inkscape::Selection *selection = desktop->getSelection();
 
-    for (GSList const* sel_iter = selection->itemList(); sel_iter; sel_iter = sel_iter->next) {
-        SPItem *sel = dynamic_cast<SPItem *>(static_cast<SPObject *>(sel_iter->data));
+    std::vector<SPItem*> items=selection->itemList();
+    for (std::vector<SPItem*>::const_iterator sel_iter=items.begin();sel_iter!=items.end();sel_iter++) {
+        SPItem *sel = *sel_iter;
         if (sel) {
             matches = sp_get_same_object_type(sel, matches);
         } else {
@@ -1942,12 +1897,6 @@
     selection->clear();
     selection->setList(matches);
 
-    if (matches) {
-        g_slist_free(matches);
-    }
-    if (all_list) {
-        g_slist_free(all_list);
-    }
 }
 
 
@@ -1956,15 +1905,15 @@
  * Find all items in src list that have the same fill or stroke style as sel
  * Return the list of matching items
  */
-GSList *sp_get_same_fill_or_stroke_color(SPItem *sel, GSList *src, SPSelectStrokeStyleType type)
+std::vector<SPItem*> sp_get_same_fill_or_stroke_color(SPItem *sel, std::vector<SPItem*> &src, SPSelectStrokeStyleType type)
 {
-    GSList *matches = NULL;
+    std::vector<SPItem*> matches ;
     gboolean match = false;
 
     SPIPaint *sel_paint = (type == SP_FILL_COLOR) ? &(sel->style->fill) : &(sel->style->stroke);
 
-    for (GSList *i = src; i != NULL; i = i->next) {
-        SPItem *iter = dynamic_cast<SPItem *>(static_cast<SPObject *>(i->data));
+    for (std::vector<SPItem*>::const_reverse_iterator i=src.rbegin();i!=src.rend();i++) {
+        SPItem *iter = *i;
         if (iter) {
             SPIPaint *iter_paint = (type == SP_FILL_COLOR) ? &(iter->style->fill) : &(iter->style->stroke);
             match = false;
@@ -2003,7 +1952,7 @@
             }
 
             if (match) {
-                matches = g_slist_prepend(matches, iter);
+                matches.push_back(iter);
             }
         } else {
             g_assert_not_reached();
@@ -2054,17 +2003,16 @@
  * Find all items in src list that have the same object type as sel by type
  * Return the list of matching items
  */
-GSList *sp_get_same_object_type(SPItem *sel, GSList *src)
+std::vector<SPItem*> sp_get_same_object_type(SPItem *sel, std::vector<SPItem*> &src)
 {
-    GSList *matches = NULL;
+    std::vector<SPItem*> matches;
 
-    for (GSList *i = src; i != NULL; i = i->next) {
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(i->data));
+    for (std::vector<SPItem*>::const_reverse_iterator i=src.rbegin();i!=src.rend();i++) {
+        SPItem *item = *i;
         if (item && item_type_match(sel, item) && !item->cloned) {
-            matches = g_slist_prepend (matches, item);
+            matches.push_back(item);
         }
     }
-
     return matches;
 }
 
@@ -2074,9 +2022,9 @@
  * Find all items in src list that have the same stroke style as sel by type
  * Return the list of matching items
  */
-GSList *sp_get_same_style(SPItem *sel, GSList *src, SPSelectStrokeStyleType type)
+std::vector<SPItem*> sp_get_same_style(SPItem *sel, std::vector<SPItem*> &src, SPSelectStrokeStyleType type)
 {
-    GSList *matches = NULL;
+    std::vector<SPItem*> matches;
     bool match = false;
 
     SPStyle *sel_style = sel->style;
@@ -2092,16 +2040,16 @@
      * Stroke width needs to handle transformations, so call this function
      * to get the transformed stroke width
      */
-    GSList *objects = NULL;
+    std::vector<SPItem*> objects;
     SPStyle *sel_style_for_width = NULL;
     if (type == SP_STROKE_STYLE_WIDTH || type == SP_STROKE_STYLE_ALL || type==SP_STYLE_ALL ) {
-        objects = g_slist_prepend(objects, sel);
+        objects.push_back(sel);
         sel_style_for_width = new SPStyle(SP_ACTIVE_DOCUMENT);
         objects_query_strokewidth (objects, sel_style_for_width);
     }
     bool match_g;
-    for (GSList *i = src; i != NULL; i = i->next) {
-        SPItem *iter = dynamic_cast<SPItem *>(static_cast<SPObject *>(i->data));
+    for (std::vector<SPItem*>::const_iterator i=src.begin();i!=src.end();i++) {
+        SPItem *iter = *i;
         if (iter) {
             match_g=true;
             SPStyle *iter_style = iter->style;
@@ -2110,15 +2058,14 @@
             if (type == SP_STROKE_STYLE_WIDTH|| type == SP_STROKE_STYLE_ALL|| type==SP_STYLE_ALL) {
                 match = (sel_style->stroke_width.set == iter_style->stroke_width.set);
                 if (sel_style->stroke_width.set && iter_style->stroke_width.set) {
-                    GSList *objects = NULL;
-                    objects = g_slist_prepend(objects, iter);
+                    std::vector<SPItem*> objects;
+                    objects.insert(objects.begin(),iter);
                     SPStyle tmp_style(SP_ACTIVE_DOCUMENT);
                     objects_query_strokewidth (objects, &tmp_style);
 
                     if (sel_style_for_width) {
                         match = (sel_style_for_width->stroke_width.computed == tmp_style.stroke_width.computed);
                     }
-                    g_slist_free(objects);
                 }
             }
             match_g = match_g && match;
@@ -2141,10 +2088,10 @@
                     }
                 }
             }
-            match_g = match_g && match;
+			match_g = match_g && match;
             if (match_g) {
                 while (iter->cloned) iter=dynamic_cast<SPItem *>(iter->parent);
-                matches = g_slist_prepend(matches, iter);
+                matches.insert(matches.begin(),iter);
             }
         } else {
             g_assert_not_reached();
@@ -2152,8 +2099,6 @@
     }
 
     if( sel_style_for_width != NULL ) delete sel_style_for_width;
-    g_slist_free(objects);
-
     return matches;
 }
 
@@ -2307,17 +2252,9 @@
     }
 }
 
-namespace {
-
-template <typename D>
-SPItem *next_item(SPDesktop *desktop, GSList *path, SPObject *root,
-                  bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive);
-
-template <typename D>
-SPItem *next_item_from_list(SPDesktop *desktop, GSList const *items, SPObject *root,
-                  bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive);
-
-struct Forward {
+
+
+typedef struct Forward {
     typedef SPObject *Iterator;
 
     static Iterator children(SPObject *o) { return o->firstChild(); }
@@ -2326,9 +2263,9 @@
 
     static SPObject *object(Iterator i) { return i; }
     static Iterator next(Iterator i) { return i->getNext(); }
-};
+} Forward;
 
-struct ListReverse {
+typedef struct ListReverse {
     typedef GSList *Iterator;
 
     static Iterator children(SPObject *o) {
@@ -2359,8 +2296,87 @@
         }
         return list;
     }
-};
-
+} ListReverse;
+
+
+
+template <typename D>
+SPItem *next_item(SPDesktop *desktop, GSList *path, SPObject *root,
+                  bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive)
+{
+    typename D::Iterator children;
+    typename D::Iterator iter;
+
+    SPItem *found=NULL;
+
+    if (path) {
+        SPObject *object=reinterpret_cast<SPObject *>(path->data);
+        g_assert(object->parent == root);
+        if (desktop->isLayer(object)) {
+            found = next_item<D>(desktop, path->next, object, only_in_viewport, inlayer, onlyvisible, onlysensitive);
+        }
+        iter = children = D::siblings_after(object);
+    } else {
+        iter = children = D::children(root);
+    }
+
+    while ( iter && !found ) {
+        SPObject *object=D::object(iter);
+        if (desktop->isLayer(object)) {
+            if (PREFS_SELECTION_LAYER != inlayer) { // recurse into sublayers
+                found = next_item<D>(desktop, NULL, object, only_in_viewport, inlayer, onlyvisible, onlysensitive);
+            }
+        } else {
+            SPItem *item = dynamic_cast<SPItem *>(object);
+            if ( item &&
+                 ( !only_in_viewport || desktop->isWithinViewport(item) ) &&
+                 ( !onlyvisible || !desktop->itemIsHidden(item)) &&
+                 ( !onlysensitive || !item->isLocked()) &&
+                 !desktop->isLayer(item) )
+            {
+                found = item;
+            }
+        }
+        iter = D::next(iter);
+    }
+
+    D::dispose(children);
+
+    return found;
+}
+
+
+template <typename D>
+SPItem *next_item_from_list(SPDesktop *desktop, std::vector<SPItem*> const items,
+                            SPObject *root, bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive)
+{
+    SPObject *current=root;
+    for(std::vector<SPItem*>::const_iterator i = items.begin();i!=items.end();i++) {
+        SPItem *item = *i;
+        if ( root->isAncestorOf(item) &&
+             ( !only_in_viewport || desktop->isWithinViewport(item) ) )
+        {
+            current = item;
+            break;
+        }
+    }
+
+    GSList *path=NULL;
+    while ( current != root ) {
+        path = g_slist_prepend(path, current);
+        current = current->parent;
+    }
+
+    SPItem *next;
+    // first, try from the current object
+    next = next_item<D>(desktop, path, root, only_in_viewport, inlayer, onlyvisible, onlysensitive);
+    g_slist_free(path);
+
+    if (!next) { // if we ran out of objects, start over at the root
+        next = next_item<D>(desktop, NULL, root, only_in_viewport, inlayer, onlyvisible, onlysensitive);
+    }
+
+    return next;
 }
 
 void
@@ -2487,88 +2503,8 @@
 }
 
 
-namespace {
-
-template <typename D>
-SPItem *next_item_from_list(SPDesktop *desktop, GSList const *items,
-                            SPObject *root, bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive)
-{
-    SPObject *current=root;
-    while (items) {
-        SPItem *item = dynamic_cast<SPItem *>(static_cast<SPObject *>(items->data));
-        if ( root->isAncestorOf(item) &&
-             ( !only_in_viewport || desktop->isWithinViewport(item) ) )
-        {
-            current = item;
-            break;
-        }
-        items = items->next;
-    }
-
-    GSList *path=NULL;
-    while ( current != root ) {
-        path = g_slist_prepend(path, current);
-        current = current->parent;
-    }
-
-    SPItem *next;
-    // first, try from the current object
-    next = next_item<D>(desktop, path, root, only_in_viewport, inlayer, onlyvisible, onlysensitive);
-    g_slist_free(path);
-
-    if (!next) { // if we ran out of objects, start over at the root
-        next = next_item<D>(desktop, NULL, root, only_in_viewport, inlayer, onlyvisible, onlysensitive);
-    }
-
-    return next;
-}
-
-template <typename D>
-SPItem *next_item(SPDesktop *desktop, GSList *path, SPObject *root,
-                  bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive)
-{
-    typename D::Iterator children;
-    typename D::Iterator iter;
-
-    SPItem *found=NULL;
-
-    if (path) {
-        SPObject *object=reinterpret_cast<SPObject *>(path->data);
-        g_assert(object->parent == root);
-        if (desktop->isLayer(object)) {
-            found = next_item<D>(desktop, path->next, object, only_in_viewport, inlayer, onlyvisible, onlysensitive);
-        }
-        iter = children = D::siblings_after(object);
-    } else {
-        iter = children = D::children(root);
-    }
-
-    while ( iter && !found ) {
-        SPObject *object=D::object(iter);
-        if (desktop->isLayer(object)) {
-            if (PREFS_SELECTION_LAYER != inlayer) { // recurse into sublayers
-                found = next_item<D>(desktop, NULL, object, only_in_viewport, inlayer, onlyvisible, onlysensitive);
-            }
-        } else {
-            SPItem *item = dynamic_cast<SPItem *>(object);
-            if ( item &&
-                 ( !only_in_viewport || desktop->isWithinViewport(item) ) &&
-                 ( !onlyvisible || !desktop->itemIsHidden(item)) &&
-                 ( !onlysensitive || !item->isLocked()) &&
-                 !desktop->isLayer(item) )
-            {
-                found = item;
-            }
-        }
-        iter = D::next(iter);
-    }
-
-    D::dispose(children);
-
-    return found;
-}
-
-}
+
+
 
 /**
  * If \a item is not entirely visible then adjust visible area to centre on the centre on of
@@ -2608,17 +2544,17 @@
         return;
     }
 
-    GSList *reprs = g_slist_copy(const_cast<GSList *>(selection->reprList()));
+    std::vector<Inkscape::XML::Node*> reprs (selection->reprList());
 
     selection->clear();
 
     // sorting items from different parents sorts each parent's subset without possibly mixing them, just what we need
-    reprs = g_slist_sort(reprs, (GCompareFunc) sp_repr_compare_position);
-
-    GSList *newsel = NULL;
-
-    while (reprs) {
-        Inkscape::XML::Node *sel_repr = static_cast<Inkscape::XML::Node *>(reprs->data);
+    sort(reprs.begin(),reprs.end(),sp_repr_compare_position);
+
+    std::vector<Inkscape::XML::Node*> newsel;
+
+    for(std::vector<Inkscape::XML::Node*>::const_reverse_iterator i=reprs.rbegin();i!=reprs.rend();i++){
+    	Inkscape::XML::Node *sel_repr = *i;
         Inkscape::XML::Node *parent = sel_repr->parent();
 
         Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
@@ -2634,8 +2570,7 @@
         // add the new clone to the top of the original's parent
         parent->appendChild(clone);
 
-        newsel = g_slist_prepend(newsel, clone);
-        reprs = g_slist_remove(reprs, sel_repr);
+        newsel.push_back(clone);
         Inkscape::GC::release(clone);
     }
 
@@ -2643,8 +2578,6 @@
                        C_("Action", "Clone"));
 
     selection->setReprList(newsel);
-
-    g_slist_free(newsel);
 }
 
 void
@@ -2670,11 +2603,9 @@
 
     // Get a copy of current selection.
     bool relinked = false;
-    for (GSList *items = const_cast<GSList *>(selection->itemList());
-         items != NULL;
-         items = items->next)
-    {
-        SPItem *item = static_cast<SPItem *>(items->data);
+    std::vector<SPItem*> items=selection->itemList();
+    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        SPItem *item = *i;
 
         if (dynamic_cast<SPUse *>(item)) {
             item->getRepr()->setAttribute("xlink:href", newref);
@@ -2708,13 +2639,11 @@
     }
 
     // Get a copy of current selection.
-    GSList *new_select = NULL;
+    std::vector<SPItem*> new_select;
     bool unlinked = false;
-    for (GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
-         items != NULL;
-         items = items->next)
-    {
-        SPItem *item = static_cast<SPItem *>(items->data);
+    std::vector<SPItem*> items=selection->itemList();
+    for (std::vector<SPItem*>::const_reverse_iterator i=items.rbegin();i!=items.rend();i++){
+        SPItem *item = *i;
 
         if (dynamic_cast<SPText *>(item)) {
             SPObject *tspan = sp_tref_convert_to_tspan(item);
@@ -2730,7 +2659,7 @@
 
         if (!(dynamic_cast<SPUse *>(item) || dynamic_cast<SPTRef *>(item))) {
             // keep the non-use item in the new selection
-            new_select = g_slist_prepend(new_select, item);
+            new_select.push_back(item);
             continue;
         }
 
@@ -2740,7 +2669,7 @@
             unlink = use->unlink();
             // Unable to unlink use (external or invalid href?)
             if (!unlink) {
-                new_select = g_slist_prepend(new_select, item);
+                new_select.push_back(item);
                 continue;
             }
         } else /*if (SP_IS_TREF(use))*/ {
@@ -2750,13 +2679,12 @@
 
         unlinked = true;
         // Add ungrouped items to the new selection.
-        new_select = g_slist_prepend(new_select, unlink);
+        new_select.push_back(unlink);
     }
 
-    if (new_select) { // set new selection
+    if (!new_select.empty()) { // set new selection
         selection->clear();
         selection->setList(new_select);
-        g_slist_free(new_select);
     }
     if (!unlinked) {
         desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No clones to unlink</b> in the selection."));
@@ -2779,7 +2707,9 @@
     gchar const *error = _("Select a <b>clone</b> to go to its original. Select a <b>linked offset</b> to go to its source. Select a <b>text on path</b> to go to the path. Select a <b>flowed text</b> to go to its frame.");
 
     // Check if other than two objects are selected
-    if (g_slist_length(const_cast<GSList *>(selection->itemList())) != 1 || !item) {
+
+    std::vector<SPItem*> items=selection->itemList();
+    if (items.size() != 1 || !item) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, error);
         return;
     }
@@ -2876,14 +2806,15 @@
 
     Inkscape::SVGOStringStream os;
     SPObject * firstItem = NULL;
-    for (const GSList * item = selection->itemList(); item != NULL; item = item->next) {
-        if (SP_IS_SHAPE(item->data) || SP_IS_TEXT(item->data)) {
+    std::vector<SPItem*> items=selection->itemList();
+    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        if (SP_IS_SHAPE(*i) || SP_IS_TEXT(*i)) {
             if (firstItem) {
                 os << "|";
             } else {
-                firstItem = SP_ITEM(item->data);
+                firstItem = SP_ITEM(*i);
             }
-            os << '#' << SP_ITEM(item->data)->getId() << ",0";
+            os << '#' << SP_ITEM(*i)->getId() << ",0";
         }
     }
     if (firstItem) {
@@ -2960,12 +2891,12 @@
     Geom::Point center( *c - corner ); // As defined by rotation center
     center[Geom::Y] = -center[Geom::Y];
 
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
 
     //items = g_slist_sort(items, (GCompareFunc) sp_object_compare_position);  // Why needed?
 
     // bottommost object, after sorting
-    SPObject *parent = SP_OBJECT(items->data)->parent;
+    SPObject *parent = items[0]->parent;
 
     Geom::Affine parent_transform;
     {
@@ -2978,10 +2909,10 @@
     }
 
     // Create a list of duplicates, to be pasted inside marker element.
-    GSList *repr_copies = NULL;
-    for (GSList *i = items; i != NULL; i = i->next) {
-        Inkscape::XML::Node *dup = SP_OBJECT(i->data)->getRepr()->duplicate(xml_doc);
-        repr_copies = g_slist_prepend(repr_copies, dup);
+    std::vector<Inkscape::XML::Node*> repr_copies;
+    for (std::vector<SPItem*>::const_reverse_iterator i=items.rbegin();i!=items.rend();i++){
+        Inkscape::XML::Node *dup = (*i)->getRepr()->duplicate(xml_doc);
+        repr_copies.push_back(dup);
     }
 
     Geom::Rect bbox(desktop->dt2doc(r->min()), desktop->dt2doc(r->max()));
@@ -2989,8 +2920,8 @@
     if (apply) {
         // Delete objects so that their clones don't get alerted;
         // the objects will be restored inside the marker element.
-        for (GSList *i = items; i != NULL; i = i->next) {
-            SPObject *item = reinterpret_cast<SPObject*>(i->data);
+        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+            SPObject *item = *i;
             item->deleteObject(false);
         }
     }
@@ -3009,7 +2940,6 @@
     prefs->setInt("/options/clonecompensation/value", saved_compensation);
 
 
-    g_slist_free(items);
 
     DocumentUndo::done(doc, SP_VERB_EDIT_SELECTION_2_MARKER,
                        _("Objects to marker"));
@@ -3018,8 +2948,9 @@
 static void sp_selection_to_guides_recursive(SPItem *item, bool wholegroups) {
     SPGroup *group = dynamic_cast<SPGroup *>(item);
     if (group && !dynamic_cast<SPBox3D *>(item) && !wholegroups) {
-        for (GSList *i = sp_item_group_item_list(group); i != NULL; i = i->next) {
-            sp_selection_to_guides_recursive(static_cast<SPItem*>(i->data), wholegroups);
+        std::vector<SPItem*> items=sp_item_group_item_list(group);
+        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+            sp_selection_to_guides_recursive(*i, wholegroups);
         }
     } else {
         item->convert_to_guides();
@@ -3034,9 +2965,9 @@
     SPDocument *doc = desktop->getDocument();
     Inkscape::Selection *selection = desktop->getSelection();
     // we need to copy the list because it gets reset when objects are deleted
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
 
-    if (!items) {
+    if (items.empty()) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to convert to guides."));
         return;
     }
@@ -3049,8 +2980,8 @@
     // and its entry in the selection list is invalid (crash).
     // Therefore: first convert all, then delete all.
 
-    for (GSList const *i = items; i != NULL; i = i->next) {
-        sp_selection_to_guides_recursive(static_cast<SPItem*>(i->data), wholegroups);
+    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        sp_selection_to_guides_recursive(*i, wholegroups);
     }
 
     if (deleteitems) {
@@ -3058,8 +2989,6 @@
         sp_selection_delete_impl(items);
     }
 
-    g_slist_free(items);
-
     DocumentUndo::done(doc, SP_VERB_EDIT_SELECTION_2_GUIDES, _("Objects to guides"));
 }
 
@@ -3102,18 +3031,18 @@
 
     doc->ensureUpToDate();
 
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->list()));
+    std::vector<SPObject*> items(selection->list());
 
     // Keep track of parent, this is where <use> will be inserted.
-    Inkscape::XML::Node *the_first_repr = reinterpret_cast<SPObject *>( items->data )->getRepr();
+    Inkscape::XML::Node *the_first_repr = items[0]->getRepr();
     Inkscape::XML::Node *the_parent_repr = the_first_repr->parent();
 
     // Find out if we have a single group
     bool single_group = false;
     SPGroup *the_group = NULL;
     Geom::Affine transform;
-    if( g_slist_length( items ) == 1 ) {
-        SPObject *object = reinterpret_cast<SPObject *>( items->data );
+    if( items.size() == 1 ) {
+        SPObject *object = items[0];
         the_group = dynamic_cast<SPGroup *>(object);
         if ( the_group ) {
             single_group = true;
@@ -3124,7 +3053,6 @@
             if( transform.isTranslation() ) {
 
                 // Create new list from group children.
-                g_slist_free(items);
                 items = object->childList(false);
 
                 // Hack: Temporarily set clone compensation to unmoved, so that we can move clone-originals
@@ -3170,8 +3098,8 @@
     }
 
     // Move selected items to new <symbol>
-    for (GSList *i = items; i != NULL; i = i->next) {
-      Inkscape::XML::Node *repr = SP_OBJECT(i->data)->getRepr();
+    for (std::vector<SPObject*>::const_iterator i=items.begin();i!=items.end();i++){
+      Inkscape::XML::Node *repr = (*i)->getRepr();
       repr->parent()->removeChild(repr);
       symbol_repr->addChild(repr,NULL);
     }
@@ -3197,7 +3125,6 @@
 
     // Clean up
     Inkscape::GC::release(symbol_repr);
-    g_slist_free(items);
 
     DocumentUndo::done(doc, SP_VERB_EDIT_SYMBOL, _("Group to symbol"));
 }
@@ -3238,26 +3165,25 @@
     desktop->currentLayer()->getRepr()->appendChild(group);
 
     // Move all children of symbol to group
-    GSList* children = symbol->childList(false);
+    std::vector<SPObject*> children = symbol->childList(false);
 
     // Converting a group to a symbol inserts a group for non-translational transform.
     // In converting a symbol back to a group we strip out the inserted group (or any other
     // group that only adds a transform to the symbol content).
-    if( g_slist_length( children ) == 1 ) {
-        SPObject *object = reinterpret_cast<SPObject *>( children->data );
+    if( children.size() == 1 ) {
+        SPObject *object = children[0];
         if ( dynamic_cast<SPGroup *>( object ) ) {
             if( object->getAttribute("style") == NULL ||
                 object->getAttribute("class") == NULL ) {
 
                 group->setAttribute("transform", object->getAttribute("transform"));
-                g_slist_free(children);
                 children = object->childList(false);
             }
         }
     }
         
-    for (GSList* i = children; i != NULL; i = i->next ) {
-        Inkscape::XML::Node *repr = SP_OBJECT(i->data)->getRepr();
+    for (std::vector<SPObject*>::const_reverse_iterator i=children.rbegin();i!=children.rend();i++){
+        Inkscape::XML::Node *repr = (*i)->getRepr();
         repr->parent()->removeChild(repr);
         group->addChild(repr,NULL);
     }
@@ -3283,7 +3209,6 @@
 
     // Clean up
     Inkscape::GC::release(group);
-    g_slist_free(children);
 
     DocumentUndo::done(doc, SP_VERB_EDIT_UNSYMBOL, _("Group from symbol"));
 }
@@ -3318,12 +3243,12 @@
     move_p[Geom::Y] = -move_p[Geom::Y];
     Geom::Affine move = Geom::Affine(Geom::Translate(move_p));
 
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items (selection->itemList());
 
-    items = g_slist_sort(items, (GCompareFunc) sp_object_compare_position);
+    sort(items.begin(),items.end(),sp_object_compare_position);
 
     // bottommost object, after sorting
-    SPObject *parent = SP_OBJECT(items->data)->parent;
+    SPObject *parent = items[0]->parent;
     
 
     Geom::Affine parent_transform;
@@ -3337,23 +3262,21 @@
     }
 
     // remember the position of the first item
-    gint pos = SP_OBJECT(items->data)->getRepr()->position();
+    gint pos = items[0]->getRepr()->position();
 
     // create a list of duplicates
-    GSList *repr_copies = NULL;
-    for (GSList *i = items; i != NULL; i = i->next) {
-        Inkscape::XML::Node *dup = SP_OBJECT(i->data)->getRepr()->duplicate(xml_doc);
-        repr_copies = g_slist_prepend(repr_copies, dup);
+    std::vector<Inkscape::XML::Node*> repr_copies;
+    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        Inkscape::XML::Node *dup = (*i)->getRepr()->duplicate(xml_doc);
+        repr_copies.push_back(dup);
     }
-    // restore the z-order after prepends
-    repr_copies = g_slist_reverse(repr_copies);
 
     Geom::Rect bbox(desktop->dt2doc(r->min()), desktop->dt2doc(r->max()));
 
     if (apply) {
         // delete objects so that their clones don't get alerted; this object will be restored shortly
-        for (GSList *i = items; i != NULL; i = i->next) {
-            SPObject *item = reinterpret_cast<SPObject*>(i->data);
+        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+            SPObject *item = *i;
             item->deleteObject(false);
         }
     }
@@ -3399,7 +3322,6 @@
         selection->set(rectangle);
     }
 
-    g_slist_free(items);
 
     DocumentUndo::done(doc, SP_VERB_EDIT_TILE,
                        _("Objects to pattern"));
@@ -3422,15 +3344,13 @@
         return;
     }
 
-    GSList *new_select = NULL;
+    std::vector<SPItem*> new_select;
 
     bool did = false;
 
-    for (GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
-         items != NULL;
-         items = items->next) {
-
-        SPItem *item = static_cast<SPItem *>(items->data);
+    std::vector<SPItem*> items(selection->itemList());
+    for (std::vector<SPItem*>::const_reverse_iterator i=items.rbegin();i!=items.rend();i++){
+        SPItem *item = *i;
 
         SPStyle *style = item->style;
 
@@ -3466,7 +3386,7 @@
                     Geom::Affine transform( i->transform * pat_transform );
                     i->doWriteTransform(i->getRepr(), transform);
 
-                    new_select = g_slist_prepend(new_select, i);
+                    new_select.push_back(i);
                 } else {
                     g_assert_not_reached();
                 }
@@ -3493,18 +3413,14 @@
         return;
     }
 
-    GSList const *reprlst = selection->reprList();
+    std::vector<Inkscape::XML::Node*> const reprlst = selection->reprList();
     bool filename_search = TRUE;
     bool xdpi_search = TRUE;
     bool ydpi_search = TRUE;
 
-    for (; reprlst != NULL &&
-            filename_search &&
-            xdpi_search &&
-            ydpi_search;
-        reprlst = reprlst->next) {
+    for (std::vector<Inkscape::XML::Node*>::const_iterator i=reprlst.begin();filename_search&&xdpi_search&&ydpi_search&&i!=reprlst.end();i++){
         gchar const *dpi_string;
-        Inkscape::XML::Node * repr = static_cast<Inkscape::XML::Node *>(reprlst->data);
+        Inkscape::XML::Node *repr = *i;
 
         if (filename_search) {
             const gchar* tmp = repr->attribute("inkscape:export-filename");
@@ -3590,10 +3506,10 @@
     }
 
     // List of the items to show; all others will be hidden
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
 
     // Sort items so that the topmost comes last
-    items = g_slist_sort(items, (GCompareFunc) sp_item_repr_compare_position);
+    sort(items.begin(),items.end(),sp_item_repr_compare_position);
 
     // Generate a random value from the current time (you may create bitmap from the same object(s)
     // multiple times, and this is done so that they don't clash)
@@ -3604,7 +3520,7 @@
     // Create the filename.
     gchar *const basename = g_strdup_printf("%s-%s-%u.png",
                                             document->getName(),
-                                            SP_OBJECT(items->data)->getRepr()->attribute("id"),
+                                            items[0]->getRepr()->attribute("id"),
                                             current);
     // Imagemagick is known not to handle spaces in filenames, so we replace anything but letters,
     // digits, and a few other chars, with "_"
@@ -3624,8 +3540,8 @@
     //g_print("%s\n", filepath);
 
     // Remember parent and z-order of the topmost one
-    gint pos = SP_OBJECT(g_slist_last(items)->data)->getRepr()->position();
-    SPObject *parent_object = SP_OBJECT(g_slist_last(items)->data)->parent;
+    gint pos = items.back()->getRepr()->position();
+    SPObject *parent_object = items.back()->parent;
     Inkscape::XML::Node *parent = parent_object->getRepr();
 
     // Calculate resolution
@@ -3717,8 +3633,6 @@
                        true,  /*bool force_overwrite,*/
                        items);
 
-    g_slist_free(items);
-
     // Run filter, if any
     if (run) {
         g_print("Running external filter: %s\n", run);
@@ -3793,22 +3707,20 @@
         return;
     }
         
-    GSList const *l = const_cast<GSList *>(selection->reprList());
-
-    GSList *p = g_slist_copy(const_cast<GSList *>(l));
+    std::vector<Inkscape::XML::Node*> p(selection->reprList());
     
-    p = g_slist_sort(p, (GCompareFunc) sp_repr_compare_position);
+    sort(p.begin(),p.end(),sp_repr_compare_position);
 
     selection->clear();
 
-    gint topmost = (static_cast<Inkscape::XML::Node *>(g_slist_last(p)->data))->position();
-    Inkscape::XML::Node *topmost_parent = (static_cast<Inkscape::XML::Node *>(g_slist_last(p)->data))->parent();
+    int topmost = (p.back())->position();
+    Inkscape::XML::Node *topmost_parent = (p.back())->parent();
 
     Inkscape::XML::Node *inner = xml_doc->createElement("svg:g");
     inner->setAttribute("inkscape:label", "Clip");
     
-    while (p) {
-        Inkscape::XML::Node *current = static_cast<Inkscape::XML::Node *>(p->data);
+    for(std::vector<Inkscape::XML::Node*>::const_iterator i=p.begin();i!=p.end();i++){
+    	Inkscape::XML::Node *current = *i;
 
         if (current->parent() == topmost_parent) {
             Inkscape::XML::Node *spnew = current->duplicate(xml_doc);
@@ -3817,7 +3729,7 @@
             Inkscape::GC::release(spnew);
             topmost --; // only reduce count for those items deleted from topmost_parent
         } else { // move it to topmost_parent first
-            GSList *temp_clip = NULL;
+            std::vector<Inkscape::XML::Node*> temp_clip;
 
             // At this point, current may already have no item, due to its being a clone whose original is already moved away
             // So we copy it artificially calculating the transform from its repr->attr("transform") and the parent transform
@@ -3833,15 +3745,14 @@
             // then, if this is clone, looking up its original in that array and pre-multiplying
             // it by the inverse of that original's transform diff.
 
-            sp_selection_copy_one(current, item_t, &temp_clip, xml_doc);
+            sp_selection_copy_one(current, item_t, temp_clip, xml_doc);
             sp_repr_unparent(current);
 
             // paste into topmost_parent (temporarily)
-            GSList *copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), &temp_clip);
-            if (temp_clip) g_slist_free(temp_clip);
-            if (copied) { // if success,
+            std::vector<Inkscape::XML::Node*> copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), temp_clip);
+            if (!copied.empty()) { // if success,
                 // take pasted object (now in topmost_parent)
-                Inkscape::XML::Node *in_topmost = static_cast<Inkscape::XML::Node *>(copied->data);
+                Inkscape::XML::Node *in_topmost = copied.back();
                 // make a copy
                 Inkscape::XML::Node *spnew = in_topmost->duplicate(xml_doc);
                 // remove pasted
@@ -3849,10 +3760,8 @@
                 // put its copy into group
                 inner->appendChild(spnew);
                 Inkscape::GC::release(spnew);
-                g_slist_free(copied);
             }
         }
-        p = g_slist_remove(p, current);
     }
     
     Inkscape::XML::Node *outer = xml_doc->createElement("svg:g");
@@ -3910,7 +3819,7 @@
     if ( apply_to_layer && is_empty) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to create clippath or mask from."));
         return;
-    } else if (!apply_to_layer && ( is_empty || NULL == selection->itemList()->next )) {
+    } else if (!apply_to_layer && ( is_empty || selection->itemList().size()==1 )) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select mask object and <b>object(s)</b> to apply clippath or mask to."));
         return;
     }
@@ -3925,9 +3834,9 @@
 
     doc->ensureUpToDate();
 
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
 
-    items = g_slist_sort(items, (GCompareFunc) sp_object_compare_position);
+    sort(items.begin(),items.end(),sp_object_compare_position);
 
     // See lp bug #542004
     selection->clear();
@@ -3936,7 +3845,7 @@
     GSList *mask_items = NULL;
     GSList *apply_to_items = NULL;
     GSList *items_to_delete = NULL;
-    GSList *items_to_select = NULL;
+    std::vector<SPItem*> items_to_select;
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool topmost = prefs->getBool("/options/maskobject/topmost", true);
@@ -3947,38 +3856,38 @@
         // all selected items are used for mask, which is applied to a layer
         apply_to_items = g_slist_prepend(apply_to_items, desktop->currentLayer());
 
-        for (GSList *i = items; i != NULL; i = i->next) {
-            Inkscape::XML::Node *dup = SP_OBJECT(i->data)->getRepr()->duplicate(xml_doc);
+        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++) {
+            Inkscape::XML::Node *dup = (*i)->getRepr()->duplicate(xml_doc);
             mask_items = g_slist_prepend(mask_items, dup);
 
-            SPObject *item = reinterpret_cast<SPObject*>(i->data);
+            SPObject *item = *i;
             if (remove_original) {
                 items_to_delete = g_slist_prepend(items_to_delete, item);
             }
             else {
-                items_to_select = g_slist_prepend(items_to_select, item);
+                items_to_select.push_back((SPItem*)item);
             }
         }
     } else if (!topmost) {
         // topmost item is used as a mask, which is applied to other items in a selection
-        GSList *i = items;
-        Inkscape::XML::Node *dup = SP_OBJECT(i->data)->getRepr()->duplicate(xml_doc);
+        Inkscape::XML::Node *dup = items[0]->getRepr()->duplicate(xml_doc);
         mask_items = g_slist_prepend(mask_items, dup);
 
         if (remove_original) {
-            SPObject *item = reinterpret_cast<SPObject*>(i->data);
+            SPObject *item = items.front();
             items_to_delete = g_slist_prepend(items_to_delete, item);
         }
 
-        for (i = i->next; i != NULL; i = i->next) {
-            apply_to_items = g_slist_prepend(apply_to_items, i->data);
-            items_to_select = g_slist_prepend(items_to_select, i->data);
+        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++) {
+        	if(i==items.begin())continue;
+            apply_to_items = g_slist_prepend(apply_to_items, *i);
+            items_to_select.push_back(*i);
         }
     } else {
         GSList *i = NULL;
-        for (i = items; NULL != i->next; i = i->next) {
-            apply_to_items = g_slist_prepend(apply_to_items, i->data);
-            items_to_select = g_slist_prepend(items_to_select, i->data);
+        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++) {
+            apply_to_items = g_slist_prepend(apply_to_items, *i);
+            items_to_select.push_back(*i);
         }
 
         Inkscape::XML::Node *dup = SP_OBJECT(i->data)->getRepr()->duplicate(xml_doc);
@@ -3989,9 +3898,7 @@
             items_to_delete = g_slist_prepend(items_to_delete, item);
         }
     }
-
-    g_slist_free(items);
-    items = NULL;
+    items.clear();
 
     if (apply_to_items && grouping == PREFS_MASKOBJECT_GROUPING_ALL) {
         // group all those objects into one group
@@ -4001,24 +3908,21 @@
         // make a note we should ungroup this when unsetting mask
         group->setAttribute("inkscape:groupmode", "maskhelper");
 
-        GSList *reprs_to_group = NULL;
+        std::vector<Inkscape::XML::Node*> reprs_to_group;
 
         for (GSList *i = apply_to_items ; NULL != i ; i = i->next) {
-            reprs_to_group = g_slist_prepend(reprs_to_group, SP_OBJECT(i->data)->getRepr());
-            items_to_select = g_slist_remove(items_to_select, i->data);
+            reprs_to_group.push_back(static_cast<SPObject*>(i->data)->getRepr());
+            items_to_select.erase(find(items_to_select.begin(),items_to_select.end(),static_cast<SPObject*>(i->data)));
         }
-        reprs_to_group = g_slist_reverse(reprs_to_group);
 
         sp_selection_group_impl(reprs_to_group, group, xml_doc, doc);
 
-        reprs_to_group = NULL;
-
         // apply clip/mask only to newly created group
         g_slist_free(apply_to_items);
         apply_to_items = NULL;
         apply_to_items = g_slist_prepend(apply_to_items, doc->getObjectByRepr(group));
 
-        items_to_select = g_slist_prepend(items_to_select, doc->getObjectByRepr(group));
+        items_to_select.push_back((SPItem*)(doc->getObjectByRepr(group)));
 
         Inkscape::GC::release(group);
     }
@@ -4058,7 +3962,7 @@
 
             Inkscape::XML::Node *spnew = current->duplicate(xml_doc);
             gint position = current->position();
-            items_to_select = g_slist_remove(items_to_select, item);
+            items_to_select.erase(find(items_to_select.begin(),items_to_select.end(),item));
             current->parent()->appendChild(group);
             sp_repr_unparent(current);
             group->appendChild(spnew);
@@ -4067,7 +3971,7 @@
             // Apply clip/mask to group instead
             apply_mask_to = group;
 
-            items_to_select = g_slist_prepend(items_to_select, doc->getObjectByRepr(group));
+            items_to_select.push_back((SPItem*)(doc->getObjectByRepr(group)));
             Inkscape::GC::release(spnew);
             Inkscape::GC::release(group);
         }
@@ -4082,14 +3986,11 @@
     for (GSList *i = items_to_delete; NULL != i; i = i->next) {
         SPObject *item = reinterpret_cast<SPObject*>(i->data);
         item->deleteObject(false);
-        items_to_select = g_slist_remove(items_to_select, item);
+        items_to_select.erase(find(items_to_select.begin(),items_to_select.end(),item));
     }
     g_slist_free(items_to_delete);
 
-    items_to_select = g_slist_reverse(items_to_select);
-
     selection->addList(items_to_select);
-    g_slist_free(items_to_select);
 
     if (apply_clip_path) {
         DocumentUndo::done(doc, SP_VERB_OBJECT_SET_CLIPPATH, _("Set clipping path"));
@@ -4121,20 +4022,19 @@
     gchar const *attributeName = apply_clip_path ? "clip-path" : "mask";
     std::map<SPObject*,SPItem*> referenced_objects;
 
-    GSList *items = g_slist_copy(const_cast<GSList *>(selection->itemList()));
+    std::vector<SPItem*> items(selection->itemList());
     selection->clear();
 
     GSList *items_to_ungroup = NULL;
-    GSList *items_to_select = g_slist_copy(items);
-    items_to_select = g_slist_reverse(items_to_select);
+    std::vector<SPItem*> items_to_select(items);
 
 
     // SPObject* refers to a group containing the clipped path or mask itself,
     // whereas SPItem* refers to the item being clipped or masked
-    for (GSList const *i = items; NULL != i; i = i->next) {
+    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
         if (remove_original) {
             // remember referenced mask/clippath, so orphaned masks can be moved back to document
-            SPItem *item = reinterpret_cast<SPItem *>(i->data);
+            SPItem *item = *i;
             Inkscape::URIReference *uri_ref = NULL;
 
             if (apply_clip_path) {
@@ -4149,9 +4049,9 @@
             }
         }
 
-        SP_OBJECT(i->data)->getRepr()->setAttribute(attributeName, "none");
+        (*i)->getRepr()->setAttribute(attributeName, "none");
 
-        SPGroup *group = dynamic_cast<SPGroup *>(static_cast<SPObject *>(i->data));
+        SPGroup *group = dynamic_cast<SPGroup *>(*i);
         if (ungroup_masked && group) {
                 // if we had previously enclosed masked object in group,
                 // add it to list so we can ungroup it later
@@ -4163,7 +4063,6 @@
 
         }
     }
-    g_slist_free(items);
 
     // restore mask objects into a document
     for ( std::map<SPObject*,SPItem*>::iterator it = referenced_objects.begin() ; it != referenced_objects.end() ; ++it) {
@@ -4171,7 +4070,7 @@
         GSList *items_to_move = NULL;
         for ( SPObject *child = obj->firstChild() ; child; child = child->getNext() ) {
             // Collect all clipped paths and masks within a single group
-            Inkscape::XML::Node *copy = SP_OBJECT(child)->getRepr()->duplicate(xml_doc);
+            Inkscape::XML::Node *copy = child->getRepr()->duplicate(xml_doc);
             if(copy->attribute("inkscape:original-d") && copy->attribute("inkscape:path-effect"))
             {
                 copy->setAttribute("d", copy->attribute("inkscape:original-d"));
@@ -4197,7 +4096,7 @@
             repr->setPosition((pos + 1) > 0 ? (pos + 1) : 0);
 
             SPItem *mask_item = static_cast<SPItem *>(desktop->getDocument()->getObjectByRepr(repr));
-            items_to_select = g_slist_prepend(items_to_select, mask_item);
+            items_to_select.push_back(mask_item);
 
             // transform mask, so it is moved the same spot where mask was applied
             Geom::Affine transform(mask_item->transform);
@@ -4212,10 +4111,10 @@
     for (GSList *i = items_to_ungroup ; NULL != i ; i = i->next) {
         SPGroup *group = dynamic_cast<SPGroup *>(static_cast<SPObject *>(i->data));
         if (group) {
-            items_to_select = g_slist_remove(items_to_select, group);
-            GSList *children = NULL;
-            sp_item_group_ungroup(group, &children, false);
-            items_to_select = g_slist_concat(children, items_to_select);
+            items_to_select.erase(find(items_to_select.begin(),items_to_select.end(),group));
+            std::vector<SPItem*> children;
+            sp_item_group_ungroup(group, children, false);
+            items_to_select.insert(items_to_select.end(),children.rbegin(),children.rend());
         } else {
             g_assert_not_reached();
         }
@@ -4224,9 +4123,7 @@
     g_slist_free(items_to_ungroup);
 
     // rebuild selection
-    items_to_select = g_slist_reverse(items_to_select);
     selection->addList(items_to_select);
-    g_slist_free(items_to_select);
 
     if (apply_clip_path) {
         DocumentUndo::done(doc, SP_VERB_OBJECT_UNSET_CLIPPATH, _("Release clipping path"));

=== modified file 'src/selection-chemistry.h'
--- src/selection-chemistry.h	2015-02-20 15:50:51 +0000
+++ src/selection-chemistry.h	2015-04-29 21:03:59 +0000
@@ -143,8 +143,9 @@
 
 void sp_select_same_fill_stroke_style(SPDesktop *desktop, gboolean fill, gboolean strok, gboolean style);
 void sp_select_same_object_type(SPDesktop *desktop);
-GSList *sp_get_same_style(SPItem *sel, GSList *src, SPSelectStrokeStyleType type=SP_STYLE_ALL);
-GSList *sp_get_same_object_type(SPItem *sel, GSList *src);
+
+std::vector<SPItem*> sp_get_same_style(SPItem *sel, std::vector<SPItem*> &src, SPSelectStrokeStyleType type=SP_STYLE_ALL);
+std::vector<SPItem*> sp_get_same_object_type(SPItem *sel, std::vector<SPItem*> &src);
 
 void scroll_to_show_item(SPDesktop *desktop, SPItem *item);
 
@@ -171,9 +172,9 @@
 void unhide_all(SPDesktop *dt);
 void unhide_all_in_all_layers(SPDesktop *dt);
 
-GSList *get_all_items(GSList *list, SPObject *from, SPDesktop *desktop, bool onlyvisible, bool onlysensitive, bool ingroups, GSList const *exclude);
+std::vector<SPItem*> &get_all_items(std::vector<SPItem*> &list, SPObject *from, SPDesktop *desktop, bool onlyvisible, bool onlysensitive, bool ingroups, std::vector<SPItem*> const &exclude);
 
-GSList *sp_degroup_list (GSList *items);
+std::vector<SPItem*> sp_degroup_list (std::vector<SPItem*> &items);
 
 /* selection cycling */
 typedef enum

=== modified file 'src/selection-describer.cpp'
--- src/selection-describer.cpp	2015-03-06 08:51:53 +0000
+++ src/selection-describer.cpp	2015-04-29 21:03:59 +0000
@@ -40,14 +40,14 @@
 #include "sp-spiral.h"
 
 // Returns a list of terms for the items to be used in the statusbar
-char* collect_terms (GSList *items)
+char* collect_terms (const std::vector<SPItem*> &items)
 {
     GSList *check = NULL;
     std::stringstream ss;
     bool first = true;
 
-    for (GSList *i = (GSList *)items; i != NULL; i = i->next) {
-        SPItem *item = dynamic_cast<SPItem *>(reinterpret_cast<SPObject *>(i->data));
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *item = *iter;
         if (item) {
             const char *term = item->displayName();
             if (term != NULL && g_slist_find (check, term) == NULL) {
@@ -61,12 +61,12 @@
 }
 
 // Returns the number of terms in the list
-static int count_terms (GSList *items)
+static int count_terms (const std::vector<SPItem*> &items)
 {
     GSList *check = NULL;
     int count=0;
-    for (GSList *i = (GSList *)items; i != NULL; i = i->next) {
-        SPItem *item = dynamic_cast<SPItem *>(reinterpret_cast<SPObject *>(i->data));
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *item = *iter;
         if (item) {
             const char *term = item->displayName();
             if (term != NULL && g_slist_find (check, term) == NULL) {
@@ -79,11 +79,11 @@
 }
 
 // Returns the number of filtered items in the list
-static int count_filtered (GSList *items)
+static int count_filtered (const std::vector<SPItem*> &items)
 {
     int count=0;
-    for (GSList *i = items; i != NULL; i = i->next) {
-        SPItem *item = dynamic_cast<SPItem *>(reinterpret_cast<SPObject *>((i->data)));
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *item = *iter;
         if (item) {
             count += item->isFiltered();
         }
@@ -122,12 +122,12 @@
 }
 
 void SelectionDescriber::_updateMessageFromSelection(Inkscape::Selection *selection) {
-    GSList const *items = selection->itemList();
+	std::vector<SPItem*> const items = selection->itemList();
 
-    if (!items) { // no items
+    if (items.empty()) { // no items
         _context.set(Inkscape::NORMAL_MESSAGE, _when_nothing);
     } else {
-        SPItem *item = dynamic_cast<SPItem *>(reinterpret_cast<SPObject *>(items->data));
+        SPItem *item = items[0];
         g_assert(item != NULL);
         SPObject *layer = selection->layers()->layerForObject(item);
         SPObject *root = selection->layers()->currentRoot();
@@ -188,7 +188,7 @@
         g_free (layer_name);
         g_free (parent_name);
 
-        if (!items->next) { // one item
+        if (items.size()==1) { // one item
             char *item_desc = item->detailedDescription();
 
             bool isUse = dynamic_cast<SPUse *>(item) != NULL;
@@ -228,9 +228,9 @@
 
             g_free(item_desc);
         } else { // multiple items
-            int objcount = g_slist_length((GSList *)items);
-            char *terms = collect_terms ((GSList *)items);
-            int n_terms = count_terms((GSList *)items);
+            int objcount = items.size();
+            char *terms = collect_terms (items);
+            int n_terms = count_terms(items);
             
             gchar *objects_str = g_strdup_printf(ngettext(
                 "<b>%1$i</b> objects selected of type %2$s",
@@ -241,7 +241,7 @@
 
             // indicate all, some, or none filtered
             gchar *filt_str = NULL;
-            int n_filt = count_filtered((GSList *)items);  //all filtered
+            int n_filt = count_filtered(items);  //all filtered
             if (n_filt) {
                 filt_str = g_strdup_printf(ngettext("; <i>%d filtered object</i> ",
                                                      "; <i>%d filtered objects</i> ", n_filt), n_filt);

=== modified file 'src/selection.cpp'
--- src/selection.cpp	2014-06-27 19:23:06 +0000
+++ src/selection.cpp	2015-04-29 21:03:59 +0000
@@ -42,9 +42,11 @@
 namespace Inkscape {
 
 Selection::Selection(LayerModel *layers, SPDesktop *desktop) :
-    _objs(NULL),
-    _reprs(NULL),
-    _items(NULL),
+    _objs(std::list<SPObject*>()),
+    _objs_vector(std::vector<SPObject*>()),
+    _objs_set(std::set<SPObject*>()),
+    _reprs(std::vector<XML::Node*>()),
+    _items(std::vector<SPItem*>()),
     _layers(layers),
     _desktop(desktop),
     _selection_context(NULL),
@@ -121,17 +123,14 @@
 }
 
 void Selection::_invalidateCachedLists() {
-    g_slist_free(_items);
-    _items = NULL;
-
-    g_slist_free(_reprs);
-    _reprs = NULL;
+    _items.clear();
+    _reprs.clear();
 }
 
 void Selection::_clear() {
     _invalidateCachedLists();
-    while (_objs) {
-        SPObject *obj=reinterpret_cast<SPObject *>(_objs->data);
+    while (!_objs.empty()) {
+        SPObject *obj=_objs.front();
         _remove(obj);
     }
 }
@@ -148,7 +147,7 @@
 
     g_return_val_if_fail(SP_IS_OBJECT(obj), FALSE);
 
-    return ( g_slist_find(_objs, obj) != NULL );
+    return ( _objs_set.find(obj)!=_objs_set.end() );
 }
 
 void Selection::add(SPObject *obj, bool persist_selection_context/* = false */) {
@@ -180,7 +179,8 @@
     _removeObjectDescendants(obj);
     _removeObjectAncestors(obj);
 
-    _objs = g_slist_prepend(_objs, obj);
+    _objs.push_front(obj);
+    _objs_set.insert(obj);
 
     add_3D_boxes_recursively(obj);
 
@@ -234,26 +234,27 @@
 
     remove_3D_boxes_recursively(obj);
 
-    _objs = g_slist_remove(_objs, obj);
+    _objs.remove(obj);
+    _objs_set.erase(obj);
 }
 
-void Selection::setList(GSList const *list) {
+void Selection::setList(std::vector<SPItem*> const &list) {
     // Clear and add, or just clear with emit.
-    if (list != NULL) {
+    if (!list.empty()) {
         _clear();
         addList(list);
     } else clear();
 }
 
-void Selection::addList(GSList const *list) {
+void Selection::addList(std::vector<SPItem*> const &list) {
 
-    if (list == NULL)
+    if (list.empty())
         return;
 
     _invalidateCachedLists();
 
-    for ( GSList const *iter = list ; iter != NULL ; iter = iter->next ) {
-        SPObject *obj = reinterpret_cast<SPObject *>(iter->data);
+    for ( std::vector<SPItem*>::const_iterator iter=list.begin();iter!=list.end();iter++ ) {
+        SPObject *obj = *iter;
         if (includes(obj)) continue;
         _add (obj);
     }
@@ -261,11 +262,11 @@
     _emitChanged();
 }
 
-void Selection::setReprList(GSList const *list) {
+void Selection::setReprList(std::vector<XML::Node*> const &list) {
     _clear();
 
-    for ( GSList const *iter = list ; iter != NULL ; iter = iter->next ) {
-        SPObject *obj=_objectForXMLNode(reinterpret_cast<Inkscape::XML::Node *>(iter->data));
+    for ( std::vector<XML::Node*>::const_reverse_iterator iter=list.rbegin();iter!=list.rend();iter++ ) {
+        SPObject *obj=_objectForXMLNode(*iter);
         if (obj) {
             _add(obj);
         }
@@ -279,35 +280,38 @@
     _emitChanged();
 }
 
-GSList const *Selection::list() {
-    return _objs;
+std::vector<SPObject*> const &Selection::list() {
+    if(!_objs_vector.empty())
+    return _objs_vector;
+
+    for ( std::list<SPObject*>::const_iterator iter=_objs.begin();iter!=_objs.end();iter++ ) {
+            _objs_vector.push_back(*iter);
+    }
+    return _objs_vector;
+
 }
 
-GSList const *Selection::itemList() {
-    if (_items) {
+std::vector<SPItem*> const &Selection::itemList() {
+    if (!_items.empty()) {
         return _items;
     }
 
-    for ( GSList const *iter=_objs ; iter != NULL ; iter = iter->next ) {
-        SPObject *obj=reinterpret_cast<SPObject *>(iter->data);
+    for ( std::list<SPObject*>::const_iterator iter=_objs.begin();iter!=_objs.end();iter++ ) {
+        SPObject *obj=*iter;
         if (SP_IS_ITEM(obj)) {
-            _items = g_slist_prepend(_items, SP_ITEM(obj));
+            _items.push_back(SP_ITEM(obj));
         }
     }
-    _items = g_slist_reverse(_items);
-
     return _items;
 }
 
-GSList const *Selection::reprList() {
-    if (_reprs) { return _reprs; }
-
-    for ( GSList const *iter=itemList() ; iter != NULL ; iter = iter->next ) {
-        SPObject *obj=reinterpret_cast<SPObject *>(iter->data);
-        _reprs = g_slist_prepend(_reprs, obj->getRepr());
+std::vector<XML::Node*> const &Selection::reprList() {
+    if (!_reprs.empty()) { return _reprs; }
+    std::vector<SPItem*> list = itemList();
+    for ( std::vector<SPItem*>::const_iterator iter=list.begin();iter!=list.end();iter++ ) {
+        SPObject *obj = *iter;
+        _reprs.push_back(obj->getRepr());
     }
-    _reprs = g_slist_reverse(_reprs);
-
     return _reprs;
 }
 
@@ -337,17 +341,17 @@
 }
 
 SPObject *Selection::single() {
-    if ( _objs != NULL && _objs->next == NULL ) {
-        return reinterpret_cast<SPObject *>(_objs->data);
+    if ( _objs.size() == 1 ) {
+        return _objs.front();
     } else {
         return NULL;
     }
 }
 
 SPItem *Selection::singleItem() {
-    GSList const *items=itemList();
-    if ( items != NULL && items->next == NULL ) {
-        return reinterpret_cast<SPItem *>(items->data);
+    std::vector<SPItem*> const items=itemList();
+    if ( items.size()==1) {
+        return items[0];
     } else {
         return NULL;
     }
@@ -362,12 +366,12 @@
 }
 
 SPItem *Selection::_sizeistItem(bool sml, Selection::CompareSize compare) {
-    GSList const *items = const_cast<Selection *>(this)->itemList();
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
     gdouble max = sml ? 1e18 : 0;
     SPItem *ist = NULL;
 
-    for ( GSList const *i = items; i != NULL ; i = i->next ) {
-        Geom::OptRect obox = SP_ITEM(i->data)->desktopPreferredBounds();
+    for ( std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++ ) {
+        Geom::OptRect obox = SP_ITEM(*i)->desktopPreferredBounds();
         if (!obox || obox.isEmpty()) continue;
         Geom::Rect bbox = *obox;
 
@@ -376,7 +380,7 @@
         size = sml ? size : size * -1;
         if (size < max) {
             max = size;
-            ist = SP_ITEM(i->data);
+            ist = SP_ITEM(*i);
         }
     }
     return ist;
@@ -395,22 +399,22 @@
 
 Geom::OptRect Selection::geometricBounds() const
 {
-    GSList const *items = const_cast<Selection *>(this)->itemList();
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
 
     Geom::OptRect bbox;
-    for ( GSList const *i = items ; i != NULL ; i = i->next ) {
-        bbox.unionWith(SP_ITEM(i->data)->desktopGeometricBounds());
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        bbox.unionWith(SP_ITEM(*iter)->desktopGeometricBounds());
     }
     return bbox;
 }
 
 Geom::OptRect Selection::visualBounds() const
 {
-    GSList const *items = const_cast<Selection *>(this)->itemList();
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
 
     Geom::OptRect bbox;
-    for ( GSList const *i = items ; i != NULL ; i = i->next ) {
-        bbox.unionWith(SP_ITEM(i->data)->desktopVisualBounds());
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        bbox.unionWith(SP_ITEM(*iter)->desktopVisualBounds());
     }
     return bbox;
 }
@@ -427,11 +431,11 @@
 Geom::OptRect Selection::documentBounds(SPItem::BBoxType type) const
 {
     Geom::OptRect bbox;
-    GSList const *items = const_cast<Selection *>(this)->itemList();
-    if (!items) return bbox;
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
+    if (items.empty()) return bbox;
 
-    for ( GSList const *iter=items ; iter != NULL ; iter = iter->next ) {
-        SPItem *item = SP_ITEM(iter->data);
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *item = SP_ITEM(*iter);
         bbox |= item->documentBounds(type);
     }
 
@@ -441,9 +445,9 @@
 // If we have a selection of multiple items, then the center of the first item
 // will be returned; this is also the case in SelTrans::centerRequest()
 boost::optional<Geom::Point> Selection::center() const {
-    GSList *items = (GSList *) const_cast<Selection *>(this)->itemList();
-    if (items) {
-        SPItem *first = reinterpret_cast<SPItem*>(g_slist_last(items)->data); // from the first item in selection
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
+    if (!items.empty()) {
+        SPItem *first = items.back(); // from the first item in selection
         if (first->isCenterSet()) { // only if set explicitly
             return first->getCenter();
         }
@@ -457,13 +461,13 @@
 }
 
 std::vector<Inkscape::SnapCandidatePoint> Selection::getSnapPoints(SnapPreferences const *snapprefs) const {
-    GSList const *items = const_cast<Selection *>(this)->itemList();
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
 
     SnapPreferences snapprefs_dummy = *snapprefs; // create a local copy of the snapping prefs
     snapprefs_dummy.setTargetSnappable(Inkscape::SNAPTARGET_ROTATION_CENTER, false); // locally disable snapping to the item center
     std::vector<Inkscape::SnapCandidatePoint> p;
-    for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-        SPItem *this_item = SP_ITEM(iter->data);
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *this_item = *iter;
         this_item->getSnappoints(p, &snapprefs_dummy);
 
         //Include the transformation origin for snapping
@@ -477,10 +481,8 @@
 }
 
 void Selection::_removeObjectDescendants(SPObject *obj) {
-    GSList *iter, *next;
-    for ( iter = _objs ; iter ; iter = next ) {
-        next = iter->next;
-        SPObject *sel_obj=reinterpret_cast<SPObject *>(iter->data);
+    for ( std::list<SPObject*>::const_iterator iter=_objs.begin();iter!=_objs.end();iter++ ) {
+        SPObject *sel_obj= *iter;
         SPObject *parent = sel_obj->parent;
         while (parent) {
             if ( parent == obj ) {
@@ -511,32 +513,24 @@
     return object;
 }
 
-guint Selection::numberOfLayers() {
-    GSList const *items = const_cast<Selection *>(this)->itemList();
-    GSList *layers = NULL;
-    for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-        SPObject *layer = _layers->layerForObject(SP_OBJECT(iter->data));
-        if (g_slist_find (layers, layer) == NULL) {
-            layers = g_slist_prepend (layers, layer);
-        }
+uint Selection::numberOfLayers() {
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
+    std::set<SPObject*> layers;
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPObject *layer = _layers->layerForObject(*iter);
+        layers.insert(layer);
     }
-    guint ret = g_slist_length (layers);
-    g_slist_free (layers);
-    return ret;
+    return layers.size();
 }
 
 guint Selection::numberOfParents() {
-    GSList const *items = const_cast<Selection *>(this)->itemList();
-    GSList *parents = NULL;
-    for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-        SPObject *parent = SP_OBJECT(iter->data)->parent;
-        if (g_slist_find (parents, parent) == NULL) {
-            parents = g_slist_prepend (parents, parent);
-        }
+    std::vector<SPItem*> const items = const_cast<Selection *>(this)->itemList();
+    std::set<SPObject*> parents;
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPObject *parent = (*iter)->parent;
+        parents.insert(parent);
     }
-    guint ret = g_slist_length (parents);
-    g_slist_free (parents);
-    return ret;
+    return parents.size();
 }
 
 }

=== modified file 'src/selection.h'
--- src/selection.h	2015-02-26 02:49:35 +0000
+++ src/selection.h	2015-04-29 21:03:59 +0000
@@ -16,6 +16,7 @@
 #include <vector>
 #include <map>
 #include <list>
+#include <set>
 #include <stddef.h>
 #include <sigc++/sigc++.h>
 
@@ -26,11 +27,11 @@
 #include "sp-item.h"
 
 
+
 class SPDesktop;
 class SPItem;
 class SPBox3D;
 class Persp3D;
-typedef struct _GSList GSList;
 
 namespace Inkscape {
 class LayerModel;
@@ -39,6 +40,7 @@
 }
 }
 
+
 namespace Inkscape {
 
 /**
@@ -154,21 +156,21 @@
      *
      * @param objs the objects to select
      */
-    void setList(GSList const *objs);
+    void setList(std::vector<SPItem*> const &objs);
 
     /**
      * Adds the specified objects to selection, without deselecting first.
      *
      * @param objs the objects to select
      */
-    void addList(GSList const *objs);
+    void addList(std::vector<SPItem*> const &objs);
 
     /**
      * Clears the selection and selects the specified objects.
      *
      * @param repr a list of xml nodes for the items to select
      */
-    void setReprList(GSList const *reprs);
+    void setReprList(std::vector<XML::Node*> const &reprs);
 
     /**  Add items from an STL iterator range to the selection.
      *  \param  from the begin iterator
@@ -192,7 +194,7 @@
     /**
      * Returns true if no items are selected.
      */
-    bool isEmpty() const { return _objs == NULL; }
+    bool isEmpty() const { return _objs.empty(); }
 
     /**
      * Returns true if the given object is selected.
@@ -238,13 +240,13 @@
     XML::Node *singleRepr();
 
     /** Returns the list of selected objects. */
-    GSList const *list();
+    std::vector<SPObject*> const &list();
     /** Returns the list of selected SPItems. */
-    GSList const *itemList();
+    std::vector<SPItem*> const &itemList();
     /** Returns a list of the xml nodes of all selected objects. */
     /// \todo only returns reprs of SPItems currently; need a separate
     ///      method for that
-    GSList const *reprList();
+    std::vector<XML::Node*> const &reprList();
 
     /** Returns a list of all perspectives which have a 3D box in the current selection.
        (these may also be nested in groups) */
@@ -360,9 +362,11 @@
     /** Releases an active layer object that is being removed. */
     void _releaseContext(SPObject *obj);
 
-    mutable GSList *_objs;
-    mutable GSList *_reprs;
-    mutable GSList *_items;
+    mutable std::list<SPObject*> _objs; //to more efficiently remove arbitrary elements
+    mutable std::vector<SPObject*> _objs_vector; // to be returned by list();
+    mutable std::set<SPObject*> _objs_set; //to efficiently test if object is selected
+    mutable std::vector<XML::Node*> _reprs;
+    mutable std::vector<SPItem*> _items;
 
     void add_box_perspective(SPBox3D *box);
     void add_3D_boxes_recursively(SPObject *obj);

=== modified file 'src/seltrans.cpp'
--- src/seltrans.cpp	2014-12-21 21:58:32 +0000
+++ src/seltrans.cpp	2015-04-29 21:03:59 +0000
@@ -112,7 +112,7 @@
     _opposite_for_bboxpoints(Geom::Point(0,0)),
     _origin_for_specpoints(Geom::Point(0,0)),
     _origin_for_bboxpoints(Geom::Point(0,0)),
-    _stamp_cache(NULL),
+    _stamp_cache(std::vector<SPItem*>()),
     _message_context(desktop->messageStack()),
     _bounding_box_prefs_observer(*this)
 {
@@ -239,8 +239,9 @@
     _center_is_set = true;
 
     // Write the new center position into all selected items
-    for (GSList const *l = _desktop->selection->itemList(); l; l = l->next) {
-        SPItem *it = SP_ITEM(l->data);
+    std::vector<SPItem*> items=_desktop->selection->itemList();
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *it = SP_ITEM(*iter);
         it->setCenter(p);
         // only set the value; updating repr and document_done will be done once, on ungrab
     }
@@ -268,8 +269,9 @@
         return;
     }
 
-    for (GSList const *l = selection->itemList(); l; l = l->next) {
-        SPItem *it = reinterpret_cast<SPItem*>(sp_object_ref(SP_ITEM(l->data), NULL));
+    std::vector<SPItem*> items=_desktop->selection->itemList();
+    for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+        SPItem *it = static_cast<SPItem*>(sp_object_ref(*iter, NULL));
         _items.push_back(it);
         _items_const.push_back(it);
         _items_affines.push_back(it->i2dt_affine());
@@ -370,7 +372,7 @@
     }
 
     _updateHandles();
-    g_return_if_fail(_stamp_cache == NULL);
+    g_return_if_fail(_stamp_cache.empty());
 }
 
 void Inkscape::SelTrans::transform(Geom::Affine const &rel_affine, Geom::Point const &norm)
@@ -432,10 +434,8 @@
         for (int i = 0; i < 4; i++)
             sp_canvas_item_hide(_l[i]);
     }
-
-    if (_stamp_cache) {
-        g_slist_free(_stamp_cache);
-        _stamp_cache = NULL;
+    if(!_stamp_cache.empty()){
+        _stamp_cache.clear();
     }
 
     _message_context.clear();
@@ -491,8 +491,9 @@
 
         if (_center_is_set) {
             // we were dragging center; update reprs and commit undoable action
-            for (GSList const *l = _desktop->selection->itemList(); l; l = l->next) {
-                SPItem *it = SP_ITEM(l->data);
+        	std::vector<SPItem*> items=_desktop->selection->itemList();
+            for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+                SPItem *it = *iter;
                 it->updateRepr();
             }
             DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_SELECT,
@@ -515,26 +516,25 @@
     Inkscape::Selection *selection = _desktop->getSelection();
 
     bool fixup = !_grabbed;
-    if ( fixup && _stamp_cache ) {
+    if ( fixup && !_stamp_cache.empty() ) {
         // TODO - give a proper fix. Simple temporary work-around for the grab() issue
-        g_slist_free(_stamp_cache);
-        _stamp_cache = NULL;
+        _stamp_cache.clear();
     }
 
     /* stamping mode */
     if (!_empty) {
-        GSList *l;
-        if (_stamp_cache) {
+    	std::vector<SPItem*> l;
+        if (!_stamp_cache.empty()) {
             l = _stamp_cache;
         } else {
             /* Build cache */
-            l  = g_slist_copy((GSList *) selection->itemList());
-            l  = g_slist_sort(l, (GCompareFunc) sp_object_compare_position);
+            l = selection->itemList();
+            sort(l.begin(),l.end(),sp_object_compare_position);
             _stamp_cache = l;
         }
 
-        while (l) {
-            SPItem *original_item = SP_ITEM(l->data);
+        for(std::vector<SPItem*>::const_iterator x=l.begin();x!=l.end();x++) {
+            SPItem *original_item = *x;
             Inkscape::XML::Node *original_repr = original_item->getRepr();
 
             // remember the position of the item
@@ -568,16 +568,14 @@
             }
 
             Inkscape::GC::release(copy_repr);
-            l = l->next;
         }
         DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_SELECT,
                            _("Stamp"));
     }
 
-    if ( fixup && _stamp_cache ) {
+    if ( fixup && !_stamp_cache.empty() ) {
         // TODO - give a proper fix. Simple temporary work-around for the grab() issue
-        g_slist_free(_stamp_cache);
-        _stamp_cache = NULL;
+        _stamp_cache.clear();
     }
 }
 
@@ -712,8 +710,9 @@
         case HANDLE_CENTER:
             if (state & GDK_SHIFT_MASK) {
                 // Unset the  center position for all selected items
-                for (GSList const *l = _desktop->selection->itemList(); l; l = l->next) {
-                    SPItem *it = SP_ITEM(l->data);
+            	std::vector<SPItem*> items=_desktop->selection->itemList();
+                for ( std::vector<SPItem*>::const_iterator iter=items.begin();iter!=items.end();iter++ ) {
+                    SPItem *it = *iter;
                     it->unsetCenter();
                     it->updateRepr();
                     _center_is_set = false;  // center has changed
@@ -1283,7 +1282,7 @@
     // items will share a single center. While dragging that single center, it should never snap to the
     // centers of any of the selected objects. Therefore we will have to pass the list of selected items
     // to the snapper, to avoid self-snapping of the rotation center
-    GSList *items = (GSList *) const_cast<Selection *>(_selection)->itemList();
+	std::vector<SPItem*> items = const_cast<Selection *>(_selection)->itemList();
     SnapManager &m = _desktop->namedview->snap_manager;
     m.setup(_desktop);
     m.setRotationCenterSource(items);

=== modified file 'src/seltrans.h'
--- src/seltrans.h	2014-10-08 02:22:03 +0000
+++ src/seltrans.h	2015-04-29 21:03:59 +0000
@@ -187,7 +187,7 @@
     SPCtrlLine *_l[4];
     unsigned int _sel_changed_id;
     unsigned int _sel_modified_id;
-    GSList *_stamp_cache;
+    std::vector<SPItem*> _stamp_cache;
 
     Geom::Point _origin; ///< position of origin for transforms
     Geom::Point _point; ///< original position of the knot being used for the current transform

=== modified file 'src/snap.cpp'
--- src/snap.cpp	2015-02-25 23:08:51 +0000
+++ src/snap.cpp	2015-04-29 21:03:59 +0000
@@ -43,7 +43,7 @@
     object(this, 0),
     snapprefs(),
     _named_view(v),
-    _rotation_center_source_items(NULL),
+    _rotation_center_source_items(std::vector<SPItem*>()),
     _guide_to_ignore(NULL),
     _desktop(NULL),
     _snapindicator(true),
@@ -1013,7 +1013,7 @@
     _snapindicator = snapindicator;
     _unselected_nodes = unselected_nodes;
     _guide_to_ignore = guide_to_ignore;
-    _rotation_center_source_items = NULL;
+    _rotation_center_source_items.clear();
 }
 
 void SnapManager::setup(SPDesktop const *desktop,
@@ -1031,7 +1031,7 @@
     _snapindicator = snapindicator;
     _unselected_nodes = unselected_nodes;
     _guide_to_ignore = guide_to_ignore;
-    _rotation_center_source_items = NULL;
+    _rotation_center_source_items.clear();
 }
 
 /// Setup, taking the list of items to ignore from the desktop's selection.
@@ -1049,13 +1049,13 @@
     _snapindicator = snapindicator;
     _unselected_nodes = unselected_nodes;
     _guide_to_ignore = guide_to_ignore;
-    _rotation_center_source_items = NULL;
+    _rotation_center_source_items.clear();
     _items_to_ignore.clear();
 
     Inkscape::Selection *sel = _desktop->selection;
-    GSList const *items = sel->itemList();
-    for (GSList *i = const_cast<GSList*>(items); i; i = i->next) {
-        _items_to_ignore.push_back(static_cast<SPItem const *>(i->data));
+    std::vector<SPItem*> const items = sel->itemList();
+    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++) {
+        _items_to_ignore.push_back(*i);
     }
 }
 

=== modified file 'src/snap.h'
--- src/snap.h	2014-10-08 02:22:03 +0000
+++ src/snap.h	2015-04-29 21:03:59 +0000
@@ -136,7 +136,7 @@
                               std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes = NULL,
                               SPGuide *guide_to_ignore = NULL);
 
-    void unSetup() {_rotation_center_source_items = NULL;
+    void unSetup() {_rotation_center_source_items.clear();
                     _guide_to_ignore = NULL;
                     _desktop = NULL;
                     _unselected_nodes = NULL;}
@@ -145,8 +145,8 @@
     // of this rotation center; this reference is used to make sure that we do not snap a rotation
     // center to itself
     // NOTE: Must be called after calling setup(), not before!
-    void setRotationCenterSource(GSList *items) {_rotation_center_source_items = items;}
-    GSList const *getRotationCenterSource() {return _rotation_center_source_items;}
+    void setRotationCenterSource(const std::vector<SPItem*> &items) {_rotation_center_source_items = items;}
+    const std::vector<SPItem*> &getRotationCenterSource() {return _rotation_center_source_items;}
 
     // freeSnapReturnByRef() is preferred over freeSnap(), because it only returns a
     // point if snapping has occurred (by overwriting p); otherwise p is untouched
@@ -490,7 +490,7 @@
 
 private:
     std::vector<SPItem const *> _items_to_ignore; ///< Items that should not be snapped to, for example the items that are currently being dragged. Set using the setup() method
-    GSList *_rotation_center_source_items; // to avoid snapping a rotation center to itself
+    std::vector<SPItem*> _rotation_center_source_items; // to avoid snapping a rotation center to itself
     SPGuide *_guide_to_ignore; ///< A guide that should not be snapped to, e.g. the guide that is currently being dragged
     SPDesktop const *_desktop;
     bool _snapindicator; ///< When true, an indicator will be drawn at the position that was being snapped to

=== modified file 'src/sp-conn-end.cpp'
--- src/sp-conn-end.cpp	2014-03-30 22:01:25 +0000
+++ src/sp-conn-end.cpp	2015-04-29 21:03:59 +0000
@@ -50,8 +50,9 @@
 
         // consider all first-order children
         double child_pos = 0.0;
-        for (GSList const* i = sp_item_group_item_list(group); i != NULL; i = i->next) {
-            SPItem* child_item = SP_ITEM(i->data);
+        std::vector<SPItem*> g = sp_item_group_item_list(group);
+        for (std::vector<SPItem*>::const_iterator i = g.begin();i!=g.end();i++) {
+            SPItem* child_item = *i;
             try_get_intersect_point_with_item_recursive(conn_pv, child_item,
                     item_transform * child_item->transform, child_pos);
             if (intersect_pos < child_pos)

=== modified file 'src/sp-defs.cpp'
--- src/sp-defs.cpp	2015-02-25 00:22:08 +0000
+++ src/sp-defs.cpp	2015-04-29 21:03:59 +0000
@@ -36,11 +36,9 @@
     }
 
     flags &= SP_OBJECT_MODIFIED_CASCADE;
-
-    GSList *l = g_slist_reverse(this->childList(true));
-    while (l) {
-        SPObject *child = SP_OBJECT(l->data);
-        l = g_slist_remove(l, child);
+    std::vector<SPObject*> l(this->childList(true));
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *child = *i;
         if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
             child->updateDisplay(ctx, flags);
         }

=== modified file 'src/sp-filter.cpp'
--- src/sp-filter.cpp	2015-02-25 00:22:08 +0000
+++ src/sp-filter.cpp	2015-04-29 21:03:59 +0000
@@ -235,11 +235,9 @@
       childflags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
     }
     childflags &= SP_OBJECT_MODIFIED_CASCADE;
-
-    GSList *l = g_slist_reverse(this->childList(true, SPObject::ActionUpdate));
-    while (l) {
-        SPObject *child = SP_OBJECT (l->data);
-        l = g_slist_remove (l, child);
+    std::vector<SPObject*> l(this->childList(true, SPObject::ActionUpdate));
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *child = *i;
         if( SP_IS_FILTER_PRIMITIVE( child ) ) {
             child->updateDisplay(ctx, childflags);
         }

=== modified file 'src/sp-item-group.cpp'
--- src/sp-item-group.cpp	2015-03-12 08:19:08 +0000
+++ src/sp-item-group.cpp	2015-04-29 21:03:59 +0000
@@ -161,11 +161,9 @@
       childflags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
     }
     childflags &= SP_OBJECT_MODIFIED_CASCADE;
-
-    GSList *l = g_slist_reverse(this->childList(true, SPObject::ActionUpdate));
-    while (l) {
-        SPObject *child = SP_OBJECT (l->data);
-        l = g_slist_remove (l, child);
+    std::vector<SPObject*> l=this->childList(true, SPObject::ActionUpdate);
+    for(std::vector<SPObject*> ::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *child = *i;
 
         if (childflags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
             SPItem *item = dynamic_cast<SPItem *>(child);
@@ -201,20 +199,15 @@
 void SPGroup::modified(guint flags) {
     // std::cout << "SPGroup::modified(): " << (getId()?getId():"null") << std::endl;
     SPLPEItem::modified(flags);
-
-    SPObject *child;
-
     if (flags & SP_OBJECT_MODIFIED_FLAG) {
     	flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
     }
 
     flags &= SP_OBJECT_MODIFIED_CASCADE;
 
-    GSList *l = g_slist_reverse(this->childList(true));
-
-    while (l) {
-        child = SP_OBJECT (l->data);
-        l = g_slist_remove (l, child);
+    std::vector<SPObject*> l=this->childList(true);
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *child = *i;
 
         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
             child->emitModified(flags);
@@ -286,35 +279,27 @@
     Geom::OptRect bbox;
 
     // TODO CPPIFY: replace this const_cast later
-    GSList *l = const_cast<SPGroup*>(this)->childList(false, SPObject::ActionBBox);
-
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
-
+    std::vector<SPObject*> l = const_cast<SPGroup*>(this)->childList(false, SPObject::ActionBBox);
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *o = *i;
         SPItem *item = dynamic_cast<SPItem *>(o);
         if (item && !item->isHidden()) {
             Geom::Affine const ct(item->transform * transform);
             bbox |= item->bounds(bboxtype, ct);
         }
-
-        l = g_slist_remove (l, o);
     }
 
     return bbox;
 }
 
 void SPGroup::print(SPPrintContext *ctx) {
-    GSList *l = g_slist_reverse(this->childList(false));
-
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
-
+	std::vector<SPObject*> l=this->childList(false);
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *o = *i;
         SPItem *item = dynamic_cast<SPItem *>(o);
         if (item) {
             item->invoke_print(ctx);
         }
-
-        l = g_slist_remove (l, o);
     }
 }
 
@@ -362,17 +347,14 @@
 }
 
 void SPGroup::hide (unsigned int key) {
-    GSList *l = g_slist_reverse(this->childList(false, SPObject::ActionShow));
-
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
+	std::vector<SPObject*> l=this->childList(false, SPObject::ActionShow);
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *o = *i;
 
         SPItem *item = dynamic_cast<SPItem *>(o);
         if (item) {
             item->invoke_hide(key);
         }
-
-        l = g_slist_remove (l, o);
     }
 
 //    SPLPEItem::onHide(key);
@@ -407,7 +389,7 @@
 }
 
 void
-sp_item_group_ungroup (SPGroup *group, GSList **children, bool do_done)
+sp_item_group_ungroup (SPGroup *group, std::vector<SPItem*> &children, bool do_done)
 {
     g_return_if_fail (group != NULL);
 
@@ -564,8 +546,8 @@
         }
 
         Inkscape::GC::release(repr);
-        if (children && item) {
-            *children = g_slist_prepend(*children, item);
+        if (!children.empty() && item) {
+            children.insert(children.begin(),item);
         }
 
         items = g_slist_remove (items, items->data);
@@ -580,19 +562,17 @@
  * some API for list aspect of SPGroup
  */
 
-GSList *sp_item_group_item_list(SPGroup * group)
+std::vector<SPItem*> sp_item_group_item_list(SPGroup * group)
 {
-    g_return_val_if_fail(group != NULL, NULL);
-
-    GSList *s = NULL;
+    std::vector<SPItem*> s;
+    g_return_val_if_fail(group != NULL, s);
 
     for (SPObject *o = group->firstChild() ; o ; o = o->getNext() ) {
         if ( dynamic_cast<SPItem *>(o) ) {
-            s = g_slist_prepend(s, o);
+            s.push_back((SPItem*)o);
         }
     }
-
-    return g_slist_reverse (s);
+    return s;
 }
 
 SPObject *sp_item_group_get_child_by_name(SPGroup *group, SPObject *ref, const gchar *name)
@@ -807,9 +787,9 @@
 
 void SPGroup::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
     Inkscape::DrawingItem *ac = NULL;
-    GSList *l = g_slist_reverse(this->childList(false, SPObject::ActionShow));
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
+    std::vector<SPObject*> l=this->childList(false, SPObject::ActionShow);
+    for(std::vector<SPObject*>::const_iterator i=l.begin();i!=l.end();i++){
+        SPObject *o = *i;
         SPItem * child = dynamic_cast<SPItem *>(o);
         if (child) {
             ac = child->invoke_show (drawing, key, flags);
@@ -817,7 +797,6 @@
                 ai->appendChild(ac);
             }
         }
-        l = g_slist_remove (l, o);
     }
 }
 
@@ -826,10 +805,10 @@
     g_message("sp_group_update_patheffect: %p\n", lpeitem);
 #endif
 
-    GSList const *item_list = sp_item_group_item_list(this);
+    std::vector<SPItem*> const item_list = sp_item_group_item_list(this);
 
-    for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-        SPObject *subitem = static_cast<SPObject *>(iter->data);
+    for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+        SPObject *subitem = *iter;
 
         SPLPEItem *lpeItem = dynamic_cast<SPLPEItem *>(subitem);
         if (lpeItem) {
@@ -854,10 +833,10 @@
 static void
 sp_group_perform_patheffect(SPGroup *group, SPGroup *topgroup, bool write)
 {
-    GSList const *item_list = sp_item_group_item_list(group);
+    std::vector<SPItem*> const item_list = sp_item_group_item_list(group);
 
-    for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-        SPObject *subitem = static_cast<SPObject *>(iter->data);
+    for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+        SPObject *subitem = *iter;
 
         SPGroup *subGroup = dynamic_cast<SPGroup *>(subitem);
         if (subGroup) {

=== modified file 'src/sp-item-group.h'
--- src/sp-item-group.h	2015-02-21 16:23:30 +0000
+++ src/sp-item-group.h	2015-04-29 21:03:59 +0000
@@ -95,6 +95,7 @@
     virtual void update_patheffect(bool write);
 };
 
+
 /**
  * finds clones of a child of the group going out of the group; and inverse the group transform on its clones
  * Also called when moving objects between different layers
@@ -104,10 +105,11 @@
  */
 void sp_item_group_ungroup_handle_clones(SPItem *parent, Geom::Affine const g);
 
-void sp_item_group_ungroup (SPGroup *group, GSList **children, bool do_done = true);
-
-
-GSList *sp_item_group_item_list (SPGroup *group);
+void sp_item_group_ungroup (SPGroup *group, std::vector<SPItem*> &children, bool do_done = true);
+
+
+std::vector<SPItem*> sp_item_group_item_list (SPGroup *group);
+
 SPObject *sp_item_group_get_child_by_name (SPGroup *group, SPObject *ref, const char *name);
 
 #endif

=== modified file 'src/sp-lpe-item.cpp'
--- src/sp-lpe-item.cpp	2015-03-12 08:19:08 +0000
+++ src/sp-lpe-item.cpp	2015-04-29 21:03:59 +0000
@@ -353,9 +353,9 @@
         sp_lpe_item_create_original_path_recursive(SP_LPE_ITEM(clipPath->firstChild()));
     }
     if (SP_IS_GROUP(lpeitem)) {
-        GSList const *item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
-        for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-            SPObject *subitem = static_cast<SPObject *>(iter->data);
+    	std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
+        for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+            SPObject *subitem = *iter;
             if (SP_IS_LPE_ITEM(subitem)) {
                 sp_lpe_item_create_original_path_recursive(SP_LPE_ITEM(subitem));
             }
@@ -387,9 +387,9 @@
                 sp_lpe_item_cleanup_original_path_recursive(SP_LPE_ITEM(clipPath->firstChild()));
             }
         }
-        GSList const *item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
-        for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-            SPObject *subitem = static_cast<SPObject *>(iter->data);
+        std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
+        for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+            SPObject *subitem = *iter;
             if (SP_IS_LPE_ITEM(subitem)) {
                 sp_lpe_item_cleanup_original_path_recursive(SP_LPE_ITEM(subitem));
             }
@@ -680,9 +680,9 @@
         }
     }
     if(SP_IS_GROUP(item)){
-        GSList const *item_list = sp_item_group_item_list(SP_GROUP(item));
-        for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-            SPObject *subitem = static_cast<SPObject *>(iter->data);
+    	std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(item));
+        for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+            SPObject *subitem = *iter;
             apply_to_clippath(SP_ITEM(subitem));
         }
     }
@@ -732,9 +732,9 @@
         }
     }
     if(SP_IS_GROUP(item)){
-        GSList const *item_list = sp_item_group_item_list(SP_GROUP(item));
-        for ( GSList const *iter = item_list; iter; iter = iter->next ) {
-            SPObject *subitem = static_cast<SPObject *>(iter->data);
+    	std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(item));
+        for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+            SPObject *subitem = *iter;
             apply_to_mask(SP_ITEM(subitem));
         }
     }
@@ -746,9 +746,9 @@
     if (!SP_IS_GROUP(group)) {
         return;
     }
-    GSList *item_list = sp_item_group_item_list(SP_GROUP(group));
-    for ( GSList *iter = item_list; iter; iter = iter->next ) {
-        SPObject *subitem = static_cast<SPObject *>(iter->data);
+    std::vector<SPItem*> item_list = sp_item_group_item_list(SP_GROUP(group));
+    for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+        SPObject *subitem = *iter;
         if (SP_IS_GROUP(subitem)) {
             apply_to_clip_or_mask_group(SP_ITEM(subitem), item);
         } else if (SP_IS_SHAPE(subitem)) {

=== modified file 'src/sp-marker.cpp'
--- src/sp-marker.cpp	2015-02-25 00:22:08 +0000
+++ src/sp-marker.cpp	2015-04-29 21:03:59 +0000
@@ -419,7 +419,7 @@
 }
 
 
-const gchar *generate_marker(GSList *reprs, Geom::Rect bounds, SPDocument *document, Geom::Point center, Geom::Affine move)
+const gchar *generate_marker(std::vector<Inkscape::XML::Node*> &reprs, Geom::Rect bounds, SPDocument *document, Geom::Point center, Geom::Affine move)
 {
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     Inkscape::XML::Node *defsrepr = document->getDefs()->getRepr();
@@ -442,8 +442,8 @@
     const gchar *mark_id = repr->attribute("id");
     SPObject *mark_object = document->getObjectById(mark_id);
 
-    for (GSList *i = reprs; i != NULL; i = i->next) {
-        Inkscape::XML::Node *node = (Inkscape::XML::Node *)(i->data);
+    for (std::vector<Inkscape::XML::Node*>::const_iterator i=reprs.begin();i!=reprs.end();i++){
+        Inkscape::XML::Node *node = *i;
         SPItem *copy = SP_ITEM(mark_object->appendChildRepr(node));
 
         Geom::Affine dup_transform;

=== modified file 'src/sp-marker.h'
--- src/sp-marker.h	2014-12-21 14:29:02 +0000
+++ src/sp-marker.h	2015-04-29 21:03:59 +0000
@@ -101,7 +101,7 @@
 				      unsigned int key, unsigned int pos,
 				      Geom::Affine const &base, float linewidth);
 void sp_marker_hide (SPMarker *marker, unsigned int key);
-const char *generate_marker (GSList *reprs, Geom::Rect bounds, SPDocument *document, Geom::Point center, Geom::Affine move);
+const char *generate_marker (std::vector<Inkscape::XML::Node*> &reprs, Geom::Rect bounds, SPDocument *document, Geom::Point center, Geom::Affine move);
 SPObject *sp_marker_fork_if_necessary(SPObject *marker);
 
 #endif

=== modified file 'src/sp-object.cpp'
--- src/sp-object.cpp	2015-02-25 00:22:08 +0000
+++ src/sp-object.cpp	2015-04-29 21:03:59 +0000
@@ -380,14 +380,14 @@
     sp_repr_css_change(this->getRepr(), css, attr);
 }
 
-GSList *SPObject::childList(bool add_ref, Action) {
-    GSList *l = NULL;
+std::vector<SPObject*> SPObject::childList(bool add_ref, Action) {
+	 std::vector<SPObject*> l;
     for ( SPObject *child = firstChild() ; child; child = child->getNext() ) {
         if (add_ref) {
             sp_object_ref (child);
         }
 
-        l = g_slist_prepend (l, child);
+        l.push_back(child);
     }
     return l;
 

=== modified file 'src/sp-object.h'
--- src/sp-object.h	2015-02-21 16:23:30 +0000
+++ src/sp-object.h	2015-04-29 21:03:59 +0000
@@ -52,6 +52,7 @@
 #include <sigc++/connection.h>
 #include <sigc++/functors/slot.h>
 #include <sigc++/signal.h>
+#include <vector>
 
 #include "version.h"
 #include "util/forward-pointer-iterator.h"
@@ -328,10 +329,10 @@
     enum Action { ActionGeneral, ActionBBox, ActionUpdate, ActionShow };
 
     /**
-     * Retrieves the children as a GSList object, optionally ref'ing the children
+     * Retrieves the children as a std vector object, optionally ref'ing the children
      * in the process, if add_ref is specified.
      */
-    GSList *childList(bool add_ref, Action action = ActionGeneral);
+    std::vector<SPObject*> childList(bool add_ref, Action action = ActionGeneral);
 
     /**
      * Append repr as child of this object.

=== modified file 'src/sp-pattern.cpp'
--- src/sp-pattern.cpp	2015-02-25 00:22:08 +0000
+++ src/sp-pattern.cpp	2015-04-29 21:03:59 +0000
@@ -398,7 +398,7 @@
     g_free(c);
 }
 
-const gchar *pattern_tile(GSList *reprs, Geom::Rect bounds, SPDocument *document, Geom::Affine transform, Geom::Affine move)
+const gchar *pattern_tile(const std::vector<Inkscape::XML::Node*> &reprs, Geom::Rect bounds, SPDocument *document, Geom::Affine transform, Geom::Affine move)
 {
     Inkscape::XML::Document *xml_doc = document->getReprDoc();
     Inkscape::XML::Node *defsrepr = document->getDefs()->getRepr();
@@ -416,8 +416,8 @@
     const gchar *pat_id = repr->attribute("id");
     SPObject *pat_object = document->getObjectById(pat_id);
 
-    for (GSList *i = reprs; i != NULL; i = i->next) {
-            Inkscape::XML::Node *node = (Inkscape::XML::Node *)(i->data);
+    for (std::vector<Inkscape::XML::Node*>::const_iterator i=reprs.begin();i!=reprs.end();i++){
+        Inkscape::XML::Node *node = *i;
         SPItem *copy = SP_ITEM(pat_object->appendChildRepr(node));
 
         Geom::Affine dup_transform;

=== modified file 'src/sp-pattern.h'
--- src/sp-pattern.h	2014-10-08 02:22:03 +0000
+++ src/sp-pattern.h	2015-04-29 21:03:59 +0000
@@ -89,7 +89,7 @@
 SPPattern *sp_pattern_clone_if_necessary (SPItem *item, SPPattern *pattern, const char *property);
 void sp_pattern_transform_multiply (SPPattern *pattern, Geom::Affine postmul, bool set);
 
-const char *pattern_tile (GSList *reprs, Geom::Rect bounds, SPDocument *document, Geom::Affine transform, Geom::Affine move);
+const char *pattern_tile (const std::vector<Inkscape::XML::Node*> &reprs, Geom::Rect bounds, SPDocument *document, Geom::Affine transform, Geom::Affine move);
 
 SPPattern *pattern_getroot (SPPattern *pat);
 

=== modified file 'src/sp-switch.cpp'
--- src/sp-switch.cpp	2015-02-25 00:22:08 +0000
+++ src/sp-switch.cpp	2015-04-29 21:03:59 +0000
@@ -41,21 +41,22 @@
     return first;
 }
 
-GSList *SPSwitch::_childList(bool add_ref, SPObject::Action action) {
+std::vector<SPObject*> SPSwitch::_childList(bool add_ref, SPObject::Action action) {
     if ( action != SPObject::ActionGeneral ) {
         return this->childList(add_ref, action);
     }
 
     SPObject *child = _evaluateFirst();
+    std::vector<SPObject*> x;
     if (NULL == child)
-        return NULL;
+        return x;
 
     if (add_ref) {
         //g_object_ref (G_OBJECT (child));
     	sp_object_ref(child);
     }
-
-    return g_slist_prepend (NULL, child);
+    x.push_back(child);
+    return x;
 }
 
 const char *SPSwitch::displayName() const {
@@ -95,10 +96,9 @@
 
     _releaseLastItem(_cached_item);
 
-    for ( GSList *l = _childList(false, SPObject::ActionShow);
-            NULL != l ; l = g_slist_remove (l, l->data))
-    {
-        SPObject *o = SP_OBJECT (l->data);
+    std::vector<SPObject*> item_list = _childList(false, SPObject::ActionShow);
+    for ( std::vector<SPObject*>::const_reverse_iterator iter=item_list.rbegin();iter!=item_list.rend();iter++) {
+        SPObject *o = *iter;
         if ( !SP_IS_ITEM (o) ) {
             continue;
         }
@@ -130,10 +130,10 @@
 void SPSwitch::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
     SPObject *evaluated_child = this->_evaluateFirst();
 
-    GSList *l = this->_childList(false, SPObject::ActionShow);
+    std::vector<SPObject*> l = this->_childList(false, SPObject::ActionShow);