--- src/ui/dialog/styledialog.h	(before formatting)
+++ src/ui/dialog/styledialog.h	(after formatting)
@@ -15,18 +15,18 @@
 #ifndef STYLEDIALOG_H
 #define STYLEDIALOG_H
 
-#include <ui/widget/panel.h>
-#include <gtkmm/treeview.h>
-#include <gtkmm/treestore.h>
-#include <gtkmm/treemodelfilter.h>
-#include <gtkmm/scrolledwindow.h>
+#include <glibmm/regex.h>
+#include <gtkmm/builder.h>
 #include <gtkmm/dialog.h>
-#include <gtkmm/treeselection.h>
-#include <gtkmm/switch.h>
 #include <gtkmm/eventbox.h>
 #include <gtkmm/paned.h>
-#include <glibmm/regex.h>
-#include <gtkmm/builder.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/switch.h>
+#include <gtkmm/treemodelfilter.h>
+#include <gtkmm/treeselection.h>
+#include <gtkmm/treestore.h>
+#include <gtkmm/treeview.h>
+#include <ui/widget/panel.h>
 
 #include "ui/dialog/desktop-tracker.h"
 
@@ -49,7 +49,7 @@
  */
 class StyleDialog : public Widget::Panel {
 
-public:
+  public:
     ~StyleDialog() override;
     // No default constructor, noncopyable, nonassignable
     StyleDialog();
@@ -57,6 +57,7 @@
     StyleDialog operator=(StyleDialog const &d) = delete;
 
     static StyleDialog &getInstance() { return *new StyleDialog(); }
+
   private:
     // Monitor <style> element for changes.
     class NodeObserver;
@@ -64,15 +65,16 @@
     class NodeWatcher;
     Glib::RefPtr<Glib::Regex> r_props = Glib::Regex::create("\\s*;\\s*");
     Glib::RefPtr<Glib::Regex> r_pair = Glib::Regex::create("\\s*:\\s*");
-    std::vector<StyleDialog::NodeWatcher*> _nodeWatchers;
-    void _nodeAdded(   Inkscape::XML::Node &repr );
-    void _nodeRemoved( Inkscape::XML::Node &repr );
-    void _nodeChanged( Inkscape::XML::Node &repr );
+    std::vector<StyleDialog::NodeWatcher *> _nodeWatchers;
+    void _nodeAdded(Inkscape::XML::Node &repr);
+    void _nodeRemoved(Inkscape::XML::Node &repr);
+    void _nodeChanged(Inkscape::XML::Node &repr);
     /* void _stylesheetChanged( Inkscape::XML::Node &repr ); */
     // Data structure
     class ModelColumns : public Gtk::TreeModel::ColumnRecord {
-    public:
-        ModelColumns() {
+      public:
+        ModelColumns()
+        {
             add(_colActive);
             add(_colName);
             add(_colValue);
@@ -80,36 +82,37 @@
             add(_colSelector);
             add(_colSelectorPos);
         }
-        Gtk::TreeModelColumn<bool> _colActive;             // Active or inative property
-        Gtk::TreeModelColumn<Glib::ustring> _colName;      // Name of the property.
-        Gtk::TreeModelColumn<Glib::ustring> _colValue;     // Value of the property.
-        Gtk::TreeModelColumn<bool> _colStrike;             // Propery not used, overloaded
-        Gtk::TreeModelColumn<Glib::ustring> _colSelector;  // Style or matching object id.
-        Gtk::TreeModelColumn<gint> _colSelectorPos;        // Position of the selector to hadle dup selectors
-        
+        Gtk::TreeModelColumn<bool> _colActive;            // Active or inative property
+        Gtk::TreeModelColumn<Glib::ustring> _colName;     // Name of the property.
+        Gtk::TreeModelColumn<Glib::ustring> _colValue;    // Value of the property.
+        Gtk::TreeModelColumn<bool> _colStrike;            // Propery not used, overloaded
+        Gtk::TreeModelColumn<Glib::ustring> _colSelector; // Style or matching object id.
+        Gtk::TreeModelColumn<gint> _colSelectorPos;       // Position of the selector to hadle dup selectors
     };
     ModelColumns _mColumns;
 
     // Widgets
     Gtk::ScrolledWindow _scrolledWindow;
-    Gtk::Box   _mainBox;
-    Gtk::Box   _styleBox;
+    Gtk::Box _mainBox;
+    Gtk::Box _styleBox;
     Gtk::Switch *_all_css;
     // Reading and writing the style element.
     Inkscape::XML::Node *_getStyleTextNode();
     void _readStyleElement();
-    Glib::RefPtr< Gtk::TreeModel > _selectTree(Glib::ustring selector);
+    Glib::RefPtr<Gtk::TreeModel> _selectTree(Glib::ustring selector);
     void _writeStyleElement(Glib::RefPtr<Gtk::TreeStore> store, Glib::ustring selector);
-    void _activeToggled(const Glib::ustring& path, Glib::RefPtr<Gtk::TreeStore> store);
-    bool _addRow(GdkEventButton *evt, Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeView *css_tree, Glib::ustring selector, gint pos);
-    void _nameEdited(const Glib::ustring& path, const Glib::ustring& name, Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeView *css_tree);
-    void _valueEdited(const Glib::ustring& path, const Glib::ustring& value, Glib::RefPtr<Gtk::TreeStore> store);
+    void _activeToggled(const Glib::ustring &path, Glib::RefPtr<Gtk::TreeStore> store);
+    bool _addRow(GdkEventButton *evt, Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeView *css_tree,
+                 Glib::ustring selector, gint pos);
+    void _nameEdited(const Glib::ustring &path, const Glib::ustring &name, Glib::RefPtr<Gtk::TreeStore> store,
+                     Gtk::TreeView *css_tree);
+    void _valueEdited(const Glib::ustring &path, const Glib::ustring &value, Glib::RefPtr<Gtk::TreeStore> store);
     void _onPropDelete(Glib::ustring path, Glib::RefPtr<Gtk::TreeStore> store);
     void _reload();
 
     // Update watchers
     void _addWatcherRecursive(Inkscape::XML::Node *node);
-    void _updateWatchers();    
+    void _updateWatchers();
 
     // Manipulate Tree
     std::vector<SPObject *> _getObjVec(Glib::ustring selector);
@@ -117,21 +120,21 @@
 
     // Variables
     Inkscape::XML::Node *_textNode; // Track so we know when to add a NodeObserver.
-    bool _updating;  // Prevent cyclic actions: read <-> write, select via dialog <-> via desktop
+    bool _updating;                 // Prevent cyclic actions: read <-> write, select via dialog <-> via desktop
 
     // Signals and handlers - External
     sigc::connection _document_replaced_connection;
     sigc::connection _desktop_changed_connection;
     sigc::connection _selection_changed_connection;
 
-    void _handleDocumentReplaced(SPDesktop* desktop, SPDocument *document);
-    void _handleDesktopChanged(SPDesktop* desktop);
+    void _handleDocumentReplaced(SPDesktop *desktop, SPDocument *document);
+    void _handleDesktopChanged(SPDesktop *desktop);
     void _handleSelectionChanged();
     void _closeDialog(Gtk::Dialog *textDialogPtr);
     DesktopTracker _desktopTracker;
 };
 
-} // namespace Dialogc
+} // namespace Dialog
 } // namespace UI
 } // namespace Inkscape
 
--- src/ui/dialog/xml-tree.cpp	(before formatting)
+++ src/ui/dialog/xml-tree.cpp	(after formatting)
@@ -356,11 +356,11 @@
         repr->type() == Inkscape::XML::COMMENT_NODE)) 
     {
         attributes->setRepr(repr);
-        //styles->setRepr(repr);
+        // styles->setRepr(repr);
         // selectors->setRepr(repr);
     } else {
         attributes->setRepr(nullptr);
-        //styles->setRepr(nullptr);
+        // styles->setRepr(nullptr);
         // selectors->setRepr(nullptr);
     }
 }
