Merge lp:~mc.../inkscape/mc-selection-transform into lp:~inkscape.dev/inkscape/trunk

[Mc]

Refactoring of sp_selection_apply_affine, taking care of the case when we select an original and a clone which is present in a selected group (and not directly selected)

[Mc (mc...)]

NB: The diff is huge because i made a clang-format to have all the presentation right, the only non-whitespace parts are lines 1297-1651 and 3728+

[Jabiertxof (jabiertxof)]

I put three minor things about coding style previouly someone review me. AlsoNathan ping me about dont "clangformat" merges, till become accepted. Anyway I read your comment and help me a lot in the review. I do not a usage review, ping me if you want me to compile to give a second try.

review: Approve (code)

Unmerged revisions

14347. By Mc on 2015-09-02

more clang-format because i can never get the spacing right

14346. By Mc on 2015-09-02

final comments and refactor

14345. By Mc on 2015-09-02

refactor + fixed linked offsets

14344. By Mc on 2015-09-02

I was not /that/ far yesterday at 4am. Ready to be tested !

14343. By Mc on 2015-09-02

works better than previously, but there is still some strange behavior

14342. By Mc on 2015-09-02

Wait a minute, is that really working ? Have those several hours with paper and pen, filling pages with matrix multiplications, not been in vain ?

Just kidding, still WIP. make a clone of clone, move the original and first clone, the second moves unexpectedly.

But still, the fact that the first clone behaves right is already pretty cool !

14341. By Mc on 2015-09-01

I'm so confused right now.

14340. By Mc on 2015-09-01

does not break anything yet. I still have to fix the case where i resize a (original+(clone in a group)) selection

14339. By Mc on 2015-09-01

clang-format src/selection-chemistry.cpp

14338. By Mc on 2015-09-01

add includes_deeply helper function to test if an object is selected, even indirectly

=== modified file 'src/selection-chemistry.cpp'
--- src/selection-chemistry.cpp	2015-05-26 20:27:00 +0000
+++ src/selection-chemistry.cpp	2015-09-02 11:21:15 +0000
@@ -12,15 +12,16 @@
  *   Abhishek Sharma
  *   Kris De Gussem <[e-mail]>
  *   Tavmjong Bah <[e-mail]> (Symbol additions)
+ *   Marc Jeanmougin <[e-mail]>
  *
- * Copyright (C) 1999-2010,2012 authors
+ * Copyright (C) 1999-2010,2012,2015 authors
  * Copyright (C) 2001-2002 Ximian, Inc.
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
 #ifdef HAVE_CONFIG_H
-# include "config.h"
+#include "config.h"
 #endif
 
 #include <gtkmm/clipboard.h>
@@ -131,14 +132,12 @@
 
 // helper for printing error messages, regardless of whether we have a GUI or not
 // If desktop == NULL, errors will be shown on stderr
-static void
-selection_display_message(SPDesktop *desktop, Inkscape::MessageType msgType, Glib::ustring const &msg)
+static void selection_display_message(SPDesktop *desktop, Inkscape::MessageType msgType, Glib::ustring const &msg)
 {
     if (desktop) {
         desktop->messageStack()->flash(msgType, msg);
     } else {
-        if (msgType == Inkscape::IMMEDIATE_MESSAGE ||
-            msgType == Inkscape::WARNING_MESSAGE ||
+        if (msgType == Inkscape::IMMEDIATE_MESSAGE || msgType == Inkscape::WARNING_MESSAGE ||
             msgType == Inkscape::ERROR_MESSAGE) {
             g_printerr("%s\n", msg.c_str());
         }
@@ -150,7 +149,7 @@
 void SelectionHelper::selectAll(SPDesktop *dt)
 {
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         if (!nt->_multipath->empty()) {
             nt->_multipath->selectSubpaths();
             return;
@@ -162,7 +161,7 @@
 void SelectionHelper::selectAllInAll(SPDesktop *dt)
 {
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         nt->_selected_nodes->selectAll();
     } else {
         sp_edit_select_all_in_all_layers(dt);
@@ -173,7 +172,7 @@
 {
     NodeTool *nt = NULL;
     if (tools_isactive(dt, TOOLS_NODES)) {
-        nt = static_cast<NodeTool*>(dt->event_context);
+        nt = static_cast<NodeTool *>(dt->event_context);
     }
 
     if (nt && !nt->_selected_nodes->empty()) {
@@ -186,35 +185,20 @@
     }
 }
 
-void SelectionHelper::selectSameFillStroke(SPDesktop *dt)
-{
-    sp_select_same_fill_stroke_style(dt, true, true, true);
-}
-
-void SelectionHelper::selectSameFillColor(SPDesktop *dt)
-{
-    sp_select_same_fill_stroke_style(dt, true, false, false);
-}
-
-void SelectionHelper::selectSameStrokeColor(SPDesktop *dt)
-{
-    sp_select_same_fill_stroke_style(dt, false, true, false);
-}
-
-void SelectionHelper::selectSameStrokeStyle(SPDesktop *dt)
-{
-    sp_select_same_fill_stroke_style(dt, false, false, true);
-}
-
-void SelectionHelper::selectSameObjectType(SPDesktop *dt)
-{
-    sp_select_same_object_type(dt);
-}
+void SelectionHelper::selectSameFillStroke(SPDesktop *dt) { sp_select_same_fill_stroke_style(dt, true, true, true); }
+
+void SelectionHelper::selectSameFillColor(SPDesktop *dt) { sp_select_same_fill_stroke_style(dt, true, false, false); }
+
+void SelectionHelper::selectSameStrokeColor(SPDesktop *dt) { sp_select_same_fill_stroke_style(dt, false, true, false); }
+
+void SelectionHelper::selectSameStrokeStyle(SPDesktop *dt) { sp_select_same_fill_stroke_style(dt, false, false, true); }
+
+void SelectionHelper::selectSameObjectType(SPDesktop *dt) { sp_select_same_object_type(dt); }
 
 void SelectionHelper::invert(SPDesktop *dt)
 {
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         nt->_multipath->invertSelectionInSubpaths();
     } else {
         sp_edit_invert(dt);
@@ -224,7 +208,7 @@
 void SelectionHelper::invertAllInAll(SPDesktop *dt)
 {
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         nt->_selected_nodes->invertSelection();
     } else {
         sp_edit_invert_in_all_layers(dt);
@@ -235,7 +219,7 @@
 {
     // TODO make this a virtual method of event context!
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         nt->_multipath->reverseSubpaths();
     } else {
         sp_selected_path_reverse(dt);
@@ -246,10 +230,9 @@
 {
     Inkscape::UI::Tools::ToolBase *ec = dt->event_context;
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         nt->_multipath->shiftSelection(1);
-    } else if (tools_isactive(dt, TOOLS_GRADIENT)
-               && ec->_grdrag->isNonEmpty()) {
+    } else if (tools_isactive(dt, TOOLS_GRADIENT) && ec->_grdrag->isNonEmpty()) {
         Inkscape::UI::Tools::sp_gradient_context_select_next(ec);
     } else {
         sp_selection_item_next(dt);
@@ -260,10 +243,9 @@
 {
     Inkscape::UI::Tools::ToolBase *ec = dt->event_context;
     if (tools_isactive(dt, TOOLS_NODES)) {
-        NodeTool *nt = static_cast<NodeTool*>(dt->event_context);
+        NodeTool *nt = static_cast<NodeTool *>(dt->event_context);
         nt->_multipath->shiftSelection(-1);
-    } else if (tools_isactive(dt, TOOLS_GRADIENT)
-               && ec->_grdrag->isNonEmpty()) {
+    } else if (tools_isactive(dt, TOOLS_GRADIENT) && ec->_grdrag->isNonEmpty()) {
         Inkscape::UI::Tools::sp_gradient_context_select_prev(ec);
     } else {
         sp_selection_item_prev(dt);
@@ -273,23 +255,20 @@
 /*
  * Fixes the current selection, removing locked objects from it
  */
-void SelectionHelper::fixSelection(SPDesktop *dt) 
+void SelectionHelper::fixSelection(SPDesktop *dt)
 {
-    if(!dt)
+    if (!dt)
         return;
 
     Inkscape::Selection *selection = dt->getSelection();
-    
-    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++ ) {
+
+    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()))
-        {
+        if (item && !dt->isLayer(item) && (!item->isLocked())) {
             items.push_back(item);
         }
     }
@@ -304,7 +283,8 @@
  * 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, std::vector<Inkscape::XML::Node*> &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);
 
@@ -316,21 +296,22 @@
     // write the complete accumulated transform passed to us
     // (we're dealing with unattached repr, so we write to its attr
     // instead of using sp_item_set_transform)
-    gchar *affinestr=sp_svg_transform_write(full_t);
+    gchar *affinestr = sp_svg_transform_write(full_t);
     copy->setAttribute("transform", affinestr);
     g_free(affinestr);
 
-    clip.insert(clip.begin(),copy);
+    clip.insert(clip.begin(), copy);
 }
 
-static void sp_selection_copy_impl(std::vector<SPItem*> const &items, std::vector<Inkscape::XML::Node*> &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:
-    std::vector<SPItem*> sorted_items(items);
-    sort(sorted_items.begin(),sorted_items.end(),sp_object_compare_position_bool);
+    std::vector<SPItem *> sorted_items(items);
+    sort(sorted_items.begin(), sorted_items.end(), sp_object_compare_position_bool);
 
     // Copy item reprs:
-    for (std::vector<SPItem*>::const_iterator i = sorted_items.begin(); i != sorted_items.end(); i++) {
+    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);
@@ -338,20 +319,21 @@
             g_assert_not_reached();
         }
     }
-    reverse(clip.begin(),clip.end());
+    reverse(clip.begin(), clip.end());
 }
 
 // TODO check if parent parameter should be changed to SPItem, of if the code should handle non-items.
-static std::vector<Inkscape::XML::Node*> sp_selection_paste_impl(SPDocument *doc, SPObject *parent, std::vector<Inkscape::XML::Node*> &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);
 
-    std::vector<Inkscape::XML::Node*> copied;
+    std::vector<Inkscape::XML::Node *> copied;
     // add objects to document
-    for (std::vector<Inkscape::XML::Node*>::const_iterator l = clip.begin(); l != clip.end(); l++) {
+    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);
 
@@ -364,7 +346,7 @@
                 sp_svg_transform_read(t_str, &item_t);
             item_t *= local.inverse();
             // (we're dealing with unattached repr, so we write to its attr instead of using sp_item_set_transform)
-            gchar *affinestr=sp_svg_transform_write(item_t);
+            gchar *affinestr = sp_svg_transform_write(item_t);
             copy->setAttribute("transform", affinestr);
             g_free(affinestr);
         }
@@ -376,12 +358,13 @@
     return copied;
 }
 
-static void sp_selection_delete_impl(std::vector<SPItem*> 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 (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++) {
+    for (std::vector<SPItem *>::const_iterator i = items.begin(); i != items.end(); i++) {
         sp_object_ref(*i, NULL);
     }
-    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++) {
+    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);
@@ -397,8 +380,7 @@
 
     if (tools_isactive(desktop, TOOLS_TEXT))
         if (Inkscape::UI::Tools::sp_text_delete_selection(desktop->event_context)) {
-            DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT,
-                               _("Delete text"));
+            DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, _("Delete text"));
             return;
         }
 
@@ -409,7 +391,7 @@
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("<b>Nothing</b> was deleted."));
         return;
     }
-    std::vector<SPItem*> selected(selection->itemList());
+    std::vector<SPItem *> selected(selection->itemList());
     selection->clear();
     sp_selection_delete_impl(selected);
     desktop->currentLayer()->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
@@ -420,10 +402,9 @@
      * associated selection context.  For example: deleting an object
      * while moving it around the canvas.
      */
-    tools_switch( desktop, tools_active( desktop ) );
+    tools_switch(desktop, tools_active(desktop));
 
-    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_DELETE,
-                       _("Delete"));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_DELETE, _("Delete"));
 }
 
 static void add_ids_recursive(std::vector<const gchar *> &ids, SPObject *obj)
@@ -432,7 +413,7 @@
         ids.push_back(obj->getId());
 
         if (dynamic_cast<SPGroup *>(obj)) {
-            for (SPObject *child = obj->firstChild() ; child; child = child->getNext() ) {
+            for (SPObject *child = obj->firstChild(); child; child = child->getNext()) {
                 add_ids_recursive(ids, child);
             }
         }
@@ -446,7 +427,7 @@
     }
 
     SPDocument *doc = desktop->doc();
-    Inkscape::XML::Document* xml_doc = doc->getReprDoc();
+    Inkscape::XML::Document *xml_doc = doc->getReprDoc();
     Inkscape::Selection *selection = desktop->getSelection();
 
     // check if something is selected
@@ -454,9 +435,9 @@
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to duplicate."));
         return;
     }
-    std::vector<Inkscape::XML::Node*> reprs(selection->reprList());
+    std::vector<Inkscape::XML::Node *> reprs(selection->reprList());
 
-    if(duplicateLayer){
+    if (duplicateLayer) {
         reprs.clear();
         reprs.push_back(desktop->currentLayer()->getRepr());
     }
@@ -465,9 +446,9 @@
 
     // sorting items from different parents sorts each parent's subset without possibly mixing
     // them, just what we need
-    sort(reprs.begin(),reprs.end(),sp_repr_compare_position_bool);
+    sort(reprs.begin(), reprs.end(), sp_repr_compare_position_bool);
 
-    std::vector<Inkscape::XML::Node*> newsel;
+    std::vector<Inkscape::XML::Node *> newsel;
 
     std::vector<const gchar *> old_ids;
     std::vector<const gchar *> new_ids;
@@ -475,15 +456,15 @@
     bool relink_clones = prefs->getBool("/options/relinkclonesonduplicate/value");
     const bool fork_livepatheffects = prefs->getBool("/options/forklpeonduplicate/value", true);
 
-    for(std::vector<Inkscape::XML::Node*>::const_iterator i=reprs.begin();i!=reprs.end();i++){
+    for (std::vector<Inkscape::XML::Node *>::const_iterator i = reprs.begin(); i != reprs.end(); i++) {
         Inkscape::XML::Node *old_repr = *i;
         Inkscape::XML::Node *parent = old_repr->parent();
         Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);
 
-        if(! duplicateLayer)
+        if (!duplicateLayer)
             parent->appendChild(copy);
         else
-        	parent->addChild(copy, old_repr);
+            parent->addChild(copy, old_repr);
 
         if (relink_clones) {
             SPObject *old_obj = doc->getObjectByRepr(old_repr);
@@ -519,7 +500,8 @@
                 for (unsigned int j = 0; j < old_ids.size(); j++) {
                     if (!strcmp(orig->getId(), old_ids[j])) {
                         // we have both orig and clone in selection, relink
-                        // std::cout << id  << " old, its ori: " << orig->getId() << "; will relink:" << new_ids[i] << " to " << new_ids[j] << "\n";
+                        // std::cout << id  << " old, its ori: " << orig->getId() << "; will relink:" << new_ids[i] << "
+                        // to " << new_ids[j] << "\n";
                         SPObject *new_clone = doc->getObjectById(new_ids[i]);
                         new_clone->getRepr()->setAttribute("xlink:href", Glib::ustring("#") + new_ids[j]);
                         new_clone->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
@@ -530,8 +512,9 @@
                 if (offset) {
                     for (guint j = 0; j < old_ids.size(); j++) {
                         gchar *source_href = offset->sourceHref;
-                        if (source_href && source_href[0]=='#' && !strcmp(source_href+1, old_ids[j])) {
-                            doc->getObjectById(new_ids[i])->getRepr()->setAttribute("xlink:href", Glib::ustring("#") + new_ids[j]);
+                        if (source_href && source_href[0] == '#' && !strcmp(source_href + 1, old_ids[j])) {
+                            doc->getObjectById(new_ids[i])->getRepr()->setAttribute("xlink:href",
+                                                                                    Glib::ustring("#") + new_ids[j]);
                         }
                     }
                 }
@@ -540,16 +523,15 @@
     }
 
 
-    if ( !suppressDone ) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_DUPLICATE,
-                           _("Duplicate"));
+    if (!suppressDone) {
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_DUPLICATE, _("Duplicate"));
     }
-    if(!duplicateLayer)
+    if (!duplicateLayer)
         selection->setReprList(newsel);
-    else{
-    	SPObject* new_layer = doc->getObjectByRepr(newsel[0]);
-        gchar* name = g_strdup_printf(_("%s copy"), new_layer->label());
-        desktop->layer_manager->renameLayer( new_layer, name, TRUE );
+    else {
+        SPObject *new_layer = doc->getObjectByRepr(newsel[0]);
+        gchar *name = g_strdup_printf(_("%s copy"), new_layer->label());
+        desktop->layer_manager->renameLayer(new_layer, name, TRUE);
         g_free(name);
     }
 }
@@ -564,14 +546,13 @@
 
     SPGroup *group = dynamic_cast<SPGroup *>(selection->layers()->currentLayer());
     g_return_if_fail(group != NULL);
-    std::vector<SPItem*> items = sp_item_group_item_list(group);
+    std::vector<SPItem *> items = sp_item_group_item_list(group);
 
-    for(unsigned int i = 0; i < items.size(); i++){
+    for (unsigned int i = 0; i < items.size(); i++) {
         items[i]->deleteObject();
     }
 
-    DocumentUndo::done(doc, SP_VERB_EDIT_CLEAR_ALL,
-                       _("Delete all"));
+    DocumentUndo::done(doc, SP_VERB_EDIT_CLEAR_ALL, _("Delete all"));
 }
 
 /*
@@ -584,18 +565,15 @@
  * onlysensitive - TRUE includes only non-locked items
  * ingroups - TRUE to recursively get grouped items children
  */
-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)
+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() ) {
+    for (SPObject *child = from->firstChild(); child; child = child->getNext()) {
         SPItem *item = dynamic_cast<SPItem *>(child);
-        if (item &&
-            !desktop->isLayer(item) &&
-            (!onlysensitive || !item->isLocked()) &&
+        if (item && !desktop->isLayer(item) && (!onlysensitive || !item->isLocked()) &&
             (!onlyvisible || !desktop->itemIsHidden(item)) &&
-            (exclude.empty() || exclude.end() == std::find(exclude.begin(),exclude.end(),child))
-            )
-        {
-            list.insert(list.begin(),item);
+            (exclude.empty() || exclude.end() == std::find(exclude.begin(), exclude.end(), child))) {
+            list.insert(list.begin(), item);
         }
 
         if (ingroups || (item && desktop->isLayer(item))) {
@@ -616,13 +594,14 @@
     g_return_if_fail(dynamic_cast<SPGroup *>(dt->currentLayer()));
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    PrefsSelectionContext inlayer = (PrefsSelectionContext) prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);
+    PrefsSelectionContext inlayer =
+        (PrefsSelectionContext)prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
 
-    std::vector<SPItem*> items ;
+    std::vector<SPItem *> items;
 
-    std::vector<SPItem*> exclude;
+    std::vector<SPItem *> exclude;
     if (invert) {
         exclude = selection->itemList();
     }
@@ -632,73 +611,62 @@
 
     switch (inlayer) {
         case PREFS_SELECTION_LAYER: {
-        if ( (onlysensitive && dynamic_cast<SPItem *>(dt->currentLayer())->isLocked()) ||
-             (onlyvisible && dt->itemIsHidden(dynamic_cast<SPItem *>(dt->currentLayer()))) )
-        return;
-
-        std::vector<SPItem*> all_items = sp_item_group_item_list(dynamic_cast<SPGroup *>(dt->currentLayer()));
-
-        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 || exclude.end() == std::find(exclude.begin(),exclude.end(),item)) {
-                            items.push_back(item); // leave it in the list
+            if ((onlysensitive && dynamic_cast<SPItem *>(dt->currentLayer())->isLocked()) ||
+                (onlyvisible && dt->itemIsHidden(dynamic_cast<SPItem *>(dt->currentLayer()))))
+                return;
+
+            std::vector<SPItem *> all_items = sp_item_group_item_list(dynamic_cast<SPGroup *>(dt->currentLayer()));
+
+            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 || exclude.end() == std::find(exclude.begin(), exclude.end(), item)) {
+                                items.push_back(item); // leave it in the list
+                            }
                         }
                     }
                 }
             }
-        }
 
             break;
         }
         case PREFS_SELECTION_LAYER_RECURSIVE: {
-        	std::vector<SPItem*> x;
+            std::vector<SPItem *> x;
             items = get_all_items(x, dt->currentLayer(), dt, onlyvisible, onlysensitive, FALSE, exclude);
             break;
         }
         default: {
-            std::vector<SPItem*> x;
+            std::vector<SPItem *> x;
             items = get_all_items(x, dt->currentRoot(), dt, onlyvisible, onlysensitive, FALSE, exclude);
             break;
-    }
+        }
     }
 
     selection->setList(items);
