From 930ca25606ddefe59afa37f32c823bedcea8ed30 Mon Sep 17 00:00:00 2001
From: Jabier Arraiza <jabier.arraiza@marker.es>
Date: Wed, 29 May 2019 11:20:37 +0200
Subject: Fixing coding style

---
 clang_format_diff | 1476 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1476 insertions(+)
 create mode 100644 clang_format_diff

(limited to 'clang_format_diff')

diff --git a/clang_format_diff b/clang_format_diff
new file mode 100644
index 000000000..4999b6f40
--- /dev/null
+++ b/clang_format_diff
@@ -0,0 +1,1476 @@
+--- 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);
+         }
+     }
-- 
cgit v1.2.3