--- src/ui/dialog/xml-tree.h	(before formatting)
+++ src/ui/dialog/xml-tree.h	(after formatting)
@@ -27,10 +27,10 @@
 
 #include "message.h"
 
+#include "ui/dialog/attrdialog.h"
+#include "ui/dialog/desktop-tracker.h"
 #include "ui/dialog/selectordialog.h"
-#include "ui/dialog/attrdialog.h"
 #include "ui/dialog/styledialog.h"
-#include "ui/dialog/desktop-tracker.h"
 
 
 class SPDesktop;
--- src/ui/dialog/styledialog.cpp	(before formatting)
+++ src/ui/dialog/styledialog.cpp	(after formatting)
@@ -13,24 +13,23 @@
  */
 
 #include "styledialog.h"
+#include "attribute-rel-svg.h"
 #include "attributes.h"
-#include "verbs.h"
-#include "selection.h"
-#include "attribute-rel-svg.h"
+#include "document-undo.h"
 #include "inkscape.h"
-#include "document-undo.h"
+#include "io/resource.h"
 #include "selection.h"
 #include "style-internal.h"
 #include "style.h"
-#include "io/resource.h"
 #include "ui/icon-loader.h"
 #include "ui/widget/iconrenderer.h"
+#include "verbs.h"
 
 #include "xml/attribute-record.h"
 #include "xml/node-observer.h"
 
+#include <map>
 #include <regex>
-#include <map>
 #include <utility>
 
 #include <glibmm/i18n.h>
@@ -46,7 +45,8 @@
  * This macro is used to remove spaces around selectors or any strings when
  * parsing is done to update XML style element or row labels in this dialog.
  */