-
-}
-
-void sp_edit_select_all(SPDesktop *desktop)
-{
-    sp_edit_select_all_full(desktop, false, false);
-}
-
-void sp_edit_select_all_in_all_layers(SPDesktop *desktop)
-{
-    sp_edit_select_all_full(desktop, true, false);
-}
-
-void sp_edit_invert(SPDesktop *desktop)
-{
-    sp_edit_select_all_full(desktop, false, true);
-}
-
-void sp_edit_invert_in_all_layers(SPDesktop *desktop)
-{
-    sp_edit_select_all_full(desktop, true, true);
-}
-
-static void sp_selection_group_impl(std::vector<Inkscape::XML::Node*> p, Inkscape::XML::Node *group, Inkscape::XML::Document *xml_doc, SPDocument *doc) {
-
-    sort(p.begin(),p.end(),sp_repr_compare_position_bool);
+}
+
+void sp_edit_select_all(SPDesktop *desktop) { sp_edit_select_all_full(desktop, false, false); }
+
+void sp_edit_select_all_in_all_layers(SPDesktop *desktop) { sp_edit_select_all_full(desktop, true, false); }
+
+void sp_edit_invert(SPDesktop *desktop) { sp_edit_select_all_full(desktop, false, true); }
+
+void sp_edit_invert_in_all_layers(SPDesktop *desktop) { sp_edit_select_all_full(desktop, true, true); }
+
+static void sp_selection_group_impl(std::vector<Inkscape::XML::Node *> p, Inkscape::XML::Node *group,
+                                    Inkscape::XML::Document *xml_doc, SPDocument *doc)
+{
+
+    sort(p.begin(), p.end(), sp_repr_compare_position_bool);
 
     // Remember the position and parent of the topmost object.
     gint topmost = p.back()->position();
     Inkscape::XML::Node *topmost_parent = p.back()->parent();
 
-    for(std::vector<Inkscape::XML::Node*>::const_iterator i = p.begin(); i != p.end(); i++){
+    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) {
@@ -706,12 +674,14 @@
             sp_repr_unparent(current);
             group->appendChild(spnew);
             Inkscape::GC::release(spnew);
-            topmost --; // only reduce count for those items deleted from topmost_parent
-        } else { // move it to topmost_parent first
-            std::vector<Inkscape::XML::Node*> temp_clip;
+            topmost--; // only reduce count for those items deleted from topmost_parent
+        } else {       // move it to topmost_parent first
+            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
+            // 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
             gchar const *t_str = current->attribute("transform");
             Geom::Affine item_t(Geom::identity());
             if (t_str)
@@ -728,8 +698,10 @@
             sp_repr_unparent(current);
 
             // paste into topmost_parent (temporarily)
-            std::vector<Inkscape::XML::Node*> copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), temp_clip);
-            if (!temp_clip.empty())temp_clip.clear() ;
+            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 = copied.back();
@@ -763,7 +735,7 @@
         return;
     }
 
-    std::vector<Inkscape::XML::Node*> p (selection->reprList());
+    std::vector<Inkscape::XML::Node *> p(selection->reprList());
 
     selection->clear();
 
@@ -771,14 +743,14 @@
 
     sp_selection_group_impl(p, group, xml_doc, doc);
 
-    DocumentUndo::done(doc, SP_VERB_SELECTION_GROUP,
-                       C_("Verb", "Group"));
+    DocumentUndo::done(doc, SP_VERB_SELECTION_GROUP, C_("Verb", "Group"));
 
     selection->set(group);
     Inkscape::GC::release(group);
 }
 
-static gint clone_depth_descending(gconstpointer a, gconstpointer b) {
+static gint clone_depth_descending(gconstpointer a, gconstpointer b)
+{
     SPUse *use_a = static_cast<SPUse *>(const_cast<gpointer>(a));
     SPUse *use_b = static_cast<SPUse *>(const_cast<gpointer>(b));
     int depth_a = use_a->cloneDepth();
@@ -799,10 +771,10 @@
     }
 
     // first check whether there is anything to ungroup
-    std::vector<SPItem*> old_select = selection->itemList();
-    std::vector<SPItem*> new_select;
+    std::vector<SPItem *> old_select = selection->itemList();
+    std::vector<SPItem *> new_select;
     GSList *groups = NULL;
-    for (std::vector<SPItem*>::const_iterator item = old_select.begin(); item!=old_select.end(); item++) {
+    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);
@@ -815,13 +787,13 @@
         return;
     }
 
-    std::vector<SPItem*> items(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 (std::vector<SPItem*>::const_iterator item = items.begin(); item != items.end(); item++) {
+    for (std::vector<SPItem *>::const_iterator item = items.begin(); item != items.end(); item++) {
         SPUse *use = dynamic_cast<SPUse *>(*item);
 
         SPItem *original = use;
@@ -841,21 +813,21 @@
 
     for (GSList *item = clones_to_unlink; item; item = item->next) {
         SPUse *use = static_cast<SPUse *>(item->data);
-        std::vector<SPItem*>::iterator items_node = std::find(items.begin(),items.end(), item->data);
+        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 (std::vector<SPItem*>::iterator item = items.begin(); item != items.end(); item++) {
+    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) != NULL) {
-        	std::vector<SPItem*> children;
+            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.insert(new_select.end(),children.begin(),children.end());
+            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
@@ -865,24 +837,22 @@
 
     selection->addList(new_select);
 
-    DocumentUndo::done(selection->layers()->getDocument(), SP_VERB_SELECTION_UNGROUP,
-                       _("Ungroup"));
+    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 */
-std::vector<SPItem*>
-sp_degroup_list(std::vector<SPItem*> &items)
+std::vector<SPItem *> sp_degroup_list(std::vector<SPItem *> &items)
 {
-	std::vector<SPItem*> out;
+    std::vector<SPItem *> out;
     bool has_groups = false;
-    for (std::vector<SPItem*>::const_iterator item=items.begin();item!=items.end();item++) {
+    for (std::vector<SPItem *>::const_iterator item = items.begin(); item != items.end(); item++) {
         SPGroup *group = dynamic_cast<SPGroup *>(*item);
         if (!group) {
             out.push_back(*item);
         } else {
             has_groups = true;
-            std::vector<SPItem*> members = sp_item_group_item_list(group);
-            for (std::vector<SPItem*>::const_iterator member=members.begin();member!=members.end();member++) {
+            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);
             }
             members.clear();
@@ -898,8 +868,7 @@
 
 
 /** If items in the list have a common parent, return it, otherwise return NULL */
-static SPGroup *
-sp_item_list_common_parent_group(std::vector<SPItem*> const items)
+static SPGroup *sp_item_list_common_parent_group(std::vector<SPItem *> const items)
 {
     if (items.empty()) {
         return NULL;
@@ -909,8 +878,9 @@
     if (!dynamic_cast<SPGroup *>(parent)) {
         return NULL;
     }
-    for (std::vector<SPItem*>::const_iterator item=items.begin();item!=items.end();item++) {
-    	if((*item)==items[0])continue;
+    for (std::vector<SPItem *>::const_iterator item = items.begin(); item != items.end(); item++) {
+        if ((*item) == items[0])
+            continue;
         if ((*item)->parent != parent) {
             return NULL;
         }
@@ -920,13 +890,12 @@
 }
 
 /** Finds out the minimum common bbox of the selected items. */
-static Geom::OptRect
-enclose_items(std::vector<SPItem*> const &items)
+static Geom::OptRect enclose_items(std::vector<SPItem *> const &items)
 {
     g_assert(!items.empty());
 
     Geom::OptRect r;
-    for (std::vector<SPItem*>::const_iterator i = items.begin();i!=items.end();i++) {
+    for (std::vector<SPItem *>::const_iterator i = items.begin(); i != items.end(); i++) {
         r.unionWith((*i)->desktopVisualBounds());
     }
     return r;
@@ -936,7 +905,7 @@
 static SPObject *prev_sibling(SPObject *child)
 {
     SPObject *prev = 0;
-    if ( child && dynamic_cast<SPGroup *>(child->parent) ) {
+    if (child && dynamic_cast<SPGroup *>(child->parent)) {
         prev = child->getPrev();
     }
     return prev;
@@ -944,14 +913,12 @@
 
 bool sp_item_repr_compare_position_bool(SPObject const *first, SPObject const *second)
 {
-    return sp_repr_compare_position(((SPItem*)first)->getRepr(),
-    		((SPItem*)second)->getRepr())<0;
+    return sp_repr_compare_position(((SPItem *)first)->getRepr(), ((SPItem *)second)->getRepr()) < 0;
 }
 
-void
-sp_selection_raise(Inkscape::Selection *selection, SPDesktop *desktop)
+void sp_selection_raise(Inkscape::Selection *selection, SPDesktop *desktop)
 {
-    std::vector<SPItem*> items= selection->itemList();
+    std::vector<SPItem *> items = selection->itemList();
     if (items.empty()) {
         selection_display_message(desktop, Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to raise."));
         return;
@@ -959,22 +926,23 @@
 
     SPGroup const *group = sp_item_list_common_parent_group(items);
     if (!group) {
-        selection_display_message(desktop, Inkscape::ERROR_MESSAGE, _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
+        selection_display_message(desktop, Inkscape::ERROR_MESSAGE,
+                                  _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
         return;
     }
 
     Inkscape::XML::Node *grepr = const_cast<Inkscape::XML::Node *>(group->getRepr());
 
     /* Construct reverse-ordered list of selected children. */
-    std::vector<SPItem*> rev(items);
-    sort(rev.begin(),rev.end(),sp_item_repr_compare_position_bool);
+    std::vector<SPItem *> rev(items);
+    sort(rev.begin(), rev.end(), sp_item_repr_compare_position_bool);
 
     // 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) {
-        for (std::vector<SPItem*>::const_iterator item=rev.begin();item!=rev.end();item++) {
+        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) {
@@ -982,9 +950,9 @@
                 SPItem *newItem = dynamic_cast<SPItem *>(newref);
                 if (newItem) {
                     Geom::OptRect newref_bbox = newItem->desktopVisualBounds();
-                    if ( newref_bbox && selected->intersects(*newref_bbox) ) {
+                    if (newref_bbox && selected->intersects(*newref_bbox)) {
                         // AND if it's not one of our selected objects,
-                        if ( std::find(items.begin(),items.end(),newref)==items.end()) {
+                        if (std::find(items.begin(), items.end(), newref) == items.end()) {
                             // move the selected object after that sibling
                             grepr->changeOrder(child->getRepr(), newref->getRepr());
                         }
@@ -995,7 +963,7 @@
         }
     }
     DocumentUndo::done(selection->layers()->getDocument(), SP_VERB_SELECTION_RAISE,
-                       //TRANSLATORS: "Raise" means "to raise an object" in the undo history
+                       // TRANSLATORS: "Raise" means "to raise an object" in the undo history
                        C_("Undo action", "Raise"));
 }
 
@@ -1008,29 +976,29 @@
         return;
     }
 
-    std::vector<SPItem*> items = selection->itemList();
+    std::vector<SPItem *> items = selection->itemList();
 
     SPGroup const *group = sp_item_list_common_parent_group(items);
     if (!group) {
-        selection_display_message(desktop, Inkscape::ERROR_MESSAGE, _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
+        selection_display_message(desktop, Inkscape::ERROR_MESSAGE,
+                                  _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
         return;
     }
 
-    std::vector<Inkscape::XML::Node*> rl(selection->reprList());
-    sort(rl.begin(),rl.end(),sp_repr_compare_position_bool);
+    std::vector<Inkscape::XML::Node *> rl(selection->reprList());
+    sort(rl.begin(), rl.end(), sp_repr_compare_position_bool);
 
-    for (std::vector<Inkscape::XML::Node*>::const_iterator l=rl.begin(); l!=rl.end();l++) {
-        Inkscape::XML::Node *repr =(*l);
+    for (std::vector<Inkscape::XML::Node *>::const_iterator l = rl.begin(); l != rl.end(); l++) {
+        Inkscape::XML::Node *repr = (*l);
         repr->setPosition(-1);
     }
 
-    DocumentUndo::done(document, SP_VERB_SELECTION_TO_FRONT,
-                       _("Raise to top"));
+    DocumentUndo::done(document, SP_VERB_SELECTION_TO_FRONT, _("Raise to top"));
 }
 
 void sp_selection_lower(Inkscape::Selection *selection, SPDesktop *desktop)
 {
-    std::vector<SPItem*> items = selection->itemList();
+    std::vector<SPItem *> items = selection->itemList();
     if (items.empty()) {
         selection_display_message(desktop, Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to lower."));
         return;
@@ -1038,7 +1006,8 @@
 
     SPGroup const *group = sp_item_list_common_parent_group(items);
     if (!group) {
-        selection_display_message(desktop, Inkscape::ERROR_MESSAGE, _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
+        selection_display_message(desktop, Inkscape::ERROR_MESSAGE,
+                                  _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
         return;
     }
 
@@ -1048,12 +1017,12 @@
     Geom::OptRect selected = enclose_items(items);
 
     /* Construct direct-ordered list of selected children. */
-    std::vector<SPItem*> rev(items);
-    sort(rev.begin(),rev.end(),sp_item_repr_compare_position_bool);
+    std::vector<SPItem *> rev(items);
+    sort(rev.begin(), rev.end(), sp_item_repr_compare_position_bool);
 
     // Iterate over all objects in the selection (starting from top).
     if (selected) {
-        for (std::vector<SPItem*>::const_reverse_iterator item=rev.rbegin();item!=rev.rend();item++) {
+        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)) {
@@ -1061,9 +1030,9 @@
                 SPItem *newItem = dynamic_cast<SPItem *>(newref);
                 if (newItem) {
                     Geom::OptRect ref_bbox = newItem->desktopVisualBounds();
-                    if ( ref_bbox && selected->intersects(*ref_bbox) ) {
+                    if (ref_bbox && selected->intersects(*ref_bbox)) {
                         // AND if it's not one of our selected objects,
-                        if (items.end()==std::find(items.begin(),items.end(),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)
@@ -1079,7 +1048,7 @@
     }
 
     DocumentUndo::done(selection->layers()->getDocument(), SP_VERB_SELECTION_LOWER,
-                       //TRANSLATORS: "Lower" means "to lower an object" in the undo history
+                       // TRANSLATORS: "Lower" means "to lower an object" in the undo history
                        C_("Undo action", "Lower"));
 }
 
@@ -1092,18 +1061,19 @@
         return;
     }
 
-    std::vector<SPItem*> items =selection->itemList();
+    std::vector<SPItem *> items = selection->itemList();
 
     SPGroup const *group = sp_item_list_common_parent_group(items);
     if (!group) {
-        selection_display_message(desktop, Inkscape::ERROR_MESSAGE, _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
+        selection_display_message(desktop, Inkscape::ERROR_MESSAGE,
+                                  _("You cannot raise/lower objects from <b>different groups</b> or <b>layers</b>."));
         return;
     }
 
-    std::vector<Inkscape::XML::Node*> rl(selection->reprList());
-    sort(rl.begin(),rl.end(),sp_repr_compare_position_bool);
+    std::vector<Inkscape::XML::Node *> rl(selection->reprList());
+    sort(rl.begin(), rl.end(), sp_repr_compare_position_bool);
 
-    for (std::vector<Inkscape::XML::Node*>::const_reverse_iterator l=rl.rbegin();l!=rl.rend();l++) {
+    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 = (*l);
@@ -1118,26 +1088,25 @@
         repr->setPosition(minpos);
     }
 
-    DocumentUndo::done(document, SP_VERB_SELECTION_TO_BACK,
-                       _("Lower to bottom"));
+    DocumentUndo::done(document, SP_VERB_SELECTION_TO_BACK, _("Lower to bottom"));
 }
 
-void
-sp_undo(SPDesktop *desktop, SPDocument *)
+void sp_undo(SPDesktop *desktop, SPDocument *)
 {
     // No re/undo while dragging, too dangerous.
-    if(desktop->getCanvas()->is_dragging) return;
+    if (desktop->getCanvas()->is_dragging)
+        return;
 
     if (!DocumentUndo::undo(desktop->getDocument())) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Nothing to undo."));
     }
 }
 
-void
-sp_redo(SPDesktop *desktop, SPDocument *)
+void sp_redo(SPDesktop *desktop, SPDocument *)
 {
     // No re/undo while dragging, too dangerous.
-    if(desktop->getCanvas()->is_dragging) return;
+    if (desktop->getCanvas()->is_dragging)
+        return;
 
     if (!DocumentUndo::redo(desktop->getDocument())) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Nothing to redo."));
@@ -1153,8 +1122,7 @@
 /**
  * \pre item != NULL
  */
-SPCSSAttr *
-take_style_from_item(SPObject *object)
+SPCSSAttr *take_style_from_item(SPObject *object)
 {
     // CPPIFY:
     // This function should only take SPItems, but currently SPString is not an Item.
@@ -1168,8 +1136,9 @@
         (dynamic_cast<SPText *>(object) && object->children && object->children->next == NULL)) {
         // if this is a text with exactly one tspan child, merge the style of that tspan as well
         // If this is a group, merge the style of its topmost (last) child with style
-        for (SPObject *last_element = object->lastChild(); last_element != NULL; last_element = last_element->getPrev()) {
-            if ( last_element->style ) {
+        for (SPObject *last_element = object->lastChild(); last_element != NULL;
+             last_element = last_element->getPrev()) {
+            if (last_element->style) {
                 SPCSSAttr *temp = sp_css_attr_from_object(last_element, SP_STYLE_FLAG_IFSET);
                 if (temp) {
                     sp_repr_css_merge(css, temp);
@@ -1183,7 +1152,8 @@
     // Remove black-listed properties (those that should not be used in a default style)
     css = sp_css_attr_unset_blacklist(css);
 
-    if (!(dynamic_cast<SPText *>(object) || dynamic_cast<SPTSpan *>(object) || dynamic_cast<SPTRef *>(object) || dynamic_cast<SPString *>(object))) {
+    if (!(dynamic_cast<SPText *>(object) || dynamic_cast<SPTSpan *>(object) || dynamic_cast<SPTRef *>(object) ||
+          dynamic_cast<SPString *>(object))) {
         // do not copy text properties from non-text objects, it's confusing
         css = sp_css_attr_unset_text(css);
     }
@@ -1229,16 +1199,15 @@
 {
     Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
     if (cm->pastePathEffect(desktop)) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_PASTE_LIVEPATHEFFECT,
-                           _("Paste live path effect"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_PASTE_LIVEPATHEFFECT, _("Paste live path effect"));
     }
 }
 
 
 static void sp_selection_remove_livepatheffect_impl(SPItem *item)
 {
-    if ( SPLPEItem *lpeitem = dynamic_cast<SPLPEItem*>(item) ) {
-        if ( lpeitem->hasPathEffect() ) {
+    if (SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item)) {
+        if (lpeitem->hasPathEffect()) {
             lpeitem->removeAllPathEffects(false);
         }
     }
@@ -1246,30 +1215,31 @@
 
 void sp_selection_remove_livepatheffect(SPDesktop *desktop)
 {
-    if (desktop == NULL) return;
+    if (desktop == NULL)
+        return;
 
     Inkscape::Selection *selection = desktop->getSelection();
 
     // check if something is selected
     if (selection->isEmpty()) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to remove live path effects from."));
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                       _("Select <b>object(s)</b> to remove live path effects from."));
         return;
     }
-    std::vector<SPItem*> list=selection->itemList();
-    for ( std::vector<SPItem*>::const_iterator itemlist=list.begin();itemlist!=list.end();itemlist++) {
+    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);
-
     }
 
-    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_REMOVE_LIVEPATHEFFECT,
-                       _("Remove live path effect"));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_REMOVE_LIVEPATHEFFECT, _("Remove live path effect"));
 }
 
 void sp_selection_remove_filter(SPDesktop *desktop)
 {
-    if (desktop == NULL) return;
+    if (desktop == NULL)
+        return;
 
     Inkscape::Selection *selection = desktop->getSelection();
 
@@ -1284,8 +1254,7 @@
     sp_desktop_set_style(desktop, css);
     sp_repr_css_attr_unref(css);
 
-    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_REMOVE_FILTER,
-                       _("Remove filter"));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_REMOVE_FILTER, _("Remove filter"));
 }
 
 
@@ -1293,8 +1262,7 @@
 {
     Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
     if (cm->pasteSize(desktop, false, apply_x, apply_y)) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_PASTE_SIZE,
-                           _("Paste size"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_PASTE_SIZE, _("Paste size"));
     }
 }
 
@@ -1302,8 +1270,7 @@
 {
     Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
     if (cm->pasteSize(desktop, true, apply_x, apply_y)) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_PASTE_SIZE_SEPARATELY,
-                           _("Paste size separately"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_PASTE_SIZE_SEPARATELY, _("Paste size separately"));
     }
 }
 
@@ -1311,16 +1278,15 @@
  * 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(std::vector<SPItem*> const &items,SPObject *where)
+void sp_selection_change_layer_maintain_clones(std::vector<SPItem *> const &items, SPObject *where)
 {
-    for (std::vector<SPItem*>::const_iterator i = items.begin(); i != items.end(); i++) {
+    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);
             sp_item_group_ungroup_handle_clones(item,
-                    (oldparent->i2doc_affine())
-                    *((newparent->i2doc_affine()).inverse()));
+                                                (oldparent->i2doc_affine()) * ((newparent->i2doc_affine()).inverse()));
         }
     }
 }
@@ -1336,17 +1302,18 @@
         return;
     }
 
-    std::vector<SPItem*> items(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());
+    SPObject *next = Inkscape::next_layer(dt->currentRoot(), dt->currentLayer());
     if (next) {
-        sp_selection_change_layer_maintain_clones(items,next);
-        std::vector<Inkscape::XML::Node*> temp_clip;
+        sp_selection_change_layer_maintain_clones(items, next);
+        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
-        std::vector<Inkscape::XML::Node*> copied;
+        next =
+            Inkscape::next_layer(dt->currentRoot(), dt->currentLayer()); // Fixes bug 1482973: crash while moving layers
+        std::vector<Inkscape::XML::Node *> copied;
         if (next) {
             copied = sp_selection_paste_impl(dt->getDocument(), next, temp_clip);
         } else {
@@ -1354,10 +1321,10 @@
             no_more = true;
         }
         selection->setReprList(copied);
-        if (next) dt->setCurrentLayer(next);
-        if ( !suppressDone ) {
-            DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO_NEXT,
-                               _("Raise to next layer"));
+        if (next)
+            dt->setCurrentLayer(next);
+        if (!suppressDone) {
+            DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO_NEXT, _("Raise to next layer"));
         }
     } else {
         no_more = true;
@@ -1366,7 +1333,6 @@
     if (no_more) {
         dt->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No more layers above."));
     }
-
 }
 
 void sp_selection_to_prev_layer(SPDesktop *dt, bool suppressDone)
@@ -1379,28 +1345,30 @@
         return;
     }
 
-    const std::vector<SPItem*> items(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());
+    SPObject *next = Inkscape::previous_layer(dt->currentRoot(), dt->currentLayer());
     if (next) {
-        sp_selection_change_layer_maintain_clones(items,next);
-        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_change_layer_maintain_clones(items, next);
+        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
-        std::vector<Inkscape::XML::Node*> copied;
+        next = Inkscape::previous_layer(dt->currentRoot(),
+                                        dt->currentLayer()); // Fixes bug 1482973: crash while moving layers
+        std::vector<Inkscape::XML::Node *> copied;
         if (next) {
             copied = sp_selection_paste_impl(dt->getDocument(), next, temp_clip);
         } else {
             copied = sp_selection_paste_impl(dt->getDocument(), dt->currentLayer(), temp_clip);
             no_more = true;
         }
-        selection->setReprList( copied);
-        if (next) dt->setCurrentLayer(next);
-        if ( !suppressDone ) {
-            DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO_PREV,
-                               _("Lower to previous layer"));
+        selection->setReprList(copied);
+        if (next)
+            dt->setCurrentLayer(next);
+        if (!suppressDone) {
+            DocumentUndo::done(dt->getDocument(), SP_VERB_LAYER_MOVE_TO_PREV, _("Lower to previous layer"));
         }
     } else {
         no_more = true;
@@ -1421,34 +1389,34 @@
         return;
     }
 
-    std::vector<SPItem*> items(selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
 
     if (moveto) {
-        sp_selection_change_layer_maintain_clones(items,moveto);
-        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_change_layer_maintain_clones(items, moveto);
+        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);
-        std::vector<Inkscape::XML::Node*> copied = sp_selection_paste_impl(dt->getDocument(), moveto, 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"));
+        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"));
         }
     }
 }
 
-static bool
-selection_contains_original(SPItem *item, Inkscape::Selection *selection)
+static bool selection_contains_original(SPItem *item, Inkscape::Selection *selection)
 {
     bool contains_original = false;
 
     SPItem *item_use = item;
     SPItem *item_use_first = item;
     SPUse *use = dynamic_cast<SPUse *>(item_use);
-    while (use && item_use && !contains_original)
-    {
+    while (use && item_use && !contains_original) {
         item_use = use->get_original();
         use = dynamic_cast<SPUse *>(item_use);
         contains_original |= selection->includes(item_use);
@@ -1467,12 +1435,11 @@
 }
 
 
-static bool
-selection_contains_both_clone_and_original(Inkscape::Selection *selection)
+static bool selection_contains_both_clone_and_original(Inkscape::Selection *selection)
 {
     bool clone_with_original = false;
-    std::vector<SPItem*> items = selection->itemList();
-    for (std::vector<SPItem*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+    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);
@@ -1483,13 +1450,149 @@
     return clone_with_original;
 }
 
+/* This function is called by sp_selection_apply_affine.
+It takes all elements in selection, looks for all clones (or linked offsets) that are also in the
+selection (either directly selected or in a selected group)
+
+The matrix magic in it is designed so that any transformation (translation or other) is handled
+with any selections in a coherent way.
+
+Note that if affine is a translation, then SPUse::compensate is involved in a subtle way and we
+have to account for it.
+
+If you want to modify this function, please watch carefully for regressions, and take extra care
+to have the right advertised transforms so that clones of clones behave well.
+
+There are 10 cases to test.
+*/
+static void prevent_clone_double_transform(Inkscape::Selection *selection, SPItem *parent, Geom::Affine affine,
+                                           bool compensate)
+{
+    // "clones are unmoved when original is moved" preference
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
+    bool prefs_unmoved = (compensation == SP_CLONE_COMPENSATION_UNMOVED);
+    bool prefs_parallel = (compensation == SP_CLONE_COMPENSATION_PARALLEL);
+
+    // calculate the matrix we need to apply to the clone to cancel its induced transform from its original
+    if (!dynamic_cast<SPItem *>(parent->parent))
+        return;
+    Geom::Affine parent2dt = dynamic_cast<SPItem *>(parent->parent)->i2dt_affine();
+    Geom::Affine t = parent2dt * affine * parent2dt.inverse();
+    Geom::Affine t_inv = t.inverse();
+
+    for (std::list<SPObject *>::const_iterator refd = parent->hrefList.begin(); refd != parent->hrefList.end();
+         refd++) {
+        SPItem *item = dynamic_cast<SPItem *>(*refd);
+        if (!item || item->cloned)
+            continue;
+        bool transform_offset_with_source = false;
+        bool transform_clone_with_original = false;
+        bool transform_deep_offset_with_source = false;
+        bool transform_deep_clone_with_original = false;
+
+        SPUse *useitem = dynamic_cast<SPUse *>(item);
+        SPOffset *off = dynamic_cast<SPOffset *>(item);
+        if (off && off->sourceHref && sp_offset_get_source(off) == parent) {
+            // We transform a linked offset and (directly) its original
+            transform_offset_with_source = selection->includes(off);
+            transform_deep_offset_with_source = selection->includes_deeply(off);
+        } else if (useitem && useitem->get_original() == parent) {
+            // We are transforming a clone along with its original.
+            transform_clone_with_original = selection->includes(useitem);
+            transform_deep_clone_with_original = selection->includes_deeply(useitem);
+        } else
+            continue;
+
+        // restore item->transform field from the repr, in case it was changed by seltrans
+        item->readAttr("transform");
+
+        if (transform_clone_with_original || transform_offset_with_source) {
+            // case 1: the clone and the original are directly selected.
+
+            Geom::Affine result = t_inv * item->transform * t;
+
+            if (transform_clone_with_original && (prefs_parallel || prefs_unmoved) && affine.isTranslation()) {
+                // 1.1: translation, clone
+                // find out the clone move, same as in SPUse::move_compensate
+                Geom::Affine parent = useitem->get_parent_transform();
+                Geom::Affine clone_move = parent.inverse() * t * parent;
+
+                if (prefs_parallel) {
+                    Geom::Affine move = result * clone_move * t_inv;
+                    item->doWriteTransform(item->getRepr(), move, &move, compensate);
+
+                } else if (prefs_unmoved) {
+                    Geom::Affine move = result * clone_move;
+                    item->doWriteTransform(item->getRepr(), move, &t, compensate);
+                }
+
+            } else if (transform_offset_with_source && (prefs_parallel || prefs_unmoved) && affine.isTranslation()) {
+                // 1.2: translation, offset
+                Geom::Affine parent = item->transform;
+                Geom::Affine offset_move = parent.inverse() * t * parent;
+
+                if (prefs_parallel) {
+                    Geom::Affine move = result * offset_move * t_inv;
+                    item->doWriteTransform(item->getRepr(), move, &move, compensate);
+
+                } else if (prefs_unmoved) {
+                    Geom::Affine move = result * offset_move;
+                    item->doWriteTransform(item->getRepr(), move, &t, compensate);
+                }
+            } else { // 1.3: affine is no translation, just apply the result
+                item->doWriteTransform(item->getRepr(), result, &t, compensate);
+            }
+        } else if (transform_deep_clone_with_original || transform_deep_offset_with_source) {
+            // case 2: The original is selected, and the clone is somewhere in a selected group.
+            if (transform_deep_clone_with_original && (prefs_parallel || prefs_unmoved) && affine.isTranslation()) {
+                // 2.1: translation, clone
+
+                Geom::Affine parent = useitem->get_parent_transform();
+                Geom::Affine clone_move = parent.inverse() * t * parent;
+
+                if (prefs_parallel) {
+                    Geom::Affine move = t_inv * item->transform * t_inv * clone_move;
+                    item->doWriteTransform(item->getRepr(), move, &move, compensate);
+
+                } else if (prefs_unmoved) {
+                    Geom::Affine move = t_inv * item->transform * clone_move;
+                    Geom::Affine move_a = Geom::Affine::identity();
+                    item->doWriteTransform(item->getRepr(), move, &move_a, compensate);
+                }
+            } else if (transform_deep_offset_with_source && (prefs_parallel || prefs_unmoved) &&
+                       affine.isTranslation()) {
+                // 2.2: translation, offset
+                Geom::Affine parent = item->transform;
+                Geom::Affine offset_move = parent.inverse() * t * parent;
+                Geom::Affine result = t_inv * item->transform * t_inv;
+
+                if (prefs_parallel) {
+                    Geom::Affine move = result * offset_move;
+                    item->doWriteTransform(item->getRepr(), move, &move, compensate);
+
+                } else if (prefs_unmoved) {
+                    Geom::Affine move = result * t * offset_move;
+                    Geom::Affine move_a = Geom::Affine::identity();
+                    item->doWriteTransform(item->getRepr(), move, &move_a, compensate);
+                }
+            } else { // 2.3: affine is no translation
+                Geom::Affine move = parent2dt * affine.inverse() * parent2dt.inverse() * item->transform;
+                item->doWriteTransform(item->getRepr(), move, &move, compensate);
+            }
+        }
+    }
+}
+
+
 /** Apply matrix to the selection.  \a set_i2d is normally true, which means objects are in the
 original transform, synced with their reprs, and need to jump to the new transform in one go. A
 value of set_i2d==false is only used by seltrans when it's dragging objects live (not outlines); in
 that case, items are already in the new position, but the repr is in the old, and this function
 then simply updates the repr from item->transform.
  */
-void sp_selection_apply_affine(Inkscape::Selection *selection, Geom::Affine const &affine, bool set_i2d, bool compensate, bool adjust_transf_center)
+void sp_selection_apply_affine(Inkscape::Selection *selection, Geom::Affine const &affine, bool set_i2d,
+                               bool compensate, bool adjust_transf_center)
 {
     if (selection->isEmpty())
         return;
@@ -1500,13 +1603,13 @@
     Persp3D *transf_persp;
     std::list<Persp3D *> plist = selection->perspList();
     for (std::list<Persp3D *>::iterator i = plist.begin(); i != plist.end(); ++i) {
-        persp = (Persp3D *) (*i);
+        persp = (Persp3D *)(*i);
 
-        if (!persp3d_has_all_boxes_in_selection (persp, selection)) {
+        if (!persp3d_has_all_boxes_in_selection(persp, selection)) {
             std::list<SPBox3D *> selboxes = selection->box3DList(persp);
 
             // create a new perspective as a copy of the current one and link the selected boxes to it
-            transf_persp = persp3d_create_xml_element (persp->document, persp->perspective_impl);
+            transf_persp = persp3d_create_xml_element(persp->document, persp->perspective_impl);
 
             for (std::list<SPBox3D *>::iterator b = selboxes.begin(); b != selboxes.end(); ++b)
                 box3d_switch_perspectives(*b, persp, transf_persp);
@@ -1516,38 +1619,49 @@
 
         persp3d_apply_affine_transformation(transf_persp, affine);
     }
-    std::vector<SPItem*> items = selection->itemList();
-    for (std::vector<SPItem*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+    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) ) {
+        if (dynamic_cast<SPRoot *>(item)) {
             // An SVG element cannot have a transform. We could change 'x' and 'y' in response
             // to a translation... but leave that for another day.
-            selection->desktop()->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Cannot transform an embedded SVG."));
+            selection->desktop()->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                                        _("Cannot transform an embedded SVG."));
             break;
         }
 
-        Geom::Point old_center(0,0);
+        Geom::Point old_center(0, 0);
         if (set_i2d && item->isCenterSet())
             old_center = item->getCenter();
 
-#if 0 /* Re-enable this once persistent guides have a graphical indication.
+#if 0 /* Re-enable this once persistent guides have a graphical indication.                                            \
          At the time of writing, this is the only place to re-enable. */
         sp_item_update_cns(*item, selection->desktop());
 #endif
 
-        // we're moving both a clone and its original or any ancestor in clone chain?
-        bool transform_clone_with_original = selection_contains_original(item, selection);
-
-        // ...both a text-on-path and its path?
-        bool transform_textpath_with_path = ((dynamic_cast<SPText *>(item) && item->firstChild() && dynamic_cast<SPTextPath *>(item->firstChild()))
-                                             && selection->includes( sp_textpath_get_path_item(dynamic_cast<SPTextPath *>(item->firstChild())) ));
-
-        // ...both a flowtext and its frame?
-        bool transform_flowtext_with_frame = (dynamic_cast<SPFlowtext *>(item) && selection->includes( dynamic_cast<SPFlowtext *>(item)->get_frame(NULL))); // (only the first frame is checked so far)
-
-        // ...both an offset and its source?
-        bool transform_offset_with_source = (dynamic_cast<SPOffset *>(item) && dynamic_cast<SPOffset *>(item)->sourceHref) && selection->includes( sp_offset_get_source(dynamic_cast<SPOffset *>(item)) );
+        // everyting is taken care of in prevent_clone_double_transform for the two first cases,
+        // *after* the transformation is applied to the original.
+
+        // Tests if we're moving both a clone and its original...
+        if (selection_contains_original(item, selection))
+            continue;
+
+        // ...both an offset and its source...
+        if ((dynamic_cast<SPOffset *>(item) && dynamic_cast<SPOffset *>(item)->sourceHref) &&
+            selection->includes(sp_offset_get_source(dynamic_cast<SPOffset *>(item))))
+            continue;
+
+        // ...both a text-on-path and its path...
+        bool transform_textpath_with_path =
+            ((dynamic_cast<SPText *>(item) && item->firstChild() && dynamic_cast<SPTextPath *>(item->firstChild())) &&
+             selection->includes(sp_textpath_get_path_item(dynamic_cast<SPTextPath *>(item->firstChild()))));
+
+        // ...both a flowtext and its frame...
+        bool transform_flowtext_with_frame = (dynamic_cast<SPFlowtext *>(item) &&
+                                              selection->includes(dynamic_cast<SPFlowtext *>(item)->get_frame(
+                                                  NULL))); // (only the first frame is checked so far)
+
 
         // If we're moving a connector, we want to detach it
         // from shapes that aren't part of the selection, but
@@ -1555,7 +1669,7 @@
         if (Inkscape::UI::Tools::cc_item_is_connector(item)) {
             SPPath *path = dynamic_cast<SPPath *>(item);
             if (path) {
-                SPItem *attItem[2] = {0, 0};
+                SPItem *attItem[2] = { 0, 0 };
                 path->connEndPair.getAttachedItems(attItem);
                 for (int n = 0; n < 2; ++n) {
                     if (!selection->includes(attItem[n])) {
@@ -1567,12 +1681,6 @@
             }
         }
 
-        // "clones are unmoved when original is moved" preference
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        int compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
-        bool prefs_unmoved = (compensation == SP_CLONE_COMPENSATION_UNMOVED);
-        bool prefs_parallel = (compensation == SP_CLONE_COMPENSATION_PARALLEL);
-
         /* If this is a clone and it's selected along with its original, do not move it;
          * it will feel the transform of its original and respond to it itself.
          * Without this, a clone is doubly transformed, very unintuitive.
@@ -1582,86 +1690,20 @@
          * Same for linked offset if we are also moving its source: do not move it. */
         if (transform_textpath_with_path) {
             // Restore item->transform field from the repr, in case it was changed by seltrans.
-            item->readAttr( "transform" );
+            item->readAttr("transform");
         } else if (transform_flowtext_with_frame) {
             // apply the inverse of the region's transform to the <use> so that the flow remains
             // the same (even though the output itself gets transformed)
-            for ( SPObject *region = item->firstChild() ; region ; region = region->getNext() ) {
+            for (SPObject *region = item->firstChild(); region; region = region->getNext()) {
                 if (dynamic_cast<SPFlowregion *>(region) || dynamic_cast<SPFlowregionExclude *>(region)) {
-                    for ( SPObject *item = region->firstChild() ; item ; item = item->getNext() ) {
+                    for (SPObject *item = region->firstChild(); item; item = item->getNext()) {
                         SPUse *use = dynamic_cast<SPUse *>(item);
-                        if ( use ) {
+                        if (use) {
                             use->doWriteTransform(use->getRepr(), use->transform.inverse(), NULL, compensate);
                         }
                     }
                 }
             }
-        } else if (transform_clone_with_original || transform_offset_with_source) {
-            // We are transforming a clone along with its original. The below matrix juggling is
-            // necessary to ensure that they transform as a whole, i.e. the clone's induced
-            // transform and its move compensation are both cancelled out.
-
-            // restore item->transform field from the repr, in case it was changed by seltrans
-            item->readAttr( "transform" );
-
-            // calculate the matrix we need to apply to the clone to cancel its induced transform from its original
-            Geom::Affine parent2dt;
-            {
-                SPItem *parentItem = dynamic_cast<SPItem *>(item->parent);
-                if (parentItem) {
-                    parent2dt = parentItem->i2dt_affine();
-                } else {
-                    g_assert_not_reached();
-                }
-            }
-            Geom::Affine t = parent2dt * affine * parent2dt.inverse();
-            Geom::Affine t_inv = t.inverse();
-            Geom::Affine result = t_inv * item->transform * t;
-
-            if (transform_clone_with_original && (prefs_parallel || prefs_unmoved) && affine.isTranslation()) {
-                // we need to cancel out the move compensation, too
-
-                // find out the clone move, same as in sp_use_move_compensate
-                Geom::Affine parent;
-                {
-                    SPUse *use = dynamic_cast<SPUse *>(item);
-                    if (use) {
-                        parent = use->get_parent_transform();
-                    } else {
-                        g_assert_not_reached();
-                    }
-                }
-                Geom::Affine clone_move = parent.inverse() * t * parent;
-
-                if (prefs_parallel) {
-                    Geom::Affine move = result * clone_move * t_inv;
-                    item->doWriteTransform(item->getRepr(), move, &move, compensate);
-
-                } else if (prefs_unmoved) {
-                    //if (dynamic_cast<SPUse *>(sp_use_get_original(dynamic_cast<SPUse *>(item))))
-                    //    clone_move = Geom::identity();
-                    Geom::Affine move = result * clone_move;
-                    item->doWriteTransform(item->getRepr(), move, &t, compensate);
-                }
-
-            } else if (transform_offset_with_source && (prefs_parallel || prefs_unmoved) && affine.isTranslation()){
-                Geom::Affine parent = item->transform;
-                Geom::Affine offset_move = parent.inverse() * t * parent;
-
-                if (prefs_parallel) {
-                    Geom::Affine move = result * offset_move * t_inv;
-                    item->doWriteTransform(item->getRepr(), move, &move, compensate);
-
-                } else if (prefs_unmoved) {
-                    Geom::Affine move = result * offset_move;
-                    item->doWriteTransform(item->getRepr(), move, &t, compensate);
-                }
-
-            } else {
-                // just apply the result
-                item->doWriteTransform(item->getRepr(), result, &t, compensate);
-            }
-
         } else {
             if (set_i2d) {
                 item->set_i2d_affine(item->i2dt_affine() * (Geom::Affine)affine);
@@ -1669,7 +1711,11 @@
             item->doWriteTransform(item->getRepr(), item->transform, NULL, compensate);
         }
 
-        if (adjust_transf_center) { // The transformation center should not be touched in case of pasting or importing, which is allowed by this if clause
+        // taking care of clones and linked offsets
+        prevent_clone_double_transform(selection, item, affine, compensate);
+
+        if (adjust_transf_center) { // The transformation center should not be touched in case of pasting or importing,
+                                    // which is allowed by this if clause
             // if we're moving the actual object, not just updating the repr, we can transform the
             // center by the same matrix (only necessary for non-translations)
             if (set_i2d && item->isCenterSet() && !(affine.isTranslation() || affine.isIdentity())) {
@@ -1687,35 +1733,31 @@
 
     Inkscape::Selection *selection = desktop->getSelection();
 
-    std::vector<Inkscape::XML::Node*> items = selection->reprList();
-    for (std::vector<Inkscape::XML::Node*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+    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,
-                       _("Remove transform"));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_OBJECT_FLATTEN, _("Remove transform"));
 }
 
-void
-sp_selection_scale_absolute(Inkscape::Selection *selection,
-                            double const x0, double const x1,
-                            double const y0, double const y1)
+void sp_selection_scale_absolute(Inkscape::Selection *selection, double const x0, double const x1, double const y0,
+                                 double const y1)
 {
     if (selection->isEmpty())
         return;
 
     Geom::OptRect bbox = selection->visualBounds();
-    if ( !bbox ) {
+    if (!bbox) {
         return;
     }
 
     Geom::Translate const p2o(-bbox->min());
 
-    Geom::Scale const newSize(x1 - x0,
-                              y1 - y0);
-    Geom::Scale const scale( newSize * Geom::Scale(bbox->dimensions()).inverse() );
+    Geom::Scale const newSize(x1 - x0, y1 - y0);
+    Geom::Scale const scale(newSize * Geom::Scale(bbox->dimensions()).inverse());
     Geom::Translate const o2n(x0, y0);
-    Geom::Affine const final( p2o * scale * o2n );
+    Geom::Affine const final(p2o * scale * o2n);
 
     sp_selection_apply_affine(selection, final);
 }
@@ -1728,42 +1770,38 @@
 
     Geom::OptRect bbox = selection->visualBounds();
 
-    if ( !bbox ) {
+    if (!bbox) {
         return;
     }
 
-    // FIXME: ARBITRARY LIMIT: don't try to scale above 1 Mpx, it won't display properly and will crash sooner or later anyway
-    if ( bbox->dimensions()[Geom::X] * scale[Geom::X] > 1e6  ||
-         bbox->dimensions()[Geom::Y] * scale[Geom::Y] > 1e6 )
-    {
+    // FIXME: ARBITRARY LIMIT: don't try to scale above 1 Mpx, it won't display properly and will crash sooner or later
+    // anyway
+    if (bbox->dimensions()[Geom::X] * scale[Geom::X] > 1e6 || bbox->dimensions()[Geom::Y] * scale[Geom::Y] > 1e6) {
         return;
     }
 
     Geom::Translate const n2d(-align);
     Geom::Translate const d2n(align);
-    Geom::Affine const final( n2d * scale * d2n );
+    Geom::Affine const final(n2d * scale * d2n);
     sp_selection_apply_affine(selection, final);
 }
 
-void
-sp_selection_rotate_relative(Inkscape::Selection *selection, Geom::Point const &center, gdouble const angle_degrees)
+void sp_selection_rotate_relative(Inkscape::Selection *selection, Geom::Point const &center,
+                                  gdouble const angle_degrees)
 {
     Geom::Translate const d2n(center);
     Geom::Translate const n2d(-center);
     Geom::Rotate const rotate(Geom::Rotate::from_degrees(angle_degrees));
-    Geom::Affine const final( Geom::Affine(n2d) * rotate * d2n );
+    Geom::Affine const final(Geom::Affine(n2d) * rotate * d2n);
     sp_selection_apply_affine(selection, final);
 }
 
-void
-sp_selection_skew_relative(Inkscape::Selection *selection, Geom::Point const &align, double dx, double dy)
+void sp_selection_skew_relative(Inkscape::Selection *selection, Geom::Point const &align, double dx, double dy)
 {
     Geom::Translate const d2n(align);
     Geom::Translate const n2d(-align);
-    Geom::Affine const skew(1, dy,
-                            dx, 1,
-                            0, 0);
-    Geom::Affine const final( n2d * skew * d2n );
+    Geom::Affine const skew(1, dy, dx, 1, 0, 0);
+    Geom::Affine const final(n2d * skew * d2n);
     sp_selection_apply_affine(selection, final);
 }
 
@@ -1787,9 +1825,9 @@
     if (selection->isEmpty())
         return;
 
-    std::vector<SPItem*> items = 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 (std::vector<SPItem*>::const_iterator l=items.begin();l!=items.end() ;l++) {
+    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);
@@ -1798,13 +1836,11 @@
         }
     }
 
-    DocumentUndo::done(desktop->getDocument(),
-                       ccw ? SP_VERB_OBJECT_ROTATE_90_CCW : SP_VERB_OBJECT_ROTATE_90_CW,
+    DocumentUndo::done(desktop->getDocument(), ccw ? SP_VERB_OBJECT_ROTATE_90_CCW : SP_VERB_OBJECT_ROTATE_90_CW,
                        ccw ? _("Rotate 90\xc2\xb0 CCW") : _("Rotate 90\xc2\xb0 CW"));
 }
 
-void
-sp_selection_rotate(Inkscape::Selection *selection, gdouble const angle_degrees)
+void sp_selection_rotate(Inkscape::Selection *selection, gdouble const angle_degrees)
 {
     if (selection->isEmpty())
         return;
@@ -1817,11 +1853,8 @@
     sp_selection_rotate_relative(selection, *center, angle_degrees);
 
     DocumentUndo::maybeDone(selection->desktop()->getDocument(),
-                            ( ( angle_degrees > 0 )
-                              ? "selector:rotate:ccw"
-                              : "selector:rotate:cw" ),
-                            SP_VERB_CONTEXT_SELECT,
-                            _("Rotate"));
+                            ((angle_degrees > 0) ? "selector:rotate:ccw" : "selector:rotate:cw"),
+                            SP_VERB_CONTEXT_SELECT, _("Rotate"));
 }
 
 /*
@@ -1846,42 +1879,39 @@
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
     bool ingroups = TRUE;
-    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;
+    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();
-    std::vector<SPItem*> items = selection->itemList();
+    std::vector<SPItem *> items = selection->itemList();
 
-    std::vector<SPItem*> tmp;
-    for (std::vector<SPItem*>::const_iterator iter=all_list.begin();iter!=all_list.end();iter++) {
-        if(!SP_IS_GROUP(*iter)){
+    std::vector<SPItem *> tmp;
+    for (std::vector<SPItem *>::const_iterator iter = all_list.begin(); iter != all_list.end(); iter++) {
+        if (!SP_IS_GROUP(*iter)) {
             tmp.push_back(*iter);
         }
     }
-    all_list=tmp;
+    all_list = tmp;
 
-    for (std::vector<SPItem*>::const_iterator sel_iter=items.begin();sel_iter!=items.end();sel_iter++) {
+    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;
+        std::vector<SPItem *> matches = all_list;
         if (fill && stroke && style) {
             matches = sp_get_same_style(sel, matches);
-        }
-        else if (fill) {
+        } else if (fill) {
             matches = sp_get_same_style(sel, matches, SP_FILL_COLOR);
-        }
-        else if (stroke) {
+        } else if (stroke) {
             matches = sp_get_same_style(sel, matches, SP_STROKE_COLOR);
-        }
-        else if (style) {
-            matches = sp_get_same_style(sel, matches,SP_STROKE_STYLE_ALL);
-        }
-        all_matches.insert(all_matches.end(), matches.begin(),matches.end());
+        } else if (style) {
+            matches = sp_get_same_style(sel, matches, SP_STROKE_STYLE_ALL);
+        }
+        all_matches.insert(all_matches.end(), matches.begin(), matches.end());
     }
 
     selection->clear();
     selection->setList(all_matches);
-
 }
 
 
@@ -1902,14 +1932,15 @@
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
     bool ingroups = TRUE;
-    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;
+    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();
 
-    std::vector<SPItem*> items=selection->itemList();
-    for (std::vector<SPItem*>::const_iterator sel_iter=items.begin();sel_iter!=items.end();sel_iter++) {
+    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);
@@ -1920,7 +1951,6 @@
 
     selection->clear();
     selection->setList(matches);
-
 }
 
 
@@ -1929,14 +1959,15 @@
  * Find all items in src list that have the same fill or stroke style as sel
  * Return the list of matching items
  */
-std::vector<SPItem*> sp_get_same_fill_or_stroke_color(SPItem *sel, std::vector<SPItem*> &src, SPSelectStrokeStyleType type)
+std::vector<SPItem *> sp_get_same_fill_or_stroke_color(SPItem *sel, std::vector<SPItem *> &src,
+                                                       SPSelectStrokeStyleType type)
 {
-    std::vector<SPItem*> matches ;
+    std::vector<SPItem *> matches;
     gboolean match = false;
 
     SPIPaint *sel_paint = (type == SP_FILL_COLOR) ? &(sel->style->fill) : &(sel->style->stroke);
 
-    for (std::vector<SPItem*>::const_reverse_iterator i=src.rbegin();i!=src.rend();i++) {
+    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);
@@ -1952,10 +1983,11 @@
                     (type == SP_FILL_COLOR) ? iter->style->getFillPaintServer() : iter->style->getStrokePaintServer();
 
                 if ((dynamic_cast<SPLinearGradient *>(sel_server) || dynamic_cast<SPRadialGradient *>(sel_server) ||
-                     (dynamic_cast<SPGradient *>(sel_server) && dynamic_cast<SPGradient *>(sel_server)->getVector()->isSwatch()))
-                    &&
+                     (dynamic_cast<SPGradient *>(sel_server) &&
+                      dynamic_cast<SPGradient *>(sel_server)->getVector()->isSwatch())) &&
                     (dynamic_cast<SPLinearGradient *>(iter_server) || dynamic_cast<SPRadialGradient *>(iter_server) ||
-                     (dynamic_cast<SPGradient *>(iter_server) && dynamic_cast<SPGradient *>(iter_server)->getVector()->isSwatch()))) {
+                     (dynamic_cast<SPGradient *>(iter_server) &&
+                      dynamic_cast<SPGradient *>(iter_server)->getVector()->isSwatch()))) {
                     SPGradient *sel_vector = dynamic_cast<SPGradient *>(sel_server)->getVector();
                     SPGradient *iter_vector = dynamic_cast<SPGradient *>(iter_server)->getVector();
                     if (sel_vector == iter_vector) {
@@ -1986,16 +2018,16 @@
     return matches;
 }
 
-static bool item_type_match (SPItem *i, SPItem *j)
+static bool item_type_match(SPItem *i, SPItem *j)
 {
-    if ( dynamic_cast<SPRect *>(i)) {
-        return ( dynamic_cast<SPRect *>(j) );
+    if (dynamic_cast<SPRect *>(i)) {
+        return (dynamic_cast<SPRect *>(j));
 
     } else if (dynamic_cast<SPGenericEllipse *>(i)) {
         return (dynamic_cast<SPGenericEllipse *>(j));
 
     } else if (dynamic_cast<SPStar *>(i) || dynamic_cast<SPPolygon *>(i)) {
-        return (dynamic_cast<SPStar *>(j) || dynamic_cast<SPPolygon *>(j)) ;
+        return (dynamic_cast<SPStar *>(j) || dynamic_cast<SPPolygon *>(j));
 
     } else if (dynamic_cast<SPSpiral *>(i)) {
         return (dynamic_cast<SPSpiral *>(j));
@@ -2003,21 +2035,22 @@
     } else if (dynamic_cast<SPPath *>(i) || dynamic_cast<SPLine *>(i) || dynamic_cast<SPPolyLine *>(i)) {
         return (dynamic_cast<SPPath *>(j) || dynamic_cast<SPLine *>(j) || dynamic_cast<SPPolyLine *>(j));
 
-    } else if (dynamic_cast<SPText *>(i) || dynamic_cast<SPFlowtext *>(i) || dynamic_cast<SPTSpan *>(i) || dynamic_cast<SPTRef *>(i) || dynamic_cast<SPString *>(i)) {
-        return (dynamic_cast<SPText *>(j) || dynamic_cast<SPFlowtext *>(j) || dynamic_cast<SPTSpan *>(j) || dynamic_cast<SPTRef *>(j) || dynamic_cast<SPString *>(j));
+    } else if (dynamic_cast<SPText *>(i) || dynamic_cast<SPFlowtext *>(i) || dynamic_cast<SPTSpan *>(i) ||
+               dynamic_cast<SPTRef *>(i) || dynamic_cast<SPString *>(i)) {
+        return (dynamic_cast<SPText *>(j) || dynamic_cast<SPFlowtext *>(j) || dynamic_cast<SPTSpan *>(j) ||
+                dynamic_cast<SPTRef *>(j) || dynamic_cast<SPString *>(j));
 
-    }  else if (dynamic_cast<SPUse *>(i)) {
-        return (dynamic_cast<SPUse *>(j)) ;
+    } else if (dynamic_cast<SPUse *>(i)) {
+        return (dynamic_cast<SPUse *>(j));
 
     } else if (dynamic_cast<SPImage *>(i)) {
         return (dynamic_cast<SPImage *>(j));
 
-    } else if (dynamic_cast<SPOffset *>(i) && dynamic_cast<SPOffset *>(i)->sourceHref) {   // Linked offset
+    } else if (dynamic_cast<SPOffset *>(i) && dynamic_cast<SPOffset *>(i)->sourceHref) { // Linked offset
         return (dynamic_cast<SPOffset *>(j) && dynamic_cast<SPOffset *>(j)->sourceHref);
 
-    }  else if (dynamic_cast<SPOffset *>(i) && !dynamic_cast<SPOffset *>(i)->sourceHref) { // Dynamic offset
+    } else if (dynamic_cast<SPOffset *>(i) && !dynamic_cast<SPOffset *>(i)->sourceHref) { // Dynamic offset
         return (dynamic_cast<SPOffset *>(j) && !dynamic_cast<SPOffset *>(j)->sourceHref);
-
     }
 
     return false;
@@ -2027,11 +2060,11 @@
  * Find all items in src list that have the same object type as sel by type
  * Return the list of matching items
  */
-std::vector<SPItem*> sp_get_same_object_type(SPItem *sel, std::vector<SPItem*> &src)
+std::vector<SPItem *> sp_get_same_object_type(SPItem *sel, std::vector<SPItem *> &src)
 {
-    std::vector<SPItem*> matches;
+    std::vector<SPItem *> matches;
 
-    for (std::vector<SPItem*>::const_reverse_iterator i=src.rbegin();i!=src.rend();i++) {
+    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.push_back(item);
@@ -2046,9 +2079,9 @@
  * Find all items in src list that have the same stroke style as sel by type
  * Return the list of matching items
  */
-std::vector<SPItem*> sp_get_same_style(SPItem *sel, std::vector<SPItem*> &src, SPSelectStrokeStyleType type)
+std::vector<SPItem *> sp_get_same_style(SPItem *sel, std::vector<SPItem *> &src, SPSelectStrokeStyleType type)
 {
-    std::vector<SPItem*> matches;
+    std::vector<SPItem *> matches;
     bool match = false;
 
     SPStyle *sel_style = sel->style;
@@ -2064,28 +2097,28 @@
      * Stroke width needs to handle transformations, so call this function
      * to get the transformed stroke width
      */
-    std::vector<SPItem*> objects;
+    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 ) {
+    if (type == SP_STROKE_STYLE_WIDTH || type == SP_STROKE_STYLE_ALL || type == SP_STYLE_ALL) {
         objects.push_back(sel);
         sel_style_for_width = new SPStyle(SP_ACTIVE_DOCUMENT);
-        objects_query_strokewidth (objects, sel_style_for_width);
+        objects_query_strokewidth(objects, sel_style_for_width);
     }
     bool match_g;
-    for (std::vector<SPItem*>::const_iterator i=src.begin();i!=src.end();i++) {
+    for (std::vector<SPItem *>::const_iterator i = src.begin(); i != src.end(); i++) {
         SPItem *iter = *i;
         if (iter) {
-            match_g=true;
+            match_g = true;
             SPStyle *iter_style = iter->style;
             match = true;
 
-            if (type == SP_STROKE_STYLE_WIDTH|| type == SP_STROKE_STYLE_ALL|| type==SP_STYLE_ALL) {
+            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) {
-                    std::vector<SPItem*> objects;
-                    objects.insert(objects.begin(),iter);
+                    std::vector<SPItem *> objects;
+                    objects.insert(objects.begin(), iter);
                     SPStyle tmp_style(SP_ACTIVE_DOCUMENT);
-                    objects_query_strokewidth (objects, &tmp_style);
+                    objects_query_strokewidth(objects, &tmp_style);
 
                     if (sel_style_for_width) {
                         match = (sel_style_for_width->stroke_width.computed == tmp_style.stroke_width.computed);
@@ -2093,16 +2126,16 @@
                 }
             }
             match_g = match_g && match;
-            if (type == SP_STROKE_STYLE_DASHES|| type == SP_STROKE_STYLE_ALL || type==SP_STYLE_ALL) {
+            if (type == SP_STROKE_STYLE_DASHES || type == SP_STROKE_STYLE_ALL || type == SP_STYLE_ALL) {
                 match = (sel_style->stroke_dasharray.set == iter_style->stroke_dasharray.set);
                 if (sel_style->stroke_dasharray.set && iter_style->stroke_dasharray.set) {
                     match = (sel_style->stroke_dasharray.values == iter_style->stroke_dasharray.values);
                 }
             }
             match_g = match_g && match;
-            if (type == SP_STROKE_STYLE_MARKERS|| type == SP_STROKE_STYLE_ALL|| type==SP_STYLE_ALL) {
+            if (type == SP_STROKE_STYLE_MARKERS || type == SP_STROKE_STYLE_ALL || type == SP_STYLE_ALL) {
                 match = true;
-                int len = sizeof(sel_style->marker)/sizeof(SPIString);
+                int len = sizeof(sel_style->marker) / sizeof(SPIString);
                 for (int i = 0; i < len; i++) {
                     match = (sel_style->marker_ptrs[i]->set == iter_style->marker_ptrs[i]->set);
                     if (sel_style->marker_ptrs[i]->set && iter_style->marker_ptrs[i]->set &&
@@ -2112,24 +2145,25 @@
                     }
                 }
             }
-			match_g = match_g && match;
+            match_g = match_g && match;
             if (match_g) {
-                while (iter->cloned) iter=dynamic_cast<SPItem *>(iter->parent);
-                matches.insert(matches.begin(),iter);
+                while (iter->cloned)
+                    iter = dynamic_cast<SPItem *>(iter->parent);
+                matches.insert(matches.begin(), iter);
             }
         } else {
             g_assert_not_reached();
         }
     }
 
-    if( sel_style_for_width != NULL ) delete sel_style_for_width;
+    if (sel_style_for_width != NULL)
+        delete sel_style_for_width;
     return matches;
 }
 
 // helper function:
-static
-Geom::Point
-cornerFarthestFrom(Geom::Rect const &r, Geom::Point const &p){
+static Geom::Point cornerFarthestFrom(Geom::Rect const &r, Geom::Point const &p)
+{
     Geom::Point m = r.midpoint();
     unsigned i = 0;
     if (p[X] < m[X]) {
@@ -2142,10 +2176,10 @@
 }
 
 /**
-\param  angle   the angle in "angular pixels", i.e. how many visible pixels must move the outermost point of the rotated object
+\param  angle   the angle in "angular pixels", i.e. how many visible pixels must move the outermost point of the rotated
+object
 */
-void
-sp_selection_rotate_screen(Inkscape::Selection *selection, gdouble angle)
+void sp_selection_rotate_screen(Inkscape::Selection *selection, gdouble angle)
 {
     if (selection->isEmpty())
         return;
@@ -2153,7 +2187,7 @@
     Geom::OptRect bbox = selection->visualBounds();
     boost::optional<Geom::Point> center = selection->center();
 
-    if ( !bbox || !center ) {
+    if (!bbox || !center) {
         return;
     }
 
@@ -2166,15 +2200,11 @@
     sp_selection_rotate_relative(selection, *center, zangle);
 
     DocumentUndo::maybeDone(selection->desktop()->getDocument(),
-                            ( (angle > 0)
-                              ? "selector:rotate:ccw"
-                              : "selector:rotate:cw" ),
-                            SP_VERB_CONTEXT_SELECT,
+                            ((angle > 0) ? "selector:rotate:ccw" : "selector:rotate:cw"), SP_VERB_CONTEXT_SELECT,
                             _("Rotate by pixels"));
 }
 
-void
-sp_selection_scale(Inkscape::Selection *selection, gdouble grow)
+void sp_selection_scale(Inkscape::Selection *selection, gdouble grow)
 {
     if (selection->isEmpty())
         return;
@@ -2188,7 +2218,7 @@
 
     // you can't scale "do nizhe pola" (below zero)
     double const max_len = bbox->maxExtent();
-    if ( max_len + grow <= 1e-3 ) {
+    if (max_len + grow <= 1e-3) {
         return;
     }
 
@@ -2196,22 +2226,16 @@
     sp_selection_scale_relative(selection, center, Geom::Scale(times, times));
 
     DocumentUndo::maybeDone(selection->desktop()->getDocument(),
-                            ( (grow > 0)
-                              ? "selector:scale:larger"
-                              : "selector:scale:smaller" ),
-                            SP_VERB_CONTEXT_SELECT,
+                            ((grow > 0) ? "selector:scale:larger" : "selector:scale:smaller"), SP_VERB_CONTEXT_SELECT,
                             _("Scale"));
 }
 
-void
-sp_selection_scale_screen(Inkscape::Selection *selection, gdouble grow_pixels)
+void sp_selection_scale_screen(Inkscape::Selection *selection, gdouble grow_pixels)
 {
-    sp_selection_scale(selection,
-                       grow_pixels / selection->desktop()->current_zoom());
+    sp_selection_scale(selection, grow_pixels / selection->desktop()->current_zoom());
 }
 
-void
-sp_selection_scale_times(Inkscape::Selection *selection, gdouble times)
+void sp_selection_scale_times(Inkscape::Selection *selection, gdouble times)
 {
     if (selection->isEmpty())
         return;
@@ -2224,12 +2248,10 @@
 
     Geom::Point const center(sel_bbox->midpoint());
     sp_selection_scale_relative(selection, center, Geom::Scale(times, times));
-    DocumentUndo::done(selection->desktop()->getDocument(), SP_VERB_CONTEXT_SELECT,
-                       _("Scale by whole factor"));
+    DocumentUndo::done(selection->desktop()->getDocument(), SP_VERB_CONTEXT_SELECT, _("Scale by whole factor"));
 }
 
-void
-sp_selection_move(Inkscape::Selection *selection, gdouble dx, gdouble dy)
+void sp_selection_move(Inkscape::Selection *selection, gdouble dx, gdouble dy)
 {
     if (selection->isEmpty()) {
         return;
@@ -2239,19 +2261,15 @@
 
     SPDocument *doc = selection->layers()->getDocument();
     if (dx == 0) {
-        DocumentUndo::maybeDone(doc, "selector:move:vertical", SP_VERB_CONTEXT_SELECT,
-                                _("Move vertically"));
+        DocumentUndo::maybeDone(doc, "selector:move:vertical", SP_VERB_CONTEXT_SELECT, _("Move vertically"));
     } else if (dy == 0) {
-        DocumentUndo::maybeDone(doc, "selector:move:horizontal", SP_VERB_CONTEXT_SELECT,
-                                _("Move horizontally"));
+        DocumentUndo::maybeDone(doc, "selector:move:horizontal", SP_VERB_CONTEXT_SELECT, _("Move horizontally"));
     } else {
-        DocumentUndo::done(doc, SP_VERB_CONTEXT_SELECT,
-                           _("Move"));
+        DocumentUndo::done(doc, SP_VERB_CONTEXT_SELECT, _("Move"));
     }
 }
 
-void
-sp_selection_move_screen(Inkscape::Selection *selection, gdouble dx, gdouble dy)
+void sp_selection_move_screen(Inkscape::Selection *selection, gdouble dx, gdouble dy)
 {
     if (selection->isEmpty() || !selection->desktop()) {
         return;
@@ -2265,14 +2283,12 @@
 
     SPDocument *doc = selection->layers()->getDocument();
     if (dx == 0) {
-        DocumentUndo::maybeDone(doc, "selector:move:vertical", SP_VERB_CONTEXT_SELECT,
-                                _("Move vertically by pixels"));
+        DocumentUndo::maybeDone(doc, "selector:move:vertical", SP_VERB_CONTEXT_SELECT, _("Move vertically by pixels"));
     } else if (dy == 0) {
         DocumentUndo::maybeDone(doc, "selector:move:horizontal", SP_VERB_CONTEXT_SELECT,
                                 _("Move horizontally by pixels"));
     } else {
-        DocumentUndo::done(doc, SP_VERB_CONTEXT_SELECT,
-                           _("Move"));
+        DocumentUndo::done(doc, SP_VERB_CONTEXT_SELECT, _("Move"));
     }
 }
 
@@ -2292,25 +2308,18 @@
 typedef struct ListReverse {
     typedef GSList *Iterator;
 
-    static Iterator children(SPObject *o) {
-        return make_list(o->firstChild(), NULL);
-    }
-    static Iterator siblings_after(SPObject *o) {
-        return make_list(o->parent->firstChild(), o);
-    }
-    static void dispose(Iterator i) {
-        g_slist_free(i);
-    }
+    static Iterator children(SPObject *o) { return make_list(o->firstChild(), NULL); }
+    static Iterator siblings_after(SPObject *o) { return make_list(o->parent->firstChild(), o); }
+    static void dispose(Iterator i) { g_slist_free(i); }
 
-    static SPObject *object(Iterator i) {
-        return reinterpret_cast<SPObject *>(i->data);
-    }
+    static SPObject *object(Iterator i) { return reinterpret_cast<SPObject *>(i->data); }
     static Iterator next(Iterator i) { return i->next; }
 
-private:
-    static GSList *make_list(SPObject *object, SPObject *limit) {
+  private:
+    static GSList *make_list(SPObject *object, SPObject *limit)
+    {
         GSList *list = NULL;
-        while ( object != limit ) {
+        while (object != limit) {
             if (!object) { // TODO check if this happens in practice
                 g_warning("Unexpected list overrun");
                 break;
@@ -2325,16 +2334,16 @@
 
 
 template <typename D>
-SPItem *next_item(SPDesktop *desktop, GSList *path, SPObject *root,
-                  bool only_in_viewport, PrefsSelectionContext inlayer, bool onlyvisible, bool onlysensitive)
+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;
+    SPItem *found = NULL;
 
     if (path) {
-        SPObject *object=reinterpret_cast<SPObject *>(path->data);
+        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);
@@ -2344,20 +2353,17 @@
         iter = children = D::children(root);
     }
 
-    while ( iter && !found ) {
-        SPObject *object=D::object(iter);
+    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) )
-            {
+            if (item && (!only_in_viewport || desktop->isWithinViewport(item)) &&
+                (!onlyvisible || !desktop->itemIsHidden(item)) && (!onlysensitive || !item->isLocked()) &&
+                !desktop->isLayer(item)) {
                 found = item;
             }
         }
@@ -2371,22 +2377,20 @@
 
 
 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)
+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++) {
+    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) ) )
-        {
+        if (root->isAncestorOf(item) && (!only_in_viewport || desktop->isWithinViewport(item))) {
             current = item;
             break;
         }
     }
 
-    GSList *path=NULL;
-    while ( current != root ) {
+    GSList *path = NULL;
+    while (current != root) {
         path = g_slist_prepend(path, current);
         current = current->parent;
     }
@@ -2403,14 +2407,14 @@
     return next;
 }
 
-void
-sp_selection_item_next(SPDesktop *desktop)
+void sp_selection_item_next(SPDesktop *desktop)
 {
     g_return_if_fail(desktop != NULL);
     Inkscape::Selection *selection = desktop->getSelection();
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    PrefsSelectionContext inlayer = (PrefsSelectionContext)prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);
+    PrefsSelectionContext inlayer =
+        (PrefsSelectionContext)prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
 
@@ -2421,18 +2425,18 @@
         root = desktop->currentRoot();
     }
 
-    SPItem *item=next_item_from_list<Forward>(desktop, selection->itemList(), root, SP_CYCLING == SP_CYCLE_VISIBLE, inlayer, onlyvisible, onlysensitive);
+    SPItem *item = next_item_from_list<Forward>(desktop, selection->itemList(), root, SP_CYCLING == SP_CYCLE_VISIBLE,
+                                                inlayer, onlyvisible, onlysensitive);
 
     if (item) {
         selection->set(item, PREFS_SELECTION_LAYER_RECURSIVE == inlayer);
-        if ( SP_CYCLING == SP_CYCLE_FOCUS ) {
+        if (SP_CYCLING == SP_CYCLE_FOCUS) {
             scroll_to_show_item(desktop, item);
         }
     }
 }
 
-void
-sp_selection_item_prev(SPDesktop *desktop)
+void sp_selection_item_prev(SPDesktop *desktop)
 {
     SPDocument *document = desktop->getDocument();
     g_return_if_fail(document != NULL);
@@ -2440,7 +2444,8 @@
     Inkscape::Selection *selection = desktop->getSelection();
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    PrefsSelectionContext inlayer = (PrefsSelectionContext) prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);
+    PrefsSelectionContext inlayer =
+        (PrefsSelectionContext)prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);
     bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);
     bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);
 
@@ -2451,24 +2456,26 @@
         root = desktop->currentRoot();
     }
 
-    SPItem *item=next_item_from_list<ListReverse>(desktop, selection->itemList(), root, SP_CYCLING == SP_CYCLE_VISIBLE, inlayer, onlyvisible, onlysensitive);
+    SPItem *item = next_item_from_list<ListReverse>(
+        desktop, selection->itemList(), root, SP_CYCLING == SP_CYCLE_VISIBLE, inlayer, onlyvisible, onlysensitive);
 
     if (item) {
         selection->set(item, PREFS_SELECTION_LAYER_RECURSIVE == inlayer);
-        if ( SP_CYCLING == SP_CYCLE_FOCUS ) {
+        if (SP_CYCLING == SP_CYCLE_FOCUS) {
             scroll_to_show_item(desktop, item);
         }
     }
 }
 
-void sp_selection_next_patheffect_param(SPDesktop * dt)
+void sp_selection_next_patheffect_param(SPDesktop *dt)
 {
-    if (!dt) return;
+    if (!dt)
+        return;
 
     Inkscape::Selection *selection = dt->getSelection();
-    if ( selection && !selection->isEmpty() ) {
+    if (selection && !selection->isEmpty()) {
         SPItem *item = selection->singleItem();
-        if ( SPLPEItem *lpeitem = dynamic_cast<SPLPEItem*>(item) ) {
+        if (SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item)) {
             if (lpeitem->hasPathEffect()) {
                 lpeitem->editNextParamOncanvas(dt);
             } else {
@@ -2528,8 +2535,6 @@
 
 
 
-
-
 /**
  * If \a item is not entirely visible then adjust visible area to centre on the centre on of
  * \a item.
@@ -2539,14 +2544,14 @@
     Geom::Rect dbox = desktop->get_display_area();
     Geom::OptRect sbox = item->desktopVisualBounds();
 
-    if ( sbox && dbox.contains(*sbox) == false ) {
+    if (sbox && dbox.contains(*sbox) == false) {
         Geom::Point const s_dt = sbox->midpoint();
         Geom::Point const s_w = desktop->d2w(s_dt);
         Geom::Point const d_dt = dbox.midpoint();
         Geom::Point const d_w = desktop->d2w(d_dt);
-        Geom::Point const moved_w( d_w - s_w );
-        gint const dx = (gint) moved_w[X];
-        gint const dy = (gint) moved_w[Y];
+        Geom::Point const moved_w(d_w - s_w);
+        gint const dx = (gint)moved_w[X];
+        gint const dy = (gint)moved_w[Y];
         desktop->scroll_world(dx, dy);
     }
 }
@@ -2568,17 +2573,17 @@
         return;
     }
 
-    std::vector<Inkscape::XML::Node*> reprs (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
-    sort(reprs.begin(),reprs.end(),sp_repr_compare_position_bool);
-
-    std::vector<Inkscape::XML::Node*> newsel;
-
-    for(std::vector<Inkscape::XML::Node*>::const_iterator i=reprs.begin();i!=reprs.end();i++){
-    	Inkscape::XML::Node *sel_repr = *i;
+    sort(reprs.begin(), reprs.end(), sp_repr_compare_position_bool);
+
+    std::vector<Inkscape::XML::Node *> newsel;
+
+    for (std::vector<Inkscape::XML::Node *>::const_iterator i = reprs.begin(); i != reprs.end(); i++) {
+        Inkscape::XML::Node *sel_repr = *i;
         Inkscape::XML::Node *parent = sel_repr->parent();
 
         Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
@@ -2598,14 +2603,12 @@
         Inkscape::GC::release(clone);
     }
 
-    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_CLONE,
-                       C_("Action", "Clone"));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_CLONE, C_("Action", "Clone"));
 
     selection->setReprList(newsel);
 }
 
-void
-sp_selection_relink(SPDesktop *desktop)
+void sp_selection_relink(SPDesktop *desktop)
 {
     if (!desktop)
         return;
@@ -2620,15 +2623,16 @@
     Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
     const gchar *newid = cm->getFirstObjectID();
     if (!newid) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Copy an <b>object</b> to clipboard to relink clones to."));
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                       _("Copy an <b>object</b> to clipboard to relink clones to."));
         return;
     }
     gchar *newref = g_strdup_printf("#%s", newid);
 
     // Get a copy of current selection.
     bool relinked = false;
-    std::vector<SPItem*> items=selection->itemList();
-    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+    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)) {
@@ -2643,14 +2647,12 @@
     if (!relinked) {
         desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No clones to relink</b> in the selection."));
     } else {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_UNLINK_CLONE,
-                           _("Relink clone"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_UNLINK_CLONE, _("Relink clone"));
     }
 }
 
 
-void
-sp_selection_unlink(SPDesktop *desktop)
+void sp_selection_unlink(SPDesktop *desktop)
 {
     if (!desktop)
         return;
@@ -2663,10 +2665,10 @@
     }
 
     // Get a copy of current selection.
-    std::vector<SPItem*> new_select;
+    std::vector<SPItem *> new_select;
     bool unlinked = false;
-    std::vector<SPItem*> items=selection->itemList();
-    for (std::vector<SPItem*>::const_reverse_iterator i=items.rbegin();i!=items.rend();i++){
+    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)) {
@@ -2714,12 +2716,10 @@
         desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No clones to unlink</b> in the selection."));
     }
 
-    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_UNLINK_CLONE,
-                       _("Unlink clone"));
+    DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_UNLINK_CLONE, _("Unlink clone"));
 }
 
-void
-sp_select_clone_original(SPDesktop *desktop)
+void sp_select_clone_original(SPDesktop *desktop)
 {
     if (desktop == NULL)
         return;
@@ -2728,11 +2728,13 @@
 
     SPItem *item = selection->singleItem();
 
-    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.");
+    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
 
-    std::vector<SPItem*> items=selection->itemList();
+    std::vector<SPItem *> items = selection->itemList();
     if (items.size() != 1 || !item) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, error);
         return;
@@ -2759,10 +2761,12 @@
                     SPLPEItem *lpeItem = dynamic_cast<SPLPEItem *>(item);
                     if (lpeItem) {
                         // check if the applied LPE is Clone original, if so, go to the refered path
-                        Inkscape::LivePathEffect::Effect* lpe = lpeItem->getPathEffectOfType(Inkscape::LivePathEffect::CLONE_ORIGINAL);
+                        Inkscape::LivePathEffect::Effect *lpe =
+                            lpeItem->getPathEffectOfType(Inkscape::LivePathEffect::CLONE_ORIGINAL);
                         if (lpe) {
                             Inkscape::LivePathEffect::Parameter *lpeparam = lpe->getParameter("linkedpath");
-                            if (Inkscape::LivePathEffect::OriginalPathParam *pathparam = dynamic_cast<Inkscape::LivePathEffect::OriginalPathParam *>(lpeparam)) {
+                            if (Inkscape::LivePathEffect::OriginalPathParam *pathparam =
+                                    dynamic_cast<Inkscape::LivePathEffect::OriginalPathParam *>(lpeparam)) {
                                 original = pathparam->getObject();
                             }
                         }
@@ -2778,13 +2782,17 @@
     }
 
     if (!original) {
-        desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>Cannot find</b> the object to select (orphaned clone, offset, textpath, flowed text?)"));
+        desktop->messageStack()->flash(
+            Inkscape::ERROR_MESSAGE,
+            _("<b>Cannot find</b> the object to select (orphaned clone, offset, textpath, flowed text?)"));
         return;
     }
 
     for (SPObject *o = original; o && !dynamic_cast<SPRoot *>(o); o = o->parent) {
         if (dynamic_cast<SPDefs *>(o)) {
-            desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("The object you're trying to select is <b>not visible</b> (it is in &lt;defs&gt;)"));
+            desktop->messageStack()->flash(
+                Inkscape::ERROR_MESSAGE,
+                _("The object you're trying to select is <b>not visible</b> (it is in &lt;defs&gt;)"));
             return;
         }
     }
@@ -2795,14 +2803,15 @@
         if (highlight) {
             Geom::OptRect a = item->desktopVisualBounds();
             Geom::OptRect b = original->desktopVisualBounds();
-            if ( a && b ) {
+            if (a && b) {
                 // draw a flashing line between the objects
                 SPCurve *curve = new SPCurve();
                 curve->moveto(a->midpoint());
                 curve->lineto(b->midpoint());
 
-                SPCanvasItem * canvasitem = sp_canvas_bpath_new(desktop->getTempGroup(), curve);
-                sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), 0x0000ddff, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT, 5, 3);
+                SPCanvasItem *canvasitem = sp_canvas_bpath_new(desktop->getTempGroup(), curve);
+                sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), 0x0000ddff, 1.0, SP_STROKE_LINEJOIN_MITER,
+                                           SP_STROKE_LINECAP_BUTT, 5, 3);
                 sp_canvas_item_show(canvasitem);
                 curve->unref();
                 desktop->add_temporary_canvasitem(canvasitem, 1000);
@@ -2829,9 +2838,9 @@
     Inkscape::Selection *selection = desktop->getSelection();
 
     Inkscape::SVGOStringStream os;
-    SPObject * firstItem = NULL;
-    std::vector<SPItem*> items=selection->itemList();
-    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+    SPObject *firstItem = NULL;
+    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 << "|";
@@ -2850,7 +2859,8 @@
         {
             lpe_repr->setAttribute("effect", "fill_between_many");
             lpe_repr->setAttribute("linkedpaths", os.str());
-            desktop->doc()->getDefs()->getRepr()->addChild(lpe_repr, NULL); // adds to <defs> and assigns the 'id' attribute
+            desktop->doc()->getDefs()->getRepr()->addChild(lpe_repr,
+                                                           NULL); // adds to <defs> and assigns the 'id' attribute
         }
         std::string lpe_id_href = std::string("#") + lpe_repr->attribute("id");
         Inkscape::GC::release(lpe_repr);
@@ -2899,25 +2909,25 @@
     doc->ensureUpToDate();
     Geom::OptRect r = selection->visualBounds();
     boost::optional<Geom::Point> c = selection->center();
-    if ( !r || !c ) {
+    if (!r || !c) {
         return;
     }
 
     // FIXME: Inverted Y coodinate
-    Geom::Point doc_height( 0, doc->getHeight().value("px"));
+    Geom::Point doc_height(0, doc->getHeight().value("px"));
 
     // calculate the transform to be applied to objects to move them to 0,0
-    Geom::Point corner( r->min()[Geom::X], r->max()[Geom::Y] ); // FIXME: Inverted Y coodinate  
+    Geom::Point corner(r->min()[Geom::X], r->max()[Geom::Y]); // FIXME: Inverted Y coodinate
     Geom::Point move_p = doc_height - corner;
     move_p[Geom::Y] = -move_p[Geom::Y];
     Geom::Affine move = Geom::Affine(Geom::Translate(move_p));
 
-    Geom::Point center( *c - corner ); // As defined by rotation center
+    Geom::Point center(*c - corner); // As defined by rotation center
     center[Geom::Y] = -center[Geom::Y];
 
-    std::vector<SPItem*> items(selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
 
-    //items = g_slist_sort(items, (GCompareFunc) sp_object_compare_position);  // Why needed?
+    // items = g_slist_sort(items, (GCompareFunc) sp_object_compare_position);  // Why needed?
 
     // bottommost object, after sorting
     SPObject *parent = items[0]->parent;
@@ -2933,8 +2943,8 @@
     }
 
     // Create a list of duplicates, to be pasted inside marker element.
-    std::vector<Inkscape::XML::Node*> repr_copies;
-    for (std::vector<SPItem*>::const_reverse_iterator i=items.rbegin();i!=items.rend();i++){
+    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);
     }
@@ -2944,7 +2954,7 @@
     if (apply) {
         // Delete objects so that their clones don't get alerted;
         // the objects will be restored inside the marker element.
-        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        for (std::vector<SPItem *>::const_iterator i = items.begin(); i != items.end(); i++) {
             SPObject *item = *i;
             item->deleteObject(false);
         }
@@ -2965,15 +2975,15 @@
 
 
 
-    DocumentUndo::done(doc, SP_VERB_EDIT_SELECTION_2_MARKER,
-                       _("Objects to marker"));
+    DocumentUndo::done(doc, SP_VERB_EDIT_SELECTION_2_MARKER, _("Objects to marker"));
 }
 
-static void sp_selection_to_guides_recursive(SPItem *item, bool wholegroups) {
+static void sp_selection_to_guides_recursive(SPItem *item, bool wholegroups)
+{
     SPGroup *group = dynamic_cast<SPGroup *>(item);
     if (group && !dynamic_cast<SPBox3D *>(item) && !wholegroups) {
-        std::vector<SPItem*> items=sp_item_group_item_list(group);
-        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        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 {
@@ -2989,7 +2999,7 @@
     SPDocument *doc = desktop->getDocument();
     Inkscape::Selection *selection = desktop->getSelection();
     // we need to copy the list because it gets reset when objects are deleted
-    std::vector<SPItem*> items(selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
 
     if (items.empty()) {
         desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to convert to guides."));
@@ -3004,7 +3014,7 @@
     // and its entry in the selection list is invalid (crash).
     // Therefore: first convert all, then delete all.
 
-    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+    for (std::vector<SPItem *>::const_iterator i = items.begin(); i != items.end(); i++) {
         sp_selection_to_guides_recursive(*i, wholegroups);
     }
 
@@ -3018,7 +3028,7 @@
 
 /*
  * Convert objects to <symbol>. How that happens depends on what is selected:
- * 
+ *
  * 1) A random selection of objects will be embedded into a single <symbol> element.
  *
  * 2) Except, a single <g> will have its content directly embedded into a <symbol>; the 'id' and
@@ -3036,7 +3046,7 @@
  *   For SVG2, set 'refX' 'refY' to object center (with compensating shift in <use>
  *   transformation).
  */
-void sp_selection_symbol(SPDesktop *desktop, bool /*apply*/ )
+void sp_selection_symbol(SPDesktop *desktop, bool /*apply*/)
 {
     if (desktop == NULL) {
         return;
@@ -3049,13 +3059,13 @@
 
     // Check if something is selected.
     if (selection->isEmpty()) {
-      desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>objects</b> to convert to symbol."));
-      return;
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>objects</b> to convert to symbol."));
+        return;
     }
 
     doc->ensureUpToDate();
 
-    std::vector<SPObject*> items(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 = items[0]->getRepr();
@@ -3065,16 +3075,16 @@
     bool single_group = false;
     SPGroup *the_group = NULL;
     Geom::Affine transform;
-    if( items.size() == 1 ) {
+    if (items.size() == 1) {
         SPObject *object = items[0];
         the_group = dynamic_cast<SPGroup *>(object);
-        if ( the_group ) {
+        if (the_group) {
             single_group = true;
 
-            if( !sp_svg_transform_read( object->getAttribute("transform"), &transform ))
+            if (!sp_svg_transform_read(object->getAttribute("transform"), &transform))
                 transform = Geom::identity();
 
-            if( transform.isTranslation() ) {
+            if (transform.isTranslation()) {
 
                 // Create new list from group children.
                 items = object->childList(false);
@@ -3083,7 +3093,8 @@
                 // without disturbing clones.
                 // See ActorAlign::on_button_click() in src/ui/dialog/align-and-distribute.cpp
                 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-                int saved_compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
+                int saved_compensation =
+                    prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
                 prefs->setInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
 
                 // Remove transform on group, updating clones.
@@ -3101,11 +3112,11 @@
     defsrepr->appendChild(symbol_repr);
 
     // For a single group, copy relevant attributes.
-    if( single_group ) {
+    if (single_group) {
 
-        symbol_repr->setAttribute("style",  the_group->getAttribute("style"));
-        symbol_repr->setAttribute("class",  the_group->getAttribute("class"));
-        symbol_repr->setAttribute("id",     the_group->getAttribute("id")   );
+        symbol_repr->setAttribute("style", the_group->getAttribute("style"));
+        symbol_repr->setAttribute("class", the_group->getAttribute("class"));
+        symbol_repr->setAttribute("id", the_group->getAttribute("id"));
 
         // This should eventually be replaced by 'refX' and 'refY' once SVG WG approves it.
         // It is done here for round-tripping
@@ -3118,30 +3129,29 @@
         Glib::ustring id = symbol_repr->attribute("id");
         id += "_transform";
         the_group->setAttribute("id", id);
-
     }
 
     // Move selected items to new <symbol>
-    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);
+    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);
     }
 
-    if( single_group && transform.isTranslation() ) {
+    if (single_group && transform.isTranslation()) {
         the_group->deleteObject(true);
     }
 
     // Create <use> pointing to new symbol (to replace the moved objects).
     Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
 
-    clone->setAttribute("xlink:href", Glib::ustring("#")+symbol_repr->attribute("id"), false);
+    clone->setAttribute("xlink:href", Glib::ustring("#") + symbol_repr->attribute("id"), false);
 
     the_parent_repr->appendChild(clone);
 
-    if( single_group && transform.isTranslation() ) {
-        if( !transform.isIdentity() )
-            clone->setAttribute("transform", sp_svg_transform_write( transform ));
+    if (single_group && transform.isTranslation()) {
+        if (!transform.isIdentity())
+            clone->setAttribute("transform", sp_svg_transform_write(transform));
     }
 
     // Change selection to new <use> element.
@@ -3173,12 +3183,13 @@
         return;
     }
 
-    SPObject* symbol = selection->single();
- 
+    SPObject *symbol = selection->single();
+
     // Make sure we have only one object in selection.
     // Require that we really have a <symbol>.
-    if( symbol == NULL || !dynamic_cast<SPSymbol *>( symbol ))  {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select only one <b>symbol</b> in Symbol dialog to convert to group."));
+    if (symbol == NULL || !dynamic_cast<SPSymbol *>(symbol)) {
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                       _("Select only one <b>symbol</b> in Symbol dialog to convert to group."));
         return;
     }
 
@@ -3189,36 +3200,33 @@
     desktop->currentLayer()->getRepr()->appendChild(group);
 
     // Move all children of symbol to group
-    std::vector<SPObject*> 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( children.size() == 1 ) {
+    if (children.size() == 1) {
         SPObject *object = children[0];
-        if ( dynamic_cast<SPGroup *>( object ) ) {
-            if( object->getAttribute("style") == NULL ||
-                object->getAttribute("class") == NULL ) {
+        if (dynamic_cast<SPGroup *>(object)) {
+            if (object->getAttribute("style") == NULL || object->getAttribute("class") == NULL) {
 
                 group->setAttribute("transform", object->getAttribute("transform"));
                 children = object->childList(false);
             }
         }
     }
-        
-    for (std::vector<SPObject*>::const_reverse_iterator i=children.rbegin();i!=children.rend();i++){
+
+    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);
+        group->addChild(repr, NULL);
     }
 
     // Copy relevant attributes
     group->setAttribute("style", symbol->getAttribute("style"));
     group->setAttribute("class", symbol->getAttribute("class"));
-    group->setAttribute("inkscape:transform-center-x",
-                        symbol->getAttribute("inkscape:transform-center-x"));
-    group->setAttribute("inkscape:transform-center-y",
-                        symbol->getAttribute("inkscape:transform-center-y"));
+    group->setAttribute("inkscape:transform-center-x", symbol->getAttribute("inkscape:transform-center-x"));
+    group->setAttribute("inkscape:transform-center-y", symbol->getAttribute("inkscape:transform-center-y"));
 
 
     // Need to delete <symbol>; all <use> elements that referenced <symbol> should
@@ -3237,8 +3245,7 @@
     DocumentUndo::done(doc, SP_VERB_EDIT_UNSYMBOL, _("Group from symbol"));
 }
 
-void
-sp_selection_tile(SPDesktop *desktop, bool apply)
+void sp_selection_tile(SPDesktop *desktop, bool apply)
 {
     // sp_selection_to_marker has similar code
     if (desktop == NULL) {
@@ -3258,22 +3265,23 @@
 
     doc->ensureUpToDate();
     Geom::OptRect r = selection->visualBounds();
-    if ( !r ) {
+    if (!r) {
         return;
     }
 
     // calculate the transform to be applied to objects to move them to 0,0
-    Geom::Point move_p = Geom::Point(0, doc->getHeight().value("px")) - (r->min() + Geom::Point(0, r->dimensions()[Geom::Y]));
+    Geom::Point move_p =
+        Geom::Point(0, doc->getHeight().value("px")) - (r->min() + Geom::Point(0, r->dimensions()[Geom::Y]));
     move_p[Geom::Y] = -move_p[Geom::Y];
     Geom::Affine move = Geom::Affine(Geom::Translate(move_p));
 
-    std::vector<SPItem*> items (selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
 
-    sort(items.begin(),items.end(),sp_object_compare_position_bool);
+    sort(items.begin(), items.end(), sp_object_compare_position_bool);
 
     // bottommost object, after sorting
     SPObject *parent = items[0]->parent;
-    
+
 
     Geom::Affine parent_transform;
     {
@@ -3289,8 +3297,8 @@
     gint pos = items[0]->getRepr()->position();
 
     // create a list of duplicates
-    std::vector<Inkscape::XML::Node*> repr_copies;
-    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+    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);
     }
@@ -3299,7 +3307,7 @@
 
     if (apply) {
         // delete objects so that their clones don't get alerted; this object will be restored shortly
-        for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+        for (std::vector<SPItem *>::const_iterator i = items.begin(); i != items.end(); i++) {
             SPObject *item = *i;
             item->deleteObject(false);
         }
@@ -3312,11 +3320,11 @@
     int saved_compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
     prefs->setInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
 
-    gchar const *pat_id = SPPattern::produce(repr_copies, bbox, doc,
-                                       ( Geom::Affine(Geom::Translate(desktop->dt2doc(Geom::Point(r->min()[Geom::X],
-                                                                                            r->max()[Geom::Y]))))
-                                         * parent_transform.inverse() ),
-                                       parent_transform * move);
+    gchar const *pat_id = SPPattern::produce(
+        repr_copies, bbox, doc,
+        (Geom::Affine(Geom::Translate(desktop->dt2doc(Geom::Point(r->min()[Geom::X], r->max()[Geom::Y])))) *
+         parent_transform.inverse()),
+        parent_transform * move);
 
     // restore compensation setting
     prefs->setInt("/options/clonecompensation/value", saved_compensation);
@@ -3347,8 +3355,7 @@
     }
 
 
-    DocumentUndo::done(doc, SP_VERB_EDIT_TILE,
-                       _("Objects to pattern"));
+    DocumentUndo::done(doc, SP_VERB_EDIT_TILE, _("Objects to pattern"));
 }
 
 void sp_selection_untile(SPDesktop *desktop)
@@ -3364,16 +3371,17 @@
 
     // check if something is selected
     if (selection->isEmpty()) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select an <b>object with pattern fill</b> to extract objects from."));
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                       _("Select an <b>object with pattern fill</b> to extract objects from."));
         return;
     }
 
-    std::vector<SPItem*> new_select;
+    std::vector<SPItem *> new_select;
 
     bool did = false;
 
-    std::vector<SPItem*> items(selection->itemList());
-    for (std::vector<SPItem*>::const_reverse_iterator i=items.rbegin();i!=items.rend();i++){
+    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;
@@ -3395,19 +3403,19 @@
         Geom::Affine pat_transform = basePat->getTransform();
         pat_transform *= item->transform;
 
-        for (SPObject *child = pattern->firstChild() ; child != NULL; child = child->next ) {
+        for (SPObject *child = pattern->firstChild(); child != NULL; child = child->next) {
             if (dynamic_cast<SPItem *>(child)) {
                 Inkscape::XML::Node *copy = child->getRepr()->duplicate(xml_doc);
                 SPItem *i = dynamic_cast<SPItem *>(desktop->currentLayer()->appendChildRepr(copy));
 
-               // FIXME: relink clones to the new canvas objects
-               // use SPObject::setid when mental finishes it to steal ids of
+                // FIXME: relink clones to the new canvas objects
+                // use SPObject::setid when mental finishes it to steal ids of
 
                 // this is needed to make sure the new item has curve (simply requestDisplayUpdate does not work)
                 doc->ensureUpToDate();
 
                 if (i) {
-                    Geom::Affine transform( i->transform * pat_transform );
+                    Geom::Affine transform(i->transform * pat_transform);
                     i->doWriteTransform(i->getRepr(), transform);
 
                     new_select.push_back(i);
@@ -3425,8 +3433,7 @@
     if (!did) {
         desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("<b>No pattern fills</b> in the selection."));
     } else {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_UNTILE,
-                           _("Pattern to objects"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_EDIT_UNTILE, _("Pattern to objects"));
         selection->setList(new_select);
     }
 }
@@ -3437,22 +3444,22 @@
         return;
     }
 
-    std::vector<Inkscape::XML::Node*> 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 (std::vector<Inkscape::XML::Node*>::const_iterator i=reprlst.begin();filename_search&&xdpi_search&&ydpi_search&&i!=reprlst.end();i++){
+    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 = *i;
 
         if (filename_search) {
-            const gchar* tmp = repr->attribute("inkscape:export-filename");
-            if (tmp){
+            const gchar *tmp = repr->attribute("inkscape:export-filename");
+            if (tmp) {
                 filename = tmp;
                 filename_search = FALSE;
-            }
-            else{
+            } else {
                 filename.clear();
             }
         }
@@ -3477,15 +3484,12 @@
 
 void sp_document_get_export_hints(SPDocument *doc, Glib::ustring &filename, float *xdpi, float *ydpi)
 {
-    Inkscape::XML::Node * repr = doc->getReprRoot();
+    Inkscape::XML::Node *repr = doc->getReprRoot();
 
-    const gchar* tmp = repr->attribute("inkscape:export-filename");
-    if(tmp)
-    {
+    const gchar *tmp = repr->attribute("inkscape:export-filename");
+    if (tmp) {
         filename = tmp;
-    }
-    else
-    {
+    } else {
         filename.clear();
     }
     gchar const *dpi_string = repr->attribute("inkscape:export-xdpi");
@@ -3530,30 +3534,28 @@
     }
 
     // List of the items to show; all others will be hidden
-    std::vector<SPItem*> items(selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
 
     // Sort items so that the topmost comes last
-    sort(items.begin(),items.end(),sp_item_repr_compare_position_bool);
+    sort(items.begin(), items.end(), sp_item_repr_compare_position_bool);
 
     // 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)
     GTimeVal cu;
     g_get_current_time(&cu);
-    guint current = (int) (cu.tv_sec * 1000000 + cu.tv_usec) % 1024;
+    guint current = (int)(cu.tv_sec * 1000000 + cu.tv_usec) % 1024;
 
     // Create the filename.
-    gchar *const basename = g_strdup_printf("%s-%s-%u.png",
-                                            document->getName(),
-                                            items[0]->getRepr()->attribute("id"),
-                                            current);
+    gchar *const basename =
+        g_strdup_printf("%s-%s-%u.png", document->getName(), 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 "_"
     g_strcanon(basename, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.=+~$#@^&!?", '_');
 
     // Build the complete path by adding document base dir, if set, otherwise home dir
     gchar *directory = NULL;
-    if ( document->getURI() ) {
-        directory = g_path_get_dirname( document->getURI() );
+    if (document->getURI()) {
+        directory = g_path_get_dirname(document->getURI());
     }
     if (directory == NULL) {
         directory = INKSCAPE.homedir_path(NULL);
@@ -3561,7 +3563,7 @@
     gchar *filepath = g_build_filename(directory, basename, NULL);
     g_free(directory);
 
-    //g_print("%s\n", filepath);
+    // g_print("%s\n", filepath);
 
     // Remember parent and z-order of the topmost one
     gint pos = items.back()->getRepr()->position();
@@ -3599,8 +3601,8 @@
     }
 
     // The width and height of the bitmap in pixels
-    unsigned width = (unsigned) floor(bbox->width() * Inkscape::Util::Quantity::convert(res, "px", "in"));
-    unsigned height =(unsigned) floor(bbox->height() * Inkscape::Util::Quantity::convert(res, "px", "in"));
+    unsigned width = (unsigned)floor(bbox->width() * Inkscape::Util::Quantity::convert(res, "px", "in"));
+    unsigned height = (unsigned)floor(bbox->height() * Inkscape::Util::Quantity::convert(res, "px", "in"));
 
     // Find out if we have to run an external filter
     gchar const *run = NULL;
@@ -3642,19 +3644,16 @@
     double shift_y = bbox->max()[Geom::Y];
     if (res == Inkscape::Util::Quantity::convert(1, "in", "px")) { // for default 96 dpi, snap it to pixel grid
         shift_x = round(shift_x);
-        shift_y = -round(-shift_y); // this gets correct rounding despite coordinate inversion, remove the negations when the inversion is gone
+        shift_y = -round(-shift_y); // this gets correct rounding despite coordinate inversion, remove the negations
+                                    // when the inversion is gone
     }
-    t = Geom::Scale(1, -1) * Geom::Translate(shift_x, shift_y) * eek.inverse();  /// @fixme hardcoded doc2dt transform?
+    t = Geom::Scale(1, -1) * Geom::Translate(shift_x, shift_y) * eek.inverse(); /// @fixme hardcoded doc2dt transform?
 
     // TODO: avoid roundtrip via file
     // Do the export
-    sp_export_png_file(document, filepath,
-                       bbox->min()[Geom::X], bbox->min()[Geom::Y],
-                       bbox->max()[Geom::X], bbox->max()[Geom::Y],
-                       width, height, res, res,
-                       (guint32) 0xffffff00,
-                       NULL, NULL,
-                       true,  /*bool force_overwrite,*/
+    sp_export_png_file(document, filepath, bbox->min()[Geom::X], bbox->min()[Geom::Y], bbox->max()[Geom::X],
+                       bbox->max()[Geom::Y], width, height, res, res, (guint32)0xffffff00, NULL, NULL,
+                       true, /*bool force_overwrite,*/
                        items);
 
     // Run filter, if any
@@ -3662,7 +3661,7 @@
         g_print("Running external filter: %s\n", run);
         int result = system(run);
 
-        if(result == -1)
+        if (result == -1)
             g_warning("Could not run external filter: %s\n", run);
     }
 
@@ -3671,7 +3670,7 @@
     if (pb) {
         // Create the repr for the image
         // TODO: avoid unnecessary roundtrip between data URI and decoded pixbuf
-        Inkscape::XML::Node * repr = xml_doc->createElement("svg:image");
+        Inkscape::XML::Node *repr = xml_doc->createElement("svg:image");
         sp_embed_image(repr, pb);
         if (res == Inkscape::Util::Quantity::convert(1, "in", "px")) { // for default 96 dpi, snap it to pixel grid
             sp_repr_set_svg_double(repr, "width", width);
@@ -3682,7 +3681,7 @@
         }
 
         // Write transform
-        gchar *c=sp_svg_transform_write(t);
+        gchar *c = sp_svg_transform_write(t);
         repr->setAttribute("transform", c);
         g_free(c);
 
@@ -3701,8 +3700,7 @@
         g_object_unref(pb);
 
         // Complete undoable transaction
-        DocumentUndo::done(document, SP_VERB_SELECTION_CREATE_BITMAP,
-                           _("Create bitmap"));
+        DocumentUndo::done(document, SP_VERB_SELECTION_CREATE_BITMAP, _("Create bitmap"));
     }
 
     desktop->clearWaitingCursor();
@@ -3722,18 +3720,19 @@
     if (desktop == NULL) {
         return;
     }
-    SPDocument* doc = desktop->getDocument();
+    SPDocument *doc = desktop->getDocument();
     Inkscape::XML::Document *xml_doc = doc->getReprDoc();
 
     Inkscape::Selection *selection = desktop->getSelection();
     if (selection->isEmpty()) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to create clippath or mask from."));
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                       _("Select <b>object(s)</b> to create clippath or mask from."));
         return;
     }
-        
-    std::vector<Inkscape::XML::Node*> p(selection->reprList());
-    
-    sort(p.begin(),p.end(),sp_repr_compare_position_bool);
+
+    std::vector<Inkscape::XML::Node *> p(selection->reprList());
+
+    sort(p.begin(), p.end(), sp_repr_compare_position_bool);
 
     selection->clear();
 
@@ -3742,21 +3741,23 @@
 
     Inkscape::XML::Node *inner = xml_doc->createElement("svg:g");
     inner->setAttribute("inkscape:label", "Clip");
-    
-    for(std::vector<Inkscape::XML::Node*>::const_iterator i=p.begin();i!=p.end();i++){
-    	Inkscape::XML::Node *current = *i;
+
+    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);
             sp_repr_unparent(current);
             inner->appendChild(spnew);
             Inkscape::GC::release(spnew);
-            topmost --; // only reduce count for those items deleted from topmost_parent
-        } else { // move it to topmost_parent first
-            std::vector<Inkscape::XML::Node*> temp_clip;
+            topmost--; // only reduce count for those items deleted from topmost_parent
+        } else {       // move it to topmost_parent first
+            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
+            // 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
             gchar const *t_str = current->attribute("transform");
             Geom::Affine item_t(Geom::identity());
             if (t_str)
@@ -3773,7 +3774,8 @@
             sp_repr_unparent(current);
 
             // paste into topmost_parent (temporarily)
-            std::vector<Inkscape::XML::Node*> copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), temp_clip);
+            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 = copied.back();
@@ -3787,12 +3789,12 @@
             }
         }
     }
-    
+
     Inkscape::XML::Node *outer = xml_doc->createElement("svg:g");
     outer->appendChild(inner);
     topmost_parent->appendChild(outer);
     outer->setPosition(topmost + 1);
-    
+
     Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
     clone->setAttribute("x", "0", false);
     clone->setAttribute("y", "0", false);
@@ -3802,16 +3804,16 @@
     clone->setAttribute("inkscape:transform-center-y", inner->attribute("inkscape:transform-center-y"), false);
 
     const Geom::Affine maskTransform(Geom::Affine::identity());
-    std::vector<Inkscape::XML::Node*> templist;
+    std::vector<Inkscape::XML::Node *> templist;
     templist.push_back(clone);
     // add the new clone to the top of the original's parent
     gchar const *mask_id = SPClipPath::create(templist, doc, &maskTransform);
-    
-    
+
+
     outer->setAttribute("clip-path", g_strdup_printf("url(#%s)", mask_id));
 
     Inkscape::GC::release(clone);
-    
+
     selection->set(outer);
     DocumentUndo::done(doc, SP_VERB_OBJECT_SET_CLIPPATH, _("Create Clip Group"));
 }
@@ -3838,11 +3840,13 @@
 
     // check if something is selected
     bool is_empty = selection->isEmpty();
-    if ( apply_to_layer && is_empty) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to create clippath or mask from."));
+    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 || selection->itemList().size()==1 )) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select mask object and <b>object(s)</b> to apply clippath or mask to."));
+    } 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;
     }
 
@@ -3856,18 +3860,18 @@
 
     doc->ensureUpToDate();
 
-    std::vector<SPItem*> items(selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
 
-    sort(items.begin(),items.end(),sp_object_compare_position_bool);
+    sort(items.begin(), items.end(), sp_object_compare_position_bool);
 
     // See lp bug #542004
     selection->clear();
 
     // create a list of duplicates
-    std::vector<Inkscape::XML::Node*> mask_items;
-    std::vector<SPItem*> apply_to_items;
-    std::vector<SPItem*> items_to_delete;
-    std::vector<SPItem*> items_to_select;
+    std::vector<Inkscape::XML::Node *> mask_items;
+    std::vector<SPItem *> apply_to_items;
+    std::vector<SPItem *> items_to_delete;
+    std::vector<SPItem *> items_to_select;
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool topmost = prefs->getBool("/options/maskobject/topmost", true);
@@ -3879,12 +3883,11 @@
         apply_to_items.push_back(SP_ITEM(desktop->currentLayer()));
     }
 
-    for (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++) {
-        if((!topmost && !apply_to_layer && *i == items.front())
-                || (topmost && !apply_to_layer && *i == items.back())
-		        || apply_to_layer){
+    for (std::vector<SPItem *>::const_iterator i = items.begin(); i != items.end(); i++) {
+        if ((!topmost && !apply_to_layer && *i == items.front()) ||
+            (topmost && !apply_to_layer && *i == items.back()) || apply_to_layer) {
 
-        	Geom::Affine oldtr=(*i)->transform;
+            Geom::Affine oldtr = (*i)->transform;
             (*i)->doWriteTransform((*i)->getRepr(), (*i)->i2doc_affine());
             Inkscape::XML::Node *dup = (*i)->getRepr()->duplicate(xml_doc);
             (*i)->doWriteTransform((*i)->getRepr(), oldtr);
@@ -3892,12 +3895,11 @@
 
             if (remove_original) {
                 items_to_delete.push_back(*i);
-            }
-            else {
+            } else {
                 items_to_select.push_back(*i);
             }
-        	continue;
-        }else{
+            continue;
+        } else {
             apply_to_items.push_back(*i);
             items_to_select.push_back(*i);
         }
@@ -3913,9 +3915,9 @@
         // make a note we should ungroup this when unsetting mask
         group->setAttribute("inkscape:groupmode", "maskhelper");
 
-        std::vector<Inkscape::XML::Node*> reprs_to_group;
-        for (std::vector<SPItem*>::const_iterator i = apply_to_items.begin(); i != apply_to_items.end(); i++) {
-            reprs_to_group.push_back(static_cast<SPObject*>(*i)->getRepr());
+        std::vector<Inkscape::XML::Node *> reprs_to_group;
+        for (std::vector<SPItem *>::const_iterator i = apply_to_items.begin(); i != apply_to_items.end(); i++) {
+            reprs_to_group.push_back(static_cast<SPObject *>(*i)->getRepr());
         }
         items_to_select.clear();
 
@@ -3923,9 +3925,9 @@
 
         // apply clip/mask only to newly created group
         apply_to_items.clear();
-        apply_to_items.push_back(dynamic_cast<SPItem*>(doc->getObjectByRepr(group)));
+        apply_to_items.push_back(dynamic_cast<SPItem *>(doc->getObjectByRepr(group)));
 
-        items_to_select.push_back((SPItem*)(doc->getObjectByRepr(group)));
+        items_to_select.push_back((SPItem *)(doc->getObjectByRepr(group)));
 
         Inkscape::GC::release(group);
     }
@@ -3935,13 +3937,13 @@
 
 
     gchar const *attributeName = apply_clip_path ? "clip-path" : "mask";
-    for (std::vector<SPItem*>::const_reverse_iterator i = apply_to_items.rbegin(); i != apply_to_items.rend(); i++) {
+    for (std::vector<SPItem *>::const_reverse_iterator i = apply_to_items.rbegin(); i != apply_to_items.rend(); i++) {
         SPItem *item = reinterpret_cast<SPItem *>(*i);
         // inverted object transform should be applied to a mask object,
         // as mask is calculated in user space (after applying transform)
-        std::vector<Inkscape::XML::Node*> mask_items_dup;
-        for(std::vector<Inkscape::XML::Node*>::const_iterator it=mask_items.begin();it!=mask_items.end();it++)
-        	mask_items_dup.push_back((*it)->duplicate(xml_doc));
+        std::vector<Inkscape::XML::Node *> mask_items_dup;
+        for (std::vector<Inkscape::XML::Node *>::const_iterator it = mask_items.begin(); it != mask_items.end(); it++)
+            mask_items_dup.push_back((*it)->duplicate(xml_doc));
         Inkscape::XML::Node *current = SP_OBJECT(*i)->getRepr();
         // Node to apply mask to
         Inkscape::XML::Node *apply_mask_to = current;
@@ -3962,7 +3964,7 @@
             // Apply clip/mask to group instead
             apply_mask_to = group;
 
-            items_to_select.push_back(item = (SPItem*)(doc->getObjectByRepr(group)));
+            items_to_select.push_back(item = (SPItem *)(doc->getObjectByRepr(group)));
             Inkscape::GC::release(spnew);
             Inkscape::GC::release(group);
         }
@@ -3977,11 +3979,10 @@
         }
 
         apply_mask_to->setAttribute(attributeName, Glib::ustring("url(#") + mask_id + ')');
-
     }
 
-    for (std::vector<SPItem*>::const_iterator i = items_to_delete.begin(); i != items_to_delete.end(); i++) {
-        SPObject *item = reinterpret_cast<SPObject*>(*i);
+    for (std::vector<SPItem *>::const_iterator i = items_to_delete.begin(); i != items_to_delete.end(); i++) {
+        SPObject *item = reinterpret_cast<SPObject *>(*i);
         item->deleteObject(false);
         items_to_select.erase(remove(items_to_select.begin(), items_to_select.end(), item), items_to_select.end());
     }
@@ -3995,7 +3996,8 @@
     }
 }
 
-void sp_selection_unset_mask(SPDesktop *desktop, bool apply_clip_path) {
+void sp_selection_unset_mask(SPDesktop *desktop, bool apply_clip_path)
+{
     if (desktop == NULL) {
         return;
     }
@@ -4006,7 +4008,8 @@
 
     // check if something is selected
     if (selection->isEmpty()) {
-        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to remove clippath or mask from."));
+        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE,
+                                       _("Select <b>object(s)</b> to remove clippath or mask from."));
         return;
     }
 
@@ -4016,18 +4019,18 @@
     doc->ensureUpToDate();
 
     gchar const *attributeName = apply_clip_path ? "clip-path" : "mask";
-    std::map<SPObject*,SPItem*> referenced_objects;
+    std::map<SPObject *, SPItem *> referenced_objects;
 
-    std::vector<SPItem*> items(selection->itemList());
+    std::vector<SPItem *> items(selection->itemList());
     selection->clear();
 
     GSList *items_to_ungroup = NULL;
-    std::vector<SPItem*> items_to_select(items);
+    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 (std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
+    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 = *i;
@@ -4049,26 +4052,25 @@
 
         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
-
-                // ungroup only groups we created when setting clip/mask
-                if (group->layerMode() == SPGroup::MASK_HELPER) {
-                    items_to_ungroup = g_slist_prepend(items_to_ungroup, group);
-                }
-
+            // if we had previously enclosed masked object in group,
+            // add it to list so we can ungroup it later
+
+            // ungroup only groups we created when setting clip/mask
+            if (group->layerMode() == SPGroup::MASK_HELPER) {
+                items_to_ungroup = g_slist_prepend(items_to_ungroup, group);
+            }
         }
     }
 
     // restore mask objects into a document
-    for ( std::map<SPObject*,SPItem*>::iterator it = referenced_objects.begin() ; it != referenced_objects.end() ; ++it) {
+    for (std::map<SPObject *, SPItem *>::iterator it = referenced_objects.begin(); it != referenced_objects.end();
+         ++it) {
         SPObject *obj = (*it).first; // Group containing the clipped paths or masks
         GSList *items_to_move = NULL;
-        for ( SPObject *child = obj->firstChild() ; child; child = child->getNext() ) {
+        for (SPObject *child = obj->firstChild(); child; child = child->getNext()) {
             // Collect all clipped paths and masks within a single group
             Inkscape::XML::Node *copy = child->getRepr()->duplicate(xml_doc);
-            if(copy->attribute("inkscape:original-d") && copy->attribute("inkscape:path-effect"))
-            {
+            if (copy->attribute("inkscape:original-d") && copy->attribute("inkscape:path-effect")) {
                 copy->setAttribute("d", copy->attribute("inkscape:original-d"));
             }
             items_to_move = g_slist_prepend(items_to_move, copy);
@@ -4104,13 +4106,13 @@
     }
 
     // ungroup marked groups added when setting mask
-    for (GSList *i = items_to_ungroup ; NULL != i ; i = i->next) {
+    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.erase(remove(items_to_select.begin(), items_to_select.end(), group), items_to_select.end());
-            std::vector<SPItem*> children;
+            std::vector<SPItem *> children;
             sp_item_group_ungroup(group, children, false);
-            items_to_select.insert(items_to_select.end(),children.rbegin(),children.rend());
+            items_to_select.insert(items_to_select.end(), children.rbegin(), children.rend());
         } else {
             g_assert_not_reached();
         }
@@ -4133,8 +4135,7 @@
  *                     "fit-margin-..." attributes.  See SPDocument::fitToRect.
  * \return true if an undoable change should be recorded.
  */
-bool
-fit_canvas_to_selection(SPDesktop *desktop, bool with_margins)
+bool fit_canvas_to_selection(SPDesktop *desktop, bool with_margins)
 {
     g_return_val_if_fail(desktop != NULL, false);
     SPDocument *doc = desktop->getDocument();
@@ -4158,12 +4159,10 @@
 /**
  * Fit canvas to the bounding box of the selection, as an undoable action.
  */
-void
-verb_fit_canvas_to_selection(SPDesktop *const desktop)
+void verb_fit_canvas_to_selection(SPDesktop *const desktop)
 {
     if (fit_canvas_to_selection(desktop)) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_FIT_CANVAS_TO_SELECTION,
-                           _("Fit Page to Selection"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_FIT_CANVAS_TO_SELECTION, _("Fit Page to Selection"));
     }
 }
 
@@ -4171,8 +4170,7 @@
  * \param with_margins margins defined in the xml under <sodipodi:namedview>
  *                     "fit-margin-..." attributes.  See SPDocument::fitToRect.
  */
-bool
-fit_canvas_to_drawing(SPDocument *doc, bool with_margins)
+bool fit_canvas_to_drawing(SPDocument *doc, bool with_margins)
 {
     g_return_val_if_fail(doc != NULL, false);
 
@@ -4187,12 +4185,10 @@
     }
 }
 
-void
-verb_fit_canvas_to_drawing(SPDesktop *desktop)
+void verb_fit_canvas_to_drawing(SPDesktop *desktop)
 {
     if (fit_canvas_to_drawing(desktop->getDocument())) {
-        DocumentUndo::done(desktop->getDocument(), SP_VERB_FIT_CANVAS_TO_DRAWING,
-                           _("Fit Page to Drawing"));
+        DocumentUndo::done(desktop->getDocument(), SP_VERB_FIT_CANVAS_TO_DRAWING, _("Fit Page to Drawing"));
     }
 }
 
@@ -4201,23 +4197,24 @@
  * "fit-margin-..." attributes.  See SPDocument::fitToRect and
  * ui/dialog/page-sizer.
  */
-void fit_canvas_to_selection_or_drawing(SPDesktop *desktop) {
+void fit_canvas_to_selection_or_drawing(SPDesktop *desktop)
+{
     g_return_if_fail(desktop != NULL);
     SPDocument *doc = desktop->getDocument();
 
     g_return_if_fail(doc != NULL);
     g_return_if_fail(desktop->selection != NULL);
 
-    bool const changed = ( desktop->selection->isEmpty()
-                           ? fit_canvas_to_drawing(doc, true)
-                           : fit_canvas_to_selection(desktop, true) );
+    bool const changed =
+        (desktop->selection->isEmpty() ? fit_canvas_to_drawing(doc, true) : fit_canvas_to_selection(desktop, true));
     if (changed) {
         DocumentUndo::done(desktop->getDocument(), SP_VERB_FIT_CANVAS_TO_SELECTION_OR_DRAWING,
                            _("Fit Page to Selection or Drawing"));
     }
 };
 
-static void itemtree_map(void (*f)(SPItem *, SPDesktop *), SPObject *root, SPDesktop *desktop) {
+static void itemtree_map(void (*f)(SPItem *, SPDesktop *), SPObject *root, SPDesktop *desktop)
+{
     // don't operate on layers
     {
         SPItem *item = dynamic_cast<SPItem *>(root);
@@ -4225,8 +4222,8 @@
             f(item, desktop);
         }
     }
-    for ( SPObject::SiblingIterator iter = root->firstChild() ; iter ; ++iter ) {
-        //don't recurse into locked layers
+    for (SPObject::SiblingIterator iter = root->firstChild(); iter; ++iter) {
+        // don't recurse into locked layers
         SPItem *item = dynamic_cast<SPItem *>(&*iter);
         if (!(item && desktop->isLayer(item) && item->isLocked())) {
             itemtree_map(f, iter, desktop);
@@ -4234,20 +4231,24 @@
     }
 }
 
-static void unlock(SPItem *item, SPDesktop */*desktop*/) {
+static void unlock(SPItem *item, SPDesktop * /*desktop*/)
+{
     if (item->isLocked()) {
         item->setLocked(FALSE);
     }
 }
 
-static void unhide(SPItem *item, SPDesktop *desktop) {
+static void unhide(SPItem *item, SPDesktop *desktop)
+{
     if (desktop->itemIsHidden(item)) {
         item->setExplicitlyHidden(FALSE);
     }
 }
 
-static void process_all(void (*f)(SPItem *, SPDesktop *), SPDesktop *dt, bool layer_only) {
-    if (!dt) return;
+static void process_all(void (*f)(SPItem *, SPDesktop *), SPDesktop *dt, bool layer_only)
+{
+    if (!dt)
+        return;
 
     SPObject *root;
     if (layer_only) {
@@ -4259,21 +4260,13 @@
     itemtree_map(f, root, dt);
 }
 
-void unlock_all(SPDesktop *dt) {
-    process_all(&unlock, dt, true);
-}
-
-void unlock_all_in_all_layers(SPDesktop *dt) {
-    process_all(&unlock, dt, false);
-}
-
-void unhide_all(SPDesktop *dt) {
-    process_all(&unhide, dt, true);
-}
-
-void unhide_all_in_all_layers(SPDesktop *dt) {
-    process_all(&unhide, dt, false);
-}
+void unlock_all(SPDesktop *dt) { process_all(&unlock, dt, true); }
+
+void unlock_all_in_all_layers(SPDesktop *dt) { process_all(&unlock, dt, false); }
+
+void unhide_all(SPDesktop *dt) { process_all(&unhide, dt, true); }
+
+void unhide_all_in_all_layers(SPDesktop *dt) { process_all(&unhide, dt, false); }
 
 
 /*
 
=== modified file 'src/selection.cpp'
--- src/selection.cpp	2015-05-12 22:12:43 +0000
+++ src/selection.cpp	2015-09-02 11:21:15 +0000
@@ -30,6 +30,7 @@
 
 #include "sp-shape.h"
 #include "sp-path.h"
+#include "sp-root.h"
 #include "sp-item-group.h"
 #include "box3d.h"
 #include "box3d.h"
@@ -151,6 +152,12 @@
     return ( _objs_set.find(obj)!=_objs_set.end() );
 }
 
+bool Selection::includes_deeply(SPObject *obj) const{
+    if(!obj || dynamic_cast<SPRoot*>(obj)){return false;}
+    return (includes(obj) || includes_deeply(obj->parent));
+}
+
+
 void Selection::add(SPObject *obj, bool persist_selection_context/* = false */) {
     g_return_if_fail(obj != NULL);
     g_return_if_fail(SP_IS_OBJECT(obj));
 
=== modified file 'src/selection.h'
--- src/selection.h	2015-04-29 22:29:17 +0000
+++ src/selection.h	2015-09-02 11:21:15 +0000
@@ -209,6 +209,16 @@
     }
 
     /**
+     * Returns true if the given item is descendant of a selected item.
+     */
+    bool includes_deeply(SPObject *obj) const;
+    bool includes_deeply(XML::Node *repr) const {
+        return includes_deeply(_objectForXMLNode(repr));
+    }
+
+
+
+    /**
      * Returns a single selected object.
      *
      * @return NULL unless exactly one object is selected