-#define REMOVE_SPACES(x) x.erase(0, x.find_first_not_of(' ')); \
+#define REMOVE_SPACES(x)                                                                                               \
+    x.erase(0, x.find_first_not_of(' '));                                                                              \
     x.erase(x.find_last_not_of(' ') + 1);
 
 namespace Inkscape {
@@ -55,26 +55,24 @@
 
 // Keeps a watch on style element
 class StyleDialog::NodeObserver : public Inkscape::XML::NodeObserver {
-public:
-    NodeObserver(StyleDialog* styledialog) :
-        _styledialog(styledialog)
+  public:
+    NodeObserver(StyleDialog *styledialog)
+        : _styledialog(styledialog)
     {
         g_debug("StyleDialog::NodeObserver: Constructor");
     };
 
-    void notifyContentChanged(Inkscape::XML::Node &node,
-                                      Inkscape::Util::ptr_shared old_content,
-                                      Inkscape::Util::ptr_shared new_content) override;
-
-    StyleDialog * _styledialog;
+    void notifyContentChanged(Inkscape::XML::Node &node, Inkscape::Util::ptr_shared old_content,
+                              Inkscape::Util::ptr_shared new_content) override;
+
+    StyleDialog *_styledialog;
 };
 
 
-void
-StyleDialog::NodeObserver::notifyContentChanged(
-    Inkscape::XML::Node &/*node*/,
-    Inkscape::Util::ptr_shared /*old_content*/,
-    Inkscape::Util::ptr_shared /*new_content*/ ) {
+void StyleDialog::NodeObserver::notifyContentChanged(Inkscape::XML::Node & /*node*/,
+                                                     Inkscape::Util::ptr_shared /*old_content*/,
+                                                     Inkscape::Util::ptr_shared /*new_content*/)
+{
 
     g_debug("StyleDialog::NodeObserver::notifyContentChanged");
     _styledialog->_updating = false;
@@ -85,61 +83,58 @@
 // Keeps a watch for new/removed/changed nodes
 // (Must update objects that selectors match.)
 class StyleDialog::NodeWatcher : public Inkscape::XML::NodeObserver {
-public:
-    NodeWatcher(StyleDialog* styledialog, Inkscape::XML::Node *repr) :
-        _styledialog(styledialog),
-        _repr(repr)
+  public:
+    NodeWatcher(StyleDialog *styledialog, Inkscape::XML::Node *repr)
+        : _styledialog(styledialog)
+        , _repr(repr)
     {
         g_debug("StyleDialog::NodeWatcher: Constructor");
     };
 
-    void notifyChildAdded( Inkscape::XML::Node &/*node*/,
-                                   Inkscape::XML::Node &child,
-                                   Inkscape::XML::Node */*prev*/ ) override
+    void notifyChildAdded(Inkscape::XML::Node & /*node*/, Inkscape::XML::Node &child,
+                          Inkscape::XML::Node * /*prev*/) override
     {
-        if ( _styledialog && _repr ) {
-            _styledialog->_nodeAdded( child );
-        }
-    }
-
-    void notifyChildRemoved( Inkscape::XML::Node &/*node*/,
-                                     Inkscape::XML::Node &child,
-                                     Inkscape::XML::Node */*prev*/ ) override
+        if (_styledialog && _repr) {
+            _styledialog->_nodeAdded(child);
+        }
+    }
+
+    void notifyChildRemoved(Inkscape::XML::Node & /*node*/, Inkscape::XML::Node &child,
+                            Inkscape::XML::Node * /*prev*/) override
     {
-        if ( _styledialog && _repr ) {
-            _styledialog->_nodeRemoved( child );
-        }
-    }
-/*     void notifyContentChanged(Inkscape::XML::Node &node,
-                                      Inkscape::Util::ptr_shared old_content,
-                                      Inkscape::Util::ptr_shared new_content) override{
-        if ( _styledialog && _repr && _textNode == node) {
-            _styledialog->_stylesheetChanged( node );
-        }
-    };
- */
-    void notifyAttributeChanged( Inkscape::XML::Node &node,
-                                         GQuark qname,
-                                         Util::ptr_shared /*old_value*/,
-                                         Util::ptr_shared /*new_value*/ ) override {
-        if ( _styledialog && _repr ) {
+        if (_styledialog && _repr) {
+            _styledialog->_nodeRemoved(child);
+        }
+    }
+    /*     void notifyContentChanged(Inkscape::XML::Node &node,
+                                          Inkscape::Util::ptr_shared old_content,
+                                          Inkscape::Util::ptr_shared new_content) override{
+            if ( _styledialog && _repr && _textNode == node) {
+                _styledialog->_stylesheetChanged( node );
+            }
+        };
+     */
+    void notifyAttributeChanged(Inkscape::XML::Node &node, GQuark qname, Util::ptr_shared /*old_value*/,
+                                Util::ptr_shared /*new_value*/) override
+    {
+        if (_styledialog && _repr) {
 
             // For the moment only care about attributes that are directly used in selectors.
-            const gchar * cname = g_quark_to_string (qname);
+            const gchar *cname = g_quark_to_string(qname);
             Glib::ustring name;
             if (cname) {
                 name = cname;
             }
 
-            if ( name == "id" || name == "class" || name == "style" ) {
-                _styledialog->_nodeChanged( node );
+            if (name == "id" || name == "class" || name == "style") {
+                _styledialog->_nodeChanged(node);
             }
             SPObject *obj = SP_ACTIVE_DOCUMENT->getObjectById(node.attribute("id"));
             if (obj) {
                 for (auto iter : obj->style->properties()) {
                     if (iter->style_src != SP_STYLE_SRC_UNSET) {
-                        if( iter->name == name) {
-                            _styledialog->_nodeChanged( node );
+                        if (iter->name == name) {
+                            _styledialog->_nodeChanged(node);
                         }
                     }
                 }
@@ -147,37 +142,34 @@
         }
     }
 
-    StyleDialog * _styledialog;
-    Inkscape::XML::Node * _repr;  // Need to track if document changes.
+    StyleDialog *_styledialog;
+    Inkscape::XML::Node *_repr; // Need to track if document changes.
 };
 
-void
-StyleDialog::_nodeAdded( Inkscape::XML::Node &node ) {
-
-    StyleDialog::NodeWatcher *w = new StyleDialog::NodeWatcher (this, &node);
-    node.addObserver (*w);
+void StyleDialog::_nodeAdded(Inkscape::XML::Node &node)
+{
+
+    StyleDialog::NodeWatcher *w = new StyleDialog::NodeWatcher(this, &node);
+    node.addObserver(*w);
     _nodeWatchers.push_back(w);
 
     _readStyleElement();
 }
 
-void
-StyleDialog::_nodeRemoved( Inkscape::XML::Node &repr ) {
+void StyleDialog::_nodeRemoved(Inkscape::XML::Node &repr)
+{
 
     for (auto it = _nodeWatchers.begin(); it != _nodeWatchers.end(); ++it) {
-        if ( (*it)->_repr == &repr ) {
-            (*it)->_repr->removeObserver (**it);
-            _nodeWatchers.erase( it );
+        if ((*it)->_repr == &repr) {
+            (*it)->_repr->removeObserver(**it);
+            _nodeWatchers.erase(it);
             break;
         }
     }
     _readStyleElement();
 }
 
-void
-StyleDialog::_nodeChanged( Inkscape::XML::Node &object ) {
-    _readStyleElement();
-}
+void StyleDialog::_nodeChanged(Inkscape::XML::Node &object) { _readStyleElement(); }
 
 /* void
 StyleDialog::_stylesheetChanged( Inkscape::XML::Node &repr ) {
@@ -191,11 +183,11 @@
  * adds selectors to treeview. _delSelector deletes the selector from the dialog.
  * Any addition/deletion of the selectors updates XML style element accordingly.
  */
-StyleDialog::StyleDialog() :
-    UI::Widget::Panel("/dialogs/style", SP_VERB_DIALOG_STYLE),
-    _updating(false),
-    _textNode(nullptr),
-    _desktopTracker()
+StyleDialog::StyleDialog()
+    : UI::Widget::Panel("/dialogs/style", SP_VERB_DIALOG_STYLE)
+    , _updating(false)
+    , _textNode(nullptr)
+    , _desktopTracker()
 {
     g_debug("StyleDialog::StyleDialog");
     // Pack widgets
@@ -204,8 +196,8 @@
     _styleBox.set_orientation(Gtk::ORIENTATION_VERTICAL);
     _styleBox.set_valign(Gtk::ALIGN_START);
     _scrolledWindow.add(_styleBox);
-    Gtk::Box *alltoggler =  Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
-    Gtk::Label *infotoggler =  Gtk::manage(new Gtk::Label(_("Edit Full Stylesheet")));
+    Gtk::Box *alltoggler = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL));
+    Gtk::Label *infotoggler = Gtk::manage(new Gtk::Label(_("Edit Full Stylesheet")));
     _all_css = Gtk::manage(new Gtk::Switch());
     _all_css->get_style_context()->add_class("switchclean");
     _all_css->set_margin_right(5);
@@ -218,13 +210,13 @@
     _mainBox.set_orientation(Gtk::ORIENTATION_VERTICAL);
     _getContents()->pack_start(_mainBox, Gtk::PACK_EXPAND_WIDGET);
     // Document & Desktop
-    _desktop_changed_connection = _desktopTracker.connectDesktopChanged(
-        sigc::mem_fun(*this, &StyleDialog::_handleDesktopChanged) );
+    _desktop_changed_connection =
+        _desktopTracker.connectDesktopChanged(sigc::mem_fun(*this, &StyleDialog::_handleDesktopChanged));
     _desktopTracker.connect(GTK_WIDGET(gobj()));
 
-    _document_replaced_connection = getDesktop()->connectDocumentReplaced(
-        sigc::mem_fun(this, &StyleDialog::_handleDocumentReplaced));
-    
+    _document_replaced_connection =
+        getDesktop()->connectDocumentReplaced(sigc::mem_fun(this, &StyleDialog::_handleDocumentReplaced));
+
     _selection_changed_connection = getDesktop()->getSelection()->connectChanged(
         sigc::hide(sigc::mem_fun(this, &StyleDialog::_handleSelectionChanged)));
     // Add watchers
@@ -245,18 +237,14 @@
     _selection_changed_connection.disconnect();
 }
 
-void 
-StyleDialog::_reload()
-{
-    _readStyleElement();
-}
+void StyleDialog::_reload() { _readStyleElement(); }
 
 /**
  * @return Inkscape::XML::Node* pointing to a style element's text node.
  * Returns the style element's text node. If there is no style element, one is created.
  * Ditto for text node.
  */
-Inkscape::XML::Node* StyleDialog::_getStyleTextNode()
+Inkscape::XML::Node *StyleDialog::_getStyleTextNode()
 {
 
     Inkscape::XML::Node *styleNode = nullptr;
@@ -287,7 +275,7 @@
     if (styleNode == nullptr) {
         // Style element not found, create one
         styleNode = SP_ACTIVE_DOCUMENT->getReprDoc()->createElement("svg:style");
-        textNode  = SP_ACTIVE_DOCUMENT->getReprDoc()->createTextNode("");
+        textNode = SP_ACTIVE_DOCUMENT->getReprDoc()->createTextNode("");
 
         styleNode->appendChild(textNode);
         Inkscape::GC::release(textNode);
@@ -305,35 +293,33 @@
     return textNode;
 }
 
-Glib::RefPtr< Gtk::TreeModel > StyleDialog::_selectTree(Glib::ustring selector)
-{
-    Gtk::Label * selectorlabel;
-    Glib::RefPtr< Gtk::TreeModel > model;
-    for (auto fullstyle:_styleBox.get_children()){
+Glib::RefPtr<Gtk::TreeModel> StyleDialog::_selectTree(Glib::ustring selector)
+{
+    Gtk::Label *selectorlabel;
+    Glib::RefPtr<Gtk::TreeModel> model;
+    for (auto fullstyle : _styleBox.get_children()) {
         Gtk::Box *style = dynamic_cast<Gtk::Box *>(fullstyle);
-        for (auto stylepart:style->get_children()){
+        for (auto stylepart : style->get_children()) {
             switch (style->child_property_position(*stylepart)) {
-                case 0:
-                    {
-                        Gtk::Box *selectorbox = dynamic_cast<Gtk::Box *>(stylepart);
-                        for (auto styleheader:selectorbox->get_children()){
-                            if (!selectorbox->child_property_position(*styleheader)) {
-                                selectorlabel = dynamic_cast<Gtk::Label *>(styleheader);
-                            }
+                case 0: {
+                    Gtk::Box *selectorbox = dynamic_cast<Gtk::Box *>(stylepart);
+                    for (auto styleheader : selectorbox->get_children()) {
+                        if (!selectorbox->child_property_position(*styleheader)) {
+                            selectorlabel = dynamic_cast<Gtk::Label *>(styleheader);
                         }
-                        break;
                     }
-                case 1:
-                    {
-                        Glib::ustring wdg_selector = selectorlabel->get_text();
-                        if (wdg_selector == selector){
-                            Gtk::TreeView* treeview = dynamic_cast<Gtk::TreeView *>(stylepart);
-                            if (treeview) {
-                                return treeview->get_model();
-                            }
+                    break;
+                }
+                case 1: {
+                    Glib::ustring wdg_selector = selectorlabel->get_text();
+                    if (wdg_selector == selector) {
+                        Gtk::TreeView *treeview = dynamic_cast<Gtk::TreeView *>(stylepart);
+                        if (treeview) {
+                            return treeview->get_model();
                         }
-                        break;
                     }
+                    break;
+                }
                 default:
                     break;
             }
@@ -349,10 +335,11 @@
 {
     g_debug("StyleDialog::_readStyleElement");
 
-    if (_updating) return; // Don't read if we wrote style element.
+    if (_updating)
+        return; // Don't read if we wrote style element.
     _updating = true;
 
-    Inkscape::XML::Node * textNode = _getStyleTextNode();
+    Inkscape::XML::Node *textNode = _getStyleTextNode();
     if (textNode == nullptr) {
         std::cerr << "StyleDialog::_readStyleElement: No text node!" << std::endl;
     }
@@ -370,11 +357,8 @@
     size_t open = content.find("{", start + 1);
     size_t close = content.find("}", start + 1);
     size_t end = content.find("*/", close + 1);
-    while(!breakme) {
-        if (open == std::string::npos ||
-            close ==  std::string::npos ||
-            end ==  std::string::npos)
-        {   
+    while (!breakme) {
+        if (open == std::string::npos || close == std::string::npos || end == std::string::npos) {
             breakme = true;
             break;
         }
@@ -383,10 +367,7 @@
             close = content.find("}", close + 1);
             end = content.find("*/", close + 1);
             size_t reopen = content.find("{", close + 1);
-            if (open == std::string::npos ||
-                end ==  std::string::npos ||
-                end < reopen)
-            {   
+            if (open == std::string::npos || end == std::string::npos || end < reopen) {
                 if (end < reopen) {
                     content = content.erase(start, end - start + 2);
                 } else {
@@ -417,13 +398,13 @@
 
     // If text node is empty, return (avoids problem with negative below).
 
-    for (auto child:_styleBox.get_children()) {
+    for (auto child : _styleBox.get_children()) {
         _styleBox.remove(*child);
         delete child;
     }
-    Inkscape::Selection* selection = getDesktop()->getSelection();
+    Inkscape::Selection *selection = getDesktop()->getSelection();
     SPObject *obj = nullptr;
-    if(selection->objects().size() == 1) {
+    if (selection->objects().size() == 1) {
         obj = selection->objects().back();
     }
 
@@ -448,28 +429,30 @@
     _builder->get_widget("CSSTree", css_tree);
     Glib::RefPtr<Gtk::TreeStore> store = Gtk::TreeStore::create(_mColumns);
     css_tree->set_model(store);
-    // We need to handle comments on SPStyle to activate 
+    // We need to handle comments on SPStyle to activate
     /* Gtk::CellRendererToggle *active = Gtk::manage(new Gtk::CellRendererToggle);
     int addCol = css_tree->append_column("", *active) - 1;
     Gtk::TreeViewColumn *col = css_tree->get_column(addCol);
     if (col) {
         col->add_attribute(active->property_active(), _mColumns._colActive);
     }  */
-    
+
     css_selector_event_add->signal_button_release_event().connect(
-            sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *, Glib::ustring, gint>(
-                sigc::mem_fun(*this, &StyleDialog::_addRow), store, css_tree, "style_properties", selectorpos));
-    Inkscape::UI::Widget::IconRenderer * addRenderer = manage(new Inkscape::UI::Widget::IconRenderer());
+        sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *, Glib::ustring, gint>(
+            sigc::mem_fun(*this, &StyleDialog::_addRow), store, css_tree, "style_properties", selectorpos));
+    Inkscape::UI::Widget::IconRenderer *addRenderer = manage(new Inkscape::UI::Widget::IconRenderer());
     addRenderer->add_icon("edit-delete");
     int addCol = css_tree->append_column("Delete row", *addRenderer) - 1;
     Gtk::TreeViewColumn *col = css_tree->get_column(addCol);
     if (col) {
-        addRenderer->signal_activated().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_onPropDelete), store));
+        addRenderer->signal_activated().connect(
+            sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(sigc::mem_fun(*this, &StyleDialog::_onPropDelete), store));
     }
     Gtk::CellRendererText *label = Gtk::manage(new Gtk::CellRendererText());
     label->property_placeholder_text() = _("property");
     label->property_editable() = true;
-    label->signal_edited().connect(sigc::bind< Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *>(sigc::mem_fun(*this, &StyleDialog::_nameEdited), store, css_tree));
+    label->signal_edited().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *>(
+        sigc::mem_fun(*this, &StyleDialog::_nameEdited), store, css_tree));
     addCol = css_tree->append_column("CSS Property", *label) - 1;
     col = css_tree->get_column(addCol);
     if (col) {
@@ -478,7 +461,8 @@
     Gtk::CellRendererText *value = Gtk::manage(new Gtk::CellRendererText());
     value->property_placeholder_text() = _("value");
     value->property_editable() = true;
-    value->signal_edited().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
+    value->signal_edited().connect(
+        sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
     addCol = css_tree->append_column("CSS Value", *value) - 1;
     col = css_tree->get_column(addCol);
     if (col) {
@@ -488,7 +472,7 @@
     std::map<Glib::ustring, Glib::ustring> attr_prop;
     if (obj || _all_css->get_active()) {
         Gtk::TreeModel::Path path;
-        if(!_all_css->get_active() && obj && obj->getRepr()->attribute("style")) {
+        if (!_all_css->get_active() && obj && obj->getRepr()->attribute("style")) {
             Glib::ustring style = obj->getRepr()->attribute("style");
             attr_prop = parseStyle(style);
             for (auto iter : obj->style->properties()) {
@@ -502,9 +486,9 @@
                     row[_mColumns._colStrike] = false;
                 }
             }
-        _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
-        }
-        selectorpos ++;
+            _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
+        }
+        selectorpos++;
         try {
             _builder = Gtk::Builder::create_from_file(gladefile);
         } catch (const Glib::Error &ex) {
@@ -520,27 +504,31 @@
         _builder->get_widget("CSSTree", css_tree);
         css_tree->set_model(store);
         css_selector_event_add->signal_button_release_event().connect(
-        sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *, Glib::ustring, gint>(
-        sigc::mem_fun(*this, &StyleDialog::_addRow), store, css_tree, "attributes", selectorpos));
+            sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *, Glib::ustring, gint>(
+                sigc::mem_fun(*this, &StyleDialog::_addRow), store, css_tree, "attributes", selectorpos));
         bool hasattributes = false;
-        if(!_all_css->get_active()) {
+        if (!_all_css->get_active()) {
             for (auto iter : obj->style->properties()) {
                 if (iter->style_src != SP_STYLE_SRC_UNSET) {
-                    if( iter->name != "font" && iter->name != "d" && iter->name != "marker") {
+                    if (iter->name != "font" && iter->name != "d" && iter->name != "marker") {
                         const gchar *attr = obj->getRepr()->attribute(iter->name.c_str());
                         if (attr) {
                             if (!hasattributes) {
-                                Inkscape::UI::Widget::IconRenderer * addRenderer = manage(new Inkscape::UI::Widget::IconRenderer());
+                                Inkscape::UI::Widget::IconRenderer *addRenderer =
+                                    manage(new Inkscape::UI::Widget::IconRenderer());
                                 addRenderer->add_icon("edit-delete");
                                 int addCol = css_tree->append_column("Delete row", *addRenderer) - 1;
                                 Gtk::TreeViewColumn *col = css_tree->get_column(addCol);
                                 if (col) {
-                                    addRenderer->signal_activated().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_onPropDelete), store));
+                                    addRenderer->signal_activated().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(
+                                        sigc::mem_fun(*this, &StyleDialog::_onPropDelete), store));
                                 }
                                 Gtk::CellRendererText *label = Gtk::manage(new Gtk::CellRendererText());
                                 label->property_placeholder_text() = _("property");
                                 label->property_editable() = true;
-                                label->signal_edited().connect(sigc::bind< Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView * >(sigc::mem_fun(*this, &StyleDialog::_nameEdited), store, css_tree));
+                                label->signal_edited().connect(
+                                    sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *>(
+                                        sigc::mem_fun(*this, &StyleDialog::_nameEdited), store, css_tree));
                                 addCol = css_tree->append_column("CSS Property", *label) - 1;
                                 col = css_tree->get_column(addCol);
                                 if (col) {
@@ -549,7 +537,8 @@
                                 Gtk::CellRendererText *value = Gtk::manage(new Gtk::CellRendererText());
                                 value->property_placeholder_text() = _("value");
                                 value->property_editable() = true;
-                                value->signal_edited().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
+                                value->signal_edited().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(
+                                    sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
                                 addCol = css_tree->append_column("CSS Value", *value) - 1;
                                 col = css_tree->get_column(addCol);
                                 if (col) {
@@ -574,18 +563,18 @@
                 }
             }
             if (!hasattributes) {
-                for (auto widg:css_selector_container->get_children()) {
+                for (auto widg : css_selector_container->get_children()) {
                     delete widg;
                 }
             }
             _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
         }
-        selectorpos ++;
+        selectorpos++;
         if (tokens.size() == 0) {
             _updating = false;
             return;
         }
-        for (unsigned i = 0; i < tokens.size()-1; i += 2) {
+        for (unsigned i = 0; i < tokens.size() - 1; i += 2) {
             Glib::ustring selector = tokens[i];
             REMOVE_SPACES(selector); // Remove leading/trailing spaces
             std::vector<Glib::ustring> tokensplus = Glib::Regex::split_simple("[,]+", selector);
@@ -593,27 +582,28 @@
                 REMOVE_SPACES(tok);
             }
             // Get list of objects selector matches
-            std::vector<SPObject *> objVec = _getObjVec( selector );
+            std::vector<SPObject *> objVec = _getObjVec(selector);
             if (!_all_css->get_active()) {
                 bool stop = true;
-                for (auto objel:objVec) {
-                    if (objel->getId() == obj->getId()){
+                for (auto objel : objVec) {
+                    if (objel->getId() == obj->getId()) {
                         stop = false;
                     }
                 }
                 if (stop) {
                     _updating = false;
-                    selectorpos ++;
+                    selectorpos++;
                     continue;
                 }
             }
             Glib::ustring properties;
             // Check to make sure we do have a value to match selector.
-            if ((i+1) < tokens.size()) {
-                properties = tokens[i+1];
+            if ((i + 1) < tokens.size()) {
+                properties = tokens[i + 1];
             } else {
                 std::cerr << "StyleDialog::_readStyleElement: Missing values "
-                    "for last selector!" << std::endl;
+                             "for last selector!"
+                          << std::endl;
             }
             Glib::RefPtr<Gtk::Builder> _builder;
             try {
@@ -634,24 +624,27 @@
             _builder->get_widget("CSSTree", css_tree);
             Glib::RefPtr<Gtk::TreeStore> store = Gtk::TreeStore::create(_mColumns);
             css_tree->set_model(store);
-            Inkscape::UI::Widget::IconRenderer * addRenderer = manage(new Inkscape::UI::Widget::IconRenderer());
+            Inkscape::UI::Widget::IconRenderer *addRenderer = manage(new Inkscape::UI::Widget::IconRenderer());
             addRenderer->add_icon("edit-delete");
             int addCol = css_tree->append_column("Delete row", *addRenderer) - 1;
             Gtk::TreeViewColumn *col = css_tree->get_column(addCol);
             if (col) {
-                addRenderer->signal_activated().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_onPropDelete), store));
-            } 
+                addRenderer->signal_activated().connect(
+                    sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(sigc::mem_fun(*this, &StyleDialog::_onPropDelete), store));
+            }
             Gtk::CellRendererToggle *active = Gtk::manage(new Gtk::CellRendererToggle);
             addCol = css_tree->append_column("Active Property", *active) - 1;
             col = css_tree->get_column(addCol);
             if (col) {
                 col->add_attribute(active->property_active(), _mColumns._colActive);
-                active->signal_toggled().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_activeToggled), store));
+                active->signal_toggled().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(
+                    sigc::mem_fun(*this, &StyleDialog::_activeToggled), store));
             }
             Gtk::CellRendererText *label = Gtk::manage(new Gtk::CellRendererText());
             label->property_placeholder_text() = _("property");
             label->property_editable() = true;
-            label->signal_edited().connect(sigc::bind< Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView * >(sigc::mem_fun(*this, &StyleDialog::_nameEdited), store, css_tree));
+            label->signal_edited().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *>(
+                sigc::mem_fun(*this, &StyleDialog::_nameEdited), store, css_tree));
             addCol = css_tree->append_column("CSS Selector", *label) - 1;
             col = css_tree->get_column(addCol);
             if (col) {
@@ -659,7 +652,8 @@
             }
             Gtk::CellRendererText *value = Gtk::manage(new Gtk::CellRendererText());
             value->property_editable() = true;
-            value->signal_edited().connect(sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
+            value->signal_edited().connect(
+                sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
             value->property_placeholder_text() = _("value");
             addCol = css_tree->append_column("CSS Value", *value) - 1;
             col = css_tree->get_column(addCol);
@@ -669,20 +663,18 @@
             }
             Glib::ustring style = properties;
             Glib::ustring comments = "";
-            while(style.find("/*") != std::string::npos) {
+            while (style.find("/*") != std::string::npos) {
                 size_t beg = style.find("/*");
                 size_t end = style.find("*/");
-                if (end !=  std::string::npos &&
-                    beg !=  std::string::npos) 
-                {
+                if (end != std::string::npos && beg != std::string::npos) {
                     comments = comments.append(style, beg + 2, end - beg - 2);
                     style = style.erase(beg, end - beg + 2);
                 }
             }
             std::map<Glib::ustring, Glib::ustring> attr_prop_styleshet = parseStyle(style);
             css_selector_event_add->signal_button_release_event().connect(
-            sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *, Glib::ustring, gint>(
-            sigc::mem_fun(*this, &StyleDialog::_addRow), store, css_tree, selector, selectorpos));
+                sigc::bind<Glib::RefPtr<Gtk::TreeStore>, Gtk::TreeView *, Glib::ustring, gint>(
+                    sigc::mem_fun(*this, &StyleDialog::_addRow), store, css_tree, selector, selectorpos));
             if (!_all_css->get_active()) {
                 for (auto iter : obj->style->properties()) {
                     if (iter->style_src != SP_STYLE_SRC_UNSET) {
@@ -713,7 +705,7 @@
                 }
             }
             std::map<Glib::ustring, Glib::ustring> attr_prop_styleshet_comments = parseStyle(comments);
-            
+
             for (auto iter : attr_prop_styleshet_comments) {
                 if (!attr_prop_styleshet.count(iter.first)) {
                     Gtk::TreeModel::Row row = *(store->append());
@@ -726,7 +718,7 @@
                 }
             }
             _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
-            selectorpos ++;
+            selectorpos++;
         }
     }
     _mainBox.show_all_children();
@@ -743,14 +735,13 @@
  * @return true
  * Delete the attribute from the style
  */
-void 
-StyleDialog::_onPropDelete(Glib::ustring path, Glib::RefPtr<Gtk::TreeStore> store)
+void StyleDialog::_onPropDelete(Glib::ustring path, Glib::RefPtr<Gtk::TreeStore> store)
 {
     Gtk::TreeModel::Row row = *store->get_iter(path);
     if (row) {
-        _updating = true; //to avoid a crash on deleting an obsolete widget
+        _updating = true; // to avoid a crash on deleting an obsolete widget
         Glib::ustring selector = row[_mColumns._colSelector];
-        row[_mColumns._colName] = ""; 
+        row[_mColumns._colName] = "";
         store->erase(row);
         _updating = false;
         _writeStyleElement(store, selector);
@@ -763,8 +754,7 @@
  * Convert a style string into a vector map. This should be moved to style.cpp
  *
  */
-std::map<Glib::ustring, Glib::ustring> 
-StyleDialog::parseStyle(Glib::ustring style_string)
+std::map<Glib::ustring, Glib::ustring> StyleDialog::parseStyle(Glib::ustring style_string)
 {
     std::map<Glib::ustring, Glib::ustring> ret;
 
@@ -794,7 +784,7 @@
     if (_updating) {
         return;
     }
-    Inkscape::Selection* selection = getDesktop()->getSelection();
+    Inkscape::Selection *selection = getDesktop()->getSelection();
     SPObject *obj = nullptr;
     if (selection->objects().size() == 1) {
         obj = selection->objects().back();
@@ -806,37 +796,33 @@
     _updating = true;
     gint selectorpos = 0;
     std::string styleContent = "";
-    if (selector != "style_properties" &&
-        selector != "attributes") 
-    {
+    if (selector != "style_properties" && selector != "attributes") {
         styleContent = "\n" + selector + " { \n";
     }
-    for (auto& row: store->children()) {
+    for (auto &row : store->children()) {
         selector = row[_mColumns._colSelector];
         selectorpos = row[_mColumns._colSelectorPos];
-        Glib::ustring opencomment ="";
-        Glib::ustring closecomment = "" ;
-        if (selector != "style_properties" &&
-            selector != "attributes") {
+        Glib::ustring opencomment = "";
+        Glib::ustring closecomment = "";
+        if (selector != "style_properties" && selector != "attributes") {
             opencomment = row[_mColumns._colActive] ? "    " : "  /*";
-            closecomment = row[_mColumns._colActive] ? "\n" : "*/\n" ;
-        }
-        Glib::ustring name = row[_mColumns._colName];        
+            closecomment = row[_mColumns._colActive] ? "\n" : "*/\n";
+        }
+        Glib::ustring name = row[_mColumns._colName];
         Glib::ustring value = row[_mColumns._colValue];
-        if (!(name.empty() && value.empty())){
+        if (!(name.empty() && value.empty())) {
             styleContent = styleContent + opencomment + name + ":" + value + ";" + closecomment;
         }
     }
-    if (selector != "style_properties" &&
-        selector != "attributes" ) {
+    if (selector != "style_properties" && selector != "attributes") {
         styleContent = styleContent + "}";
     }
     if (selector == "style_properties") {
-        obj->getRepr()->setAttribute("style",styleContent, false);
+        obj->getRepr()->setAttribute("style", styleContent, false);
     } else if (selector == "attributes") {
         for (auto iter : obj->style->properties()) {
             if (iter->style_src != SP_STYLE_SRC_UNSET) {
-                if( iter->name != "font" && iter->name != "d" && iter->name != "marker") {
+                if (iter->name != "font" && iter->name != "d" && iter->name != "marker") {
                     const gchar *attr = obj->getRepr()->attribute(iter->name.c_str());
                     if (attr) {
                         obj->getRepr()->setAttribute(iter->name.c_str(), nullptr);
@@ -844,14 +830,14 @@
                 }
             }
         }
-        for (auto& row: store->children()) {
-            Glib::ustring name = row[_mColumns._colName];        
-            Glib::ustring value = row[_mColumns._colValue];          
-            if (!(name.empty() && value.empty())){
+        for (auto &row : store->children()) {
+            Glib::ustring name = row[_mColumns._colName];
+            Glib::ustring value = row[_mColumns._colValue];
+            if (!(name.empty() && value.empty())) {
                 obj->getRepr()->setAttribute(name.c_str(), value);
             }
         }
-    } else if (!selector.empty()) { //styleshet
+    } else if (!selector.empty()) { // styleshet
         // We could test if styleContent is empty and then delete the style node here but there is no
         // harm in keeping it around ...
         SP_ACTIVE_DOCUMENT->setStyleSheet(nullptr);
@@ -862,10 +848,10 @@
         }
         selectormatch = selectormatch + ")([^}]*?})((.|\n)*)";
         Inkscape::XML::Node *textNode = _getStyleTextNode();
-        std::regex e (selectormatch.c_str());
+        std::regex e(selectormatch.c_str());
         std::string content = (textNode->content() ? textNode->content() : "");
         std::string result;
-        std::regex_replace (std::back_inserter(result), content.begin(), content.end(), e, "$1" + styleContent + "$3");
+        std::regex_replace(std::back_inserter(result), content.begin(), content.end(), e, "$1" + styleContent + "$3");
         textNode->setContent(result.c_str());
     }
     _readStyleElement();
@@ -875,19 +861,21 @@
     g_debug("StyleDialog::_writeStyleElement(): | %s |", styleContent.c_str());
 }
 
-bool StyleDialog::_addRow(GdkEventButton *evt, Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeView *css_tree, Glib::ustring selector, gint pos) {
-    if(evt->type == GDK_BUTTON_RELEASE && evt->button == 1) {
+bool StyleDialog::_addRow(GdkEventButton *evt, Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeView *css_tree,
+                          Glib::ustring selector, gint pos)
+{
+    if (evt->type == GDK_BUTTON_RELEASE && evt->button == 1) {
         Gtk::TreeIter iter = store->append();
         Gtk::TreeModel::Path path = (Gtk::TreeModel::Path)iter;
         Gtk::TreeModel::Row row = *(iter);
         row[_mColumns._colSelector] = selector;
         row[_mColumns._colSelectorPos] = pos;
         row[_mColumns._colActive] = true;
-        row[_mColumns._colName] =  "";
+        row[_mColumns._colName] = "";
         row[_mColumns._colValue] = "";
         row[_mColumns._colStrike] = false;
         gint col = 2;
-        if (pos < 2 ){
+        if (pos < 2) {
             col = 1;
         }
         css_tree->set_cursor(path, *(css_tree->get_column(col)), true);
@@ -903,12 +891,13 @@
  * @return
  * Called when the name is edited in the TreeView editable column
  */
-void StyleDialog::_nameEdited (const Glib::ustring& path, const Glib::ustring& name, Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeView *css_tree)
+void StyleDialog::_nameEdited(const Glib::ustring &path, const Glib::ustring &name, Glib::RefPtr<Gtk::TreeStore> store,
+                              Gtk::TreeView *css_tree)
 {
     Gtk::TreeModel::Row row = *store->get_iter(path);
     Gtk::TreeModel::Path pathel = (Gtk::TreeModel::Path)*store->get_iter(path);
 
-    if(row) {
+    if (row) {
         gint pos = row[_mColumns._colSelectorPos];
         bool write = false;
         if (row[_mColumns._colName] != name && row[_mColumns._colValue] != "") {
@@ -917,11 +906,11 @@
         Glib::ustring value = row[_mColumns._colValue];
         Glib::ustring selector = row[_mColumns._colSelector];
         row[_mColumns._colName] = name;
-        if(name.empty() && value.empty()) {
+        if (name.empty() && value.empty()) {
             store->erase(row);
         }
         gint col = 3;
-        if (pos < 2 ){
+        if (pos < 2) {
             col = 2;
         }
         if (write) {
@@ -940,31 +929,33 @@
  * @return
  * Called when the value is edited in the TreeView editable column
  */
-void StyleDialog::_valueEdited(const Glib::ustring& path, const Glib::ustring& value, Glib::RefPtr<Gtk::TreeStore> store)
+void StyleDialog::_valueEdited(const Glib::ustring &path, const Glib::ustring &value,
+                               Glib::RefPtr<Gtk::TreeStore> store)
 {
     Gtk::TreeModel::Row row = *store->get_iter(path);
-    if(row) {
+    if (row) {
         row[_mColumns._colValue] = value;
         Glib::ustring selector = row[_mColumns._colSelector];
         Glib::ustring name = row[_mColumns._colName];
-        if(name.empty() && value.empty()) {
+        if (name.empty() && value.empty()) {
             store->erase(row);
         }
         _writeStyleElement(store, selector);
     }
 }
 
-void StyleDialog::_activeToggled(const Glib::ustring& path, Glib::RefPtr<Gtk::TreeStore> store)
+void StyleDialog::_activeToggled(const Glib::ustring &path, Glib::RefPtr<Gtk::TreeStore> store)
 {
     Gtk::TreeModel::Row row = *store->get_iter(path);
-    if(row) {
+    if (row) {
         row[_mColumns._colActive] = !row[_mColumns._colActive];
         Glib::ustring selector = row[_mColumns._colSelector];
         _writeStyleElement(store, selector);
     }
 }
 
-void StyleDialog::_addWatcherRecursive(Inkscape::XML::Node *node) {
+void StyleDialog::_addWatcherRecursive(Inkscape::XML::Node *node)
+{
 
     g_debug("StyleDialog::_addWatcherRecursive()");
 
@@ -1007,12 +998,13 @@
  * @return objVec: a vector of pointers to SPObject's the selector matches.
  * Return a vector of all objects that selector matches.
  */
-std::vector<SPObject *> StyleDialog::_getObjVec(Glib::ustring selector) {
-
-    std::vector<SPObject *> objVec = SP_ACTIVE_DOCUMENT->getObjectsBySelector( selector );
+std::vector<SPObject *> StyleDialog::_getObjVec(Glib::ustring selector)
+{
+
+    std::vector<SPObject *> objVec = SP_ACTIVE_DOCUMENT->getObjectsBySelector(selector);
 
     g_debug("StyleDialog::_getObjVec: | %s |", selector.c_str());
-    for (auto& obj: objVec) {
+    for (auto &obj : objVec) {
         g_debug("  %s", obj->getId() ? obj->getId() : "null");
     }
 
@@ -1026,15 +1018,14 @@
  * Handle document replaced. (Happens when a default document is immediately replaced by another
  * document in a new window.)
  */
-void
-StyleDialog::_handleDocumentReplaced(SPDesktop *desktop, SPDocument * /* document */)
+void StyleDialog::_handleDocumentReplaced(SPDesktop *desktop, SPDocument * /* document */)
 {
     g_debug("StyleDialog::handleDocumentReplaced()");
 
     _selection_changed_connection.disconnect();
 
-    _selection_changed_connection = desktop->getSelection()->connectChanged(
-        sigc::hide(sigc::mem_fun(this, &StyleDialog::_handleSelectionChanged)));
+    _selection_changed_connection =
+        desktop->getSelection()->connectChanged(sigc::hide(sigc::mem_fun(this, &StyleDialog::_handleSelectionChanged)));
 
     _updateWatchers();
     _readStyleElement();
@@ -1044,8 +1035,8 @@
 /*
  * When a dialog is floating, it is connected to the active desktop.
  */
-void
-StyleDialog::_handleDesktopChanged(SPDesktop* desktop) {
+void StyleDialog::_handleDesktopChanged(SPDesktop *desktop)
+{
     g_debug("StyleDialog::handleDesktopReplaced()");
 
     if (getDesktop() == desktop) {
@@ -1057,12 +1048,12 @@
     _selection_changed_connection.disconnect();
     _document_replaced_connection.disconnect();
 
-    setDesktop( desktop );
-
-    _selection_changed_connection = desktop->getSelection()->connectChanged(
-        sigc::hide(sigc::mem_fun(this, &StyleDialog::_handleSelectionChanged)));
-    _document_replaced_connection = desktop->connectDocumentReplaced(
-        sigc::mem_fun(this, &StyleDialog::_handleDocumentReplaced));
+    setDesktop(desktop);
+
+    _selection_changed_connection =
+        desktop->getSelection()->connectChanged(sigc::hide(sigc::mem_fun(this, &StyleDialog::_handleSelectionChanged)));
+    _document_replaced_connection =
+        desktop->connectDocumentReplaced(sigc::mem_fun(this, &StyleDialog::_handleDocumentReplaced));
 
     _updateWatchers();
     _readStyleElement();
@@ -1072,8 +1063,8 @@
 /*
  * Handle a change in which objects are selected in a document.
  */
-void
-StyleDialog::_handleSelectionChanged() {
+void StyleDialog::_handleSelectionChanged()
+{
     g_debug("StyleDialog::_handleSelectionChanged()");
     _readStyleElement();
 }
--- src/ui/dialog/selectordialog.h	(before formatting)
+++ src/ui/dialog/selectordialog.h	(after formatting)
@@ -15,14 +15,14 @@
 #ifndef SELECTORDIALOG_H
 #define SELECTORDIALOG_H
 
+#include <gtkmm/dialog.h>
+#include <gtkmm/paned.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/treemodelfilter.h>
+#include <gtkmm/treeselection.h>
+#include <gtkmm/treestore.h>
+#include <gtkmm/treeview.h>
 #include <ui/widget/panel.h>
-#include <gtkmm/treeview.h>
-#include <gtkmm/treestore.h>
-#include <gtkmm/treemodelfilter.h>
-#include <gtkmm/scrolledwindow.h>
-#include <gtkmm/dialog.h>
-#include <gtkmm/treeselection.h>
-#include <gtkmm/paned.h>
 
 #include "ui/dialog/desktop-tracker.h"
 
@@ -81,7 +81,7 @@
         Gtk::TreeModelColumn<gint> _colType;                    // Selector row or child object row.
         Gtk::TreeModelColumn<std::vector<SPObject *> > _colObj; // List of matching objects.
         Gtk::TreeModelColumn<Glib::ustring> _colProperties;     // List of properties.
-        Gtk::TreeModelColumn<bool> _colVisible;                                       // Make visible or not.
+        Gtk::TreeModelColumn<bool> _colVisible;                 // Make visible or not.
     };
     ModelColumns _mColumns;
 
@@ -100,7 +100,7 @@
         void on_row_deleted(const TreeModel::Path& path) override;
 
     public:
-        static Glib::RefPtr<SelectorDialog::TreeStore> create(SelectorDialog *styledialog);
+      static Glib::RefPtr<SelectorDialog::TreeStore> create(SelectorDialog *styledialog);
 
     private:
         SelectorDialog *_selectordialog;
--- src/ui/icon-loader.cpp	(before formatting)
+++ src/ui/icon-loader.cpp	(after formatting)
@@ -62,7 +62,7 @@
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     if (prefs->getBool("/theme/symbolicIcons", false)) {
         Gtk::IconInfo iconinfo = icon_theme->lookup_icon(icon_name + Glib::ustring("-symbolic"), size, Gtk::ICON_LOOKUP_FORCE_SIZE);
-        if (iconinfo) { 
+        if (iconinfo) {
             bool was_simbolic = false;
             _icon_pixbuf = iconinfo.load_symbolic(SP_ACTIVE_DESKTOP->getToplevel()->get_style_context(), was_simbolic);
         } else {
--- src/ui/dialog/selectordialog.cpp	(before formatting)
+++ src/ui/dialog/selectordialog.cpp	(after formatting)
@@ -52,17 +52,17 @@
 // Keeps a watch on style element
 class SelectorDialog::NodeObserver : public Inkscape::XML::NodeObserver {
 public:
-    NodeObserver(SelectorDialog* selectordialog) :
-        _selectordialog(selectordialog)
-    {
-        g_debug("SelectorDialog::NodeObserver: Constructor");
+  NodeObserver(SelectorDialog *selectordialog)
+      : _selectordialog(selectordialog)
+  {
+      g_debug("SelectorDialog::NodeObserver: Constructor");
     };
 
     void notifyContentChanged(Inkscape::XML::Node &node,
                                       Inkscape::Util::ptr_shared old_content,
                                       Inkscape::Util::ptr_shared new_content) override;
 
-    SelectorDialog * _selectordialog;
+    SelectorDialog *_selectordialog;
 };
 
 
@@ -83,19 +83,19 @@
 // (Must update objects that selectors match.)
 class SelectorDialog::NodeWatcher : public Inkscape::XML::NodeObserver {
 public:
-    NodeWatcher(SelectorDialog* selectordialog, Inkscape::XML::Node *repr) :
-        _selectordialog(selectordialog),
-        _repr(repr)
-    {
-        g_debug("SelectorDialog::NodeWatcher: Constructor");
+  NodeWatcher(SelectorDialog *selectordialog, Inkscape::XML::Node *repr)
+      : _selectordialog(selectordialog)
+      , _repr(repr)
+  {
+      g_debug("SelectorDialog::NodeWatcher: Constructor");
     };
 
     void notifyChildAdded( Inkscape::XML::Node &/*node*/,
                                    Inkscape::XML::Node &child,
                                    Inkscape::XML::Node */*prev*/ ) override
     {
-        if ( _selectordialog && _repr ) {
-            _selectordialog->_nodeAdded( child );
+        if (_selectordialog && _repr) {
+            _selectordialog->_nodeAdded(child);
         }
     }
 
@@ -103,8 +103,8 @@
                                      Inkscape::XML::Node &child,
                                      Inkscape::XML::Node */*prev*/ ) override
     {
-        if ( _selectordialog && _repr ) {
-            _selectordialog->_nodeRemoved( child );
+        if (_selectordialog && _repr) {
+            _selectordialog->_nodeRemoved(child);
         }
     }
 
@@ -112,7 +112,7 @@
                                          GQuark qname,
                                          Util::ptr_shared /*old_value*/,
                                          Util::ptr_shared /*new_value*/ ) override {
-        if ( _selectordialog && _repr ) {
+        if (_selectordialog && _repr) {
 
             // For the moment only care about attributes that are directly used in selectors.
             const gchar * cname = g_quark_to_string (qname );
@@ -122,12 +122,12 @@
             }
 
             if ( name == "id" || name == "class" ) {
-                _selectordialog->_nodeChanged( node );
-            }
-        }
-    }
-
-    SelectorDialog * _selectordialog;
+                _selectordialog->_nodeChanged(node);
+            }
+        }
+    }
+
+    SelectorDialog *_selectordialog;
     Inkscape::XML::Node * _repr;  // Need to track if document changes.
 };
 
@@ -243,7 +243,7 @@
     addRenderer->add_icon("edit-delete");
     addRenderer->add_icon("list-add");
     addRenderer->add_icon("object-locked");
-    
+
     _store = TreeStore::create(this);
     _treeView.set_model(_store);
 
@@ -407,10 +407,10 @@
     content.erase(std::remove(content.begin(), content.end(), '\n'), content.end());
 
     // Remove comments (/* xxx */)
-/*     while(content.find("/*") != std::string::npos) {
-        size_t start = content.find("/*");
-        content.erase(start, (content.find("*\/", start) - start) +2);
-    } */
+    /*     while(content.find("/*") != std::string::npos) {
+            size_t start = content.find("/*");
+            content.erase(start, (content.find("*\/", start) - start) +2);
+        } */
 
     // First split into selector/value chunks.
     // An attempt to use Glib::Regex failed. A C++11 version worked but
@@ -453,7 +453,7 @@
         for (auto tok : tokensplus) {
             REMOVE_SPACES(tok);
             if (SPAttributeRelSVG::isSVGElement(tok) || tok.find(" ") != -1 || tok[0] == '>' || tok[0] == '+' ||
-               tok[0] == '~' || tok[0] == '*' || tok.erase(0, 1).find(".") != -1) {
+                tok[0] == '~' || tok[0] == '*' || tok.erase(0, 1).find(".") != -1) {
                 colType = UNHANDLED;
             }
         }
@@ -488,14 +488,15 @@
             Gtk::TreeModel::Row childrow = *(_store->append(row->children()));
             childrow[_mColumns._colSelector] = "#" + Glib::ustring(obj->getId());
             childrow[_mColumns._colExpand] = false;
-            childrow[_mColumns._colType] = colType == UNHANDLED ? UNHANDLED : OBJECT;;
+            childrow[_mColumns._colType] = colType == UNHANDLED ? UNHANDLED : OBJECT;
+            ;
             childrow[_mColumns._colObj] = std::vector<SPObject *>(1, obj);
             childrow[_mColumns._colProperties] = ""; // Unused
-            childrow[_mColumns._colVisible] = true; // Unused
-        }
-}
-
-    
+            childrow[_mColumns._colVisible] = true;  // Unused
+        }
+    }
+
+
     _updating = false;
 }
 
@@ -624,7 +625,7 @@
                     childrow[_mColumns._colType] = OBJECT;
                     childrow[_mColumns._colObj]        = std::vector<SPObject *>(1, obj);
                     childrow[_mColumns._colProperties] = "";  // Unused
-                    childrow[_mColumns._colVisible] = true;  // Unused
+                    childrow[_mColumns._colVisible] = true;   // Unused
                 }
             }
         }
@@ -665,7 +666,7 @@
                     childrow[_mColumns._colType] = OBJECT;
                     childrow[_mColumns._colObj] = std::vector<SPObject *>(1, obj);
                     childrow[_mColumns._colProperties] = ""; // Unused
-                    childrow[_mColumns._colVisible] = true; // Unused
+                    childrow[_mColumns._colVisible] = true;  // Unused
                 }
             }
         }
@@ -986,7 +987,7 @@
             textLabelPtr->show();
         } else {
             invalid = false;
-         }
+        }
     }
     delete textDialogPtr;
     // ==== Handle response ====
@@ -1209,13 +1210,13 @@
 {
     g_debug("SelectorDialog::_selectRow: updating: %s", (_updating ? "true" : "false"));
     del->hide();
-    std::vector< Gtk::TreeModel::Path > selectedrows = _treeView.get_selection()->get_selected_rows(); 
-    if(selectedrows.size() == 1) {
+    std::vector<Gtk::TreeModel::Path> selectedrows = _treeView.get_selection()->get_selected_rows();
+    if (selectedrows.size() == 1) {
         Gtk::TreeModel::Row row = *_store->get_iter(selectedrows[0]);
-        if (!row->parent() && row->children().size() < 2 ) {
+        if (!row->parent() && row->children().size() < 2) {
             del->show();
         }
-    } else if(selectedrows.size() == 0) {
+    } else if (selectedrows.size() == 0) {
         del->show();
     }
     if (_updating || !getDesktop()) return; // Avoid updating if we have set row via dialog.
@@ -1231,7 +1232,7 @@
     if (!selection->isEmpty()) {
         obj = selection->objects().back();
     }
-    
+
     for (auto row : children) {
         std::vector<SPObject *> objVec = row[_mColumns._colObj];
         if (obj) {
--- src/ui/dialog/attrdialog.cpp	(before formatting)
+++ src/ui/dialog/attrdialog.cpp	(after formatting)
@@ -18,9 +18,9 @@
 
 #include "message-context.h"
 #include "message-stack.h"
+#include "style.h"
 #include "ui/icon-loader.h"
 #include "ui/widget/iconrenderer.h"
-#include "style.h"
 
 #include "xml/node-event-vector.h"
 #include "xml/attribute-record.h"
@@ -383,7 +383,7 @@
     if (obj) {
         for (auto iter : obj->style->properties()) {
             if (iter->style_src != SP_STYLE_SRC_UNSET) {
-                if( iter->name == name) {
+                if (iter->name == name) {
                     obj->style->readFromObject(obj);
                     obj->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
                 }
@@ -413,7 +413,7 @@
             row[_attrColumns._attributeValue] = value;
         }
         reloadStyles(name);
-        
+
         this->setUndo(_("Change attribute value"));
     }
 }
--- src/style.cpp	(before formatting)
+++ src/style.cpp	(after formatting)
@@ -721,8 +721,8 @@
 }
 
 // return if is seted property
-bool
-SPStyle::isSet(SPAttributeEnum id) {
+bool SPStyle::isSet(SPAttributeEnum id)
+{
     bool set = false;
     switch (id) {
         case SP_PROP_CLIP_PATH:
@@ -730,7 +730,8 @@
         case SP_PROP_MASK:
             return set;
         case SP_PROP_FILTER:
-            if( !filter.inherit ) set = filter.set;
+            if (!filter.inherit)
+                set = filter.set;
             return set;
         case SP_PROP_COLOR_INTERPOLATION:
             // We read it but issue warning
@@ -912,11 +913,11 @@
             gchar *const str_value = reinterpret_cast<gchar *>(str_value_unsigned);
 
             // Add "!important" rule if necessary as this is not handled by cr_term_to_string().
-            gchar const * important = decl->important ? " !important" : "";
+            gchar const *important = decl->important ? " !important" : "";
             Inkscape::CSSOStringStream os;
             os << str_value << important;
 
-            readIfUnset( prop_idx, os.str().c_str(), source );
+            readIfUnset(prop_idx, os.str().c_str(), source);
             g_free(str_value);
         }
     }