Improvements to CSS dialog

4 files changed, 148 insertions, 92 deletions

diff --git a/src/ui/dialog/attrdialog.cpp b/src/ui/dialog/attrdialog.cpp
index 8d4e74548..0403f9b7c 100644
--- a/src/ui/dialog/attrdialog.cpp
+++ b/src/ui/dialog/attrdialog.cpp
@@ -281,7 +281,6 @@ void AttrDialog::onAttrDelete(Glib::ustring path)
             this->_store->erase(row);
             this->_repr->setAttribute(name.c_str(), nullptr, false);
             this->setUndo(_("Delete attribute"));
-            reloadStyles(name);
         }
     }
 }
@@ -310,7 +309,6 @@ bool AttrDialog::onKeyPressed(GdkEventKey *event)
                     this->_store->erase(row);
                     this->_repr->setAttribute(name.c_str(), nullptr, false);
                     this->setUndo(_("Delete attribute"));
-                    reloadStyles(name);
                 }
                 return true;
               }
@@ -375,28 +373,6 @@ void AttrDialog::nameEdited (const Glib::ustring& path, const Glib::ustring& nam
  * @return
  * Called when the value is edited in the TreeView editable column
  */
-void AttrDialog::reloadStyles(Glib::ustring name)
-{
-    SPDocument *document = this->_desktop->doc();
-    SPObject *obj = document->getObjectById(_repr->attribute("id"));
-    if (obj) {
-        for (auto iter : obj->style->properties()) {
-            if (iter->style_src != SP_STYLE_SRC_UNSET) {
-                if (iter->name == name) {
-                    obj->style->readFromObject(obj);
-                    obj->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
-                }
-            }
-        }
-    }
-}
-
-/**
- * @brief AttrDialog::valueEdited
- * @param event
- * @return
- * Called when the value is edited in the TreeView editable column
- */
 void AttrDialog::valueEdited (const Glib::ustring& path, const Glib::ustring& value)
 {
     Gtk::TreeModel::Row row = *_store->get_iter(path);
@@ -411,7 +387,6 @@ void AttrDialog::valueEdited (const Glib::ustring& path, const Glib::ustring& va
         if(!value.empty()) {
             row[_attrColumns._attributeValue] = value;
         }
-        reloadStyles(name);
 
         this->setUndo(_("Change attribute value"));
     }
diff --git a/src/ui/dialog/attrdialog.h b/src/ui/dialog/attrdialog.h
index 61493cc80..68ea14cc9 100644
--- a/src/ui/dialog/attrdialog.h
+++ b/src/ui/dialog/attrdialog.h
@@ -98,7 +98,6 @@ public:
     void onAttrDelete(Glib::ustring path);
     bool onAttrCreate(GdkEventButton *event);
     bool onKeyPressed(GdkEventKey *event);
-    void reloadStyles(Glib::ustring name);
     void nameEdited(const Glib::ustring &path, const Glib::ustring &name);
     void valueEdited(const Glib::ustring &path, const Glib::ustring &value);
 
diff --git a/src/ui/dialog/styledialog.cpp b/src/ui/dialog/styledialog.cpp
index d50a755cf..b716ef18f 100644
--- a/src/ui/dialog/styledialog.cpp
+++ b/src/ui/dialog/styledialog.cpp
@@ -132,10 +132,11 @@ class StyleDialog::NodeWatcher : public Inkscape::XML::NodeObserver {
             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) {
+                        obj->style->readFromObject(obj);
+                        obj->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+                        _styledialog->_nodeChanged(node);
+                        break;
                     }
                 }
             }
@@ -206,16 +207,6 @@ StyleDialog::StyleDialog()
     alltoggler->pack_start(*infotoggler, false, false, 0);
     _all_css->set_active(false);
     _mainBox.pack_start(*alltoggler, false, false, 0);
-    Glib::RefPtr<Gtk::ListStore> completionModel = Gtk::ListStore::create(_mCSSData);
-    _entry_completion = Gtk::EntryCompletion::create();
-    _entry_completion->set_model(completionModel);
-    _entry_completion->set_text_column(_mCSSData._colCSSData);
-    _entry_completion->set_minimum_key_length(1);
-    _entry_completion->set_popup_completion(true);
-    for (auto prop : sp_attribute_name_list(true)) {
-        Gtk::TreeModel::Row row = *(completionModel->append());
-        row[_mCSSData._colCSSData] = prop;
-    }
     _mainBox.set_orientation(Gtk::ORIENTATION_VERTICAL);
 
     _getContents()->pack_start(_mainBox, Gtk::PACK_EXPAND_WIDGET);
@@ -406,7 +397,7 @@ void StyleDialog::_readStyleElement()
 
     // Split on curly brackets. Even tokens are selectors, odd are values.
     std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("[}{]", content);
-
+    _ownerStyle.clear();
     // If text node is empty, return (avoids problem with negative below).
 
     for (auto child : _styleBox.get_children()) {
@@ -490,6 +481,8 @@ void StyleDialog::_readStyleElement()
                     row[_mColumns._colName] = iter->name;
                     row[_mColumns._colValue] = iter->get_value();
                     row[_mColumns._colStrike] = false;
+                    row[_mColumns._colOwner] = Glib::ustring("Value active");
+                    _addOwnerStyle(iter->name, "style attribute");
                 }
             }
             _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
@@ -578,9 +571,9 @@ void StyleDialog::_readStyleElement()
             }
             Gtk::CellRendererText *value = Gtk::manage(new Gtk::CellRendererText());
             value->property_editable() = true;
+                        value->property_placeholder_text() = _("value");
             value->signal_edited().connect(
                 sigc::bind<Glib::RefPtr<Gtk::TreeStore>>(sigc::mem_fun(*this, &StyleDialog::_valueEdited), store));
-            value->property_placeholder_text() = _("value");
             value->signal_editing_started().connect( sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this,
                                              &StyleDialog::_startValueEdit), store));
             addCol = css_tree->append_column("CSS Value", *value) - 1;
@@ -607,7 +600,9 @@ void StyleDialog::_readStyleElement()
                 for (auto iter : obj->style->properties()) {
                     if (iter->style_src != SP_STYLE_SRC_UNSET) {
                         if (attr_prop_styleshet.count(iter->name)) {
-                            Gtk::TreeModel::Row row = *(store->append());
+                            Gtk::TreeIter iterstore = store->append();
+                            Gtk::TreeModel::Path path = (Gtk::TreeModel::Path)iterstore;
+                            Gtk::TreeModel::Row row = *(iterstore);
                             row[_mColumns._colSelector] = selector;
                             row[_mColumns._colSelectorPos] = selectorpos;
                             row[_mColumns._colActive] = true;
@@ -619,10 +614,14 @@ void StyleDialog::_readStyleElement()
                             guint32 r2 = 0; // if there's no color, return black
                             r2 = sp_svg_read_color(iter->get_value().c_str(), r2);
                             if (attr_prop.count(iter->name) ||
-                                (value != iter->get_value() && ((r1 & 0x000000ff) == 0 || r1 != r2))) {
+                                (value != iter->get_value() && ((r1 & 0x000000ff) == 0 || r1 != r2))) 
+                            {
                                 row[_mColumns._colStrike] = true;
+                                row[_mColumns._colOwner] = Glib::ustring("");
                             } else {
                                 row[_mColumns._colStrike] = false;
+                                row[_mColumns._colOwner] = Glib::ustring("Value active");
+                                _addOwnerStyle(iter->name, selector);
                             }
                         }
                     }
@@ -636,25 +635,30 @@ void StyleDialog::_readStyleElement()
                     row[_mColumns._colName] = iter.first;
                     row[_mColumns._colValue] = iter.second;
                     row[_mColumns._colStrike] = false;
+                    row[_mColumns._colOwner] = Glib::ustring("Stylesheet value");
                 }
             }
             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());
+                    Gtk::TreeIter iterstore = store->append();
+                    Gtk::TreeModel::Path path = (Gtk::TreeModel::Path)iterstore;
+                    Gtk::TreeModel::Row row = *(iterstore);
                     row[_mColumns._colSelector] = selector;
                     row[_mColumns._colSelectorPos] = selectorpos;
                     row[_mColumns._colActive] = false;
                     row[_mColumns._colName] = iter.first;
                     row[_mColumns._colValue] = iter.second;
                     row[_mColumns._colStrike] = true;
+                    Glib::ustring tooltiptext = _("This value is comented");
+                    row[_mColumns._colOwner] = tooltiptext;
                 }
             }
             _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
             selectorpos++;
         }
-        /* try {
+        try {
             _builder = Gtk::Builder::create_from_file(gladefile);
         } catch (const Glib::Error &ex) {
             g_warning("Glade file loading failed for filter effect dialog");
@@ -691,9 +695,9 @@ void StyleDialog::_readStyleElement()
                                 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));
+                                label->signal_editing_started().connect(sigc::mem_fun(*this, &StyleDialog::_startNameEdit));
                                 addCol = css_tree->append_column("CSS Property", *label) - 1;
                                 col = css_tree->get_column(addCol);
                                 if (col) {
@@ -702,8 +706,11 @@ void StyleDialog::_readStyleElement()
                                 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));
+                                value->signal_editing_started().connect( sigc::bind<Glib::RefPtr<Gtk::TreeStore> >(sigc::mem_fun(*this,
+                                             &StyleDialog::_startValueEdit), store));
+            
                                 addCol = css_tree->append_column("CSS Value", *value) - 1;
                                 col = css_tree->get_column(addCol);
                                 if (col) {
@@ -711,17 +718,22 @@ void StyleDialog::_readStyleElement()
                                     col->add_attribute(value->property_strikethrough(), _mColumns._colStrike);
                                 }
                             }
-                            Gtk::TreeModel::Row row = *(store->append());
+                            Gtk::TreeIter iterstore = store->append();
+                            Gtk::TreeModel::Path path = (Gtk::TreeModel::Path)iterstore;
+                            Gtk::TreeModel::Row row = *(iterstore);
                             row[_mColumns._colSelector] = "attributes";
-                            row[_mColumns._colSelectorPos] = 1;
+                            row[_mColumns._colSelectorPos] = selectorpos;
                             row[_mColumns._colActive] = true;
                             row[_mColumns._colName] = iter->name;
                             row[_mColumns._colValue] = attr;
-                            //for this we comment this code
-                            if (attr_prop.count(iter->name)) {
+                            if (_ownerStyle.find(iter->name) != _ownerStyle.end()) {
                                 row[_mColumns._colStrike] = true;
+                                Glib::ustring tooltiptext = Glib::ustring("");
+                                row[_mColumns._colOwner] = tooltiptext;
                             } else {
                                 row[_mColumns._colStrike] = false;
+                                row[_mColumns._colOwner] = Glib::ustring("Value active");
+                                _addOwnerStyle(iter->name, "inline attributes");
                             }
                             hasattributes = true;
                         }
@@ -733,8 +745,16 @@ void StyleDialog::_readStyleElement()
                     delete widg;
                 }
             }
-            _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET); */
-        //}
+            _styleBox.pack_start(*css_selector_container, Gtk::PACK_EXPAND_WIDGET);
+        }
+        for (auto selector : _styleBox.get_children()) {
+            Gtk::Box *box = dynamic_cast<Gtk::Box *>(&selector[0]);
+            if (box) {
+                Gtk::TreeView *css_tree = dynamic_cast<Gtk::TreeView *>(box->get_children()[1]);
+                Glib::RefPtr<Gtk::TreeModel> model = css_tree->get_model();
+                model->foreach_iter(sigc::mem_fun(*this, &StyleDialog::_on_foreach_iter));
+            }
+        }
     }
     if (obj) {
         obj->style->readFromObject(obj);
@@ -744,6 +764,17 @@ void StyleDialog::_readStyleElement()
     _updating = false;
 }
 
+bool 
+StyleDialog::_on_foreach_iter(const Gtk::TreeModel::iterator& iter) {
+    Gtk::TreeModel::Row row = *(iter);
+    Glib::ustring owner = row[_mColumns._colOwner];
+    if (owner.empty()) {
+        Glib::ustring tooltiptext = Glib::ustring(_("Used in ") + _ownerStyle[row[_mColumns._colName]]);
+        row[_mColumns._colOwner] = tooltiptext;
+    }
+    return false;
+}
+
 /**
  * @brief StyleDialog::_onPropDelete
  * @param event
@@ -761,6 +792,15 @@ void StyleDialog::_onPropDelete(Glib::ustring path, Glib::RefPtr<Gtk::TreeStore>
     }
 }
 
+void 
+StyleDialog::_addOwnerStyle(Glib::ustring name, Glib::ustring selector) 
+{
+    if (_ownerStyle.find(name) == _ownerStyle.end()) {
+        _ownerStyle[name] = selector;
+    }
+}
+
+
 /**
  * @brief StyleDialog::parseStyle
  *
@@ -832,6 +872,22 @@ void StyleDialog::_writeStyleElement(Glib::RefPtr<Gtk::TreeStore> store, Glib::u
     }
     if (selector == "style_properties") {
         obj->getRepr()->setAttribute("style", styleContent, false);
+    } else if (selector == "attributes") {
+        for (auto iter : obj->style->properties()) {
+            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);
+                }
+            }
+        }
+        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, false);
+            }
+        }
     } 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 ...
@@ -871,25 +927,6 @@ void StyleDialog::_writeStyleElement(Glib::RefPtr<Gtk::TreeStore> store, Glib::u
             }
         }
     }
-    /* 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") {
-                    const gchar *attr = obj->getRepr()->attribute(iter->name.c_str());
-                    if (attr) {
-                        obj->getRepr()->setAttribute(iter->name.c_str(), nullptr);
-                    }
-                }
-            }
-        }
-        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  */
     _updating = false;
     _readStyleElement();
     DocumentUndo::done(SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_STYLE, _("Edited style element."));
@@ -921,12 +958,6 @@ bool StyleDialog::_addRow(GdkEventButton *evt, Glib::RefPtr<Gtk::TreeStore> stor
     return false;
 }
 
-void StyleDialog::_startNameEdit(Gtk::CellEditable *cell, const Glib::ustring &path)
-{
-    Gtk::Entry *entry = dynamic_cast<Gtk::Entry *>(cell);
-    entry->set_completion(_entry_completion);
-}
-
 void
 StyleDialog::_setAutocompletion(Gtk::Entry *entry, SPStyleEnum const cssenum[])
 {
@@ -941,20 +972,49 @@ StyleDialog::_setAutocompletion(Gtk::Entry *entry, SPStyleEnum const cssenum[])
     while (key) {
         Gtk::TreeModel::Row row = *(completionModel->append());
         row[_mCSSData._colCSSData] = Glib::ustring(key);
-        key = cssenum[counter].key;
         counter++;
+        key = cssenum[counter].key;
     }
+    entry->set_completion(entry_completion);
+}
+/*Harcode values non in enum*/
+void
+StyleDialog::_setAutocompletion(Gtk::Entry *entry, Glib::ustring name)
+{
+    Glib::RefPtr<Gtk::ListStore> completionModel = Gtk::ListStore::create(_mCSSData);
+    Glib::RefPtr<Gtk::EntryCompletion> entry_completion = Gtk::EntryCompletion::create();
+    entry_completion->set_model(completionModel);
+    entry_completion->set_text_column (_mCSSData._colCSSData);
+    entry_completion->set_minimum_key_length(0);
+    entry_completion->set_popup_completion(true);
+    gint counter = 0;
+    if(name == "paint-order") {
+        Gtk::TreeModel::Row row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = Glib::ustring("fill markers stroke");
+        row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = Glib::ustring("fill stroke markers");
+        row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = Glib::ustring("stroke markers fill");
+        row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = Glib::ustring("stroke fill markers");
+        row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = Glib::ustring("markers fill stroke");
+        row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = Glib::ustring("markers stroke fill");
+    }
+    entry->set_completion(entry_completion);
 }
 
 void
 StyleDialog::_startValueEdit(Gtk::CellEditable* cell, const Glib::ustring& path, Glib::RefPtr<Gtk::TreeStore> store)
 {
     Gtk::TreeModel::Row row = *store->get_iter(path);
-    Gtk::TreeModel::Path pathel = (Gtk::TreeModel::Path)*store->get_iter(path);
     if (row) {
         Gtk::Entry *entry = dynamic_cast<Gtk::Entry *>(cell);
         Glib::ustring name = row[_mColumns._colName];
-        if (name == "fill-rule") {
+        if (name == "paint-order") {
+            _setAutocompletion(entry, name);
+        } else if (name == "fill-rule") {
             _setAutocompletion(entry, enum_fill_rule);
         } else if (name == "stroke-linecap") {
             _setAutocompletion(entry, enum_stroke_linecap);
@@ -1002,6 +1062,22 @@ StyleDialog::_startValueEdit(Gtk::CellEditable* cell, const Glib::ustring& path,
     }
 }
 
+void StyleDialog::_startNameEdit(Gtk::CellEditable *cell, const Glib::ustring &path)
+{
+    Glib::RefPtr<Gtk::ListStore> completionModel = Gtk::ListStore::create(_mCSSData);
+    Glib::RefPtr<Gtk::EntryCompletion> entry_completion = Gtk::EntryCompletion::create();
+    entry_completion->set_model(completionModel);
+    entry_completion->set_text_column(_mCSSData._colCSSData);
+    entry_completion->set_minimum_key_length(1);
+    entry_completion->set_popup_completion(true);
+    for (auto prop : sp_attribute_name_list(true)) {
+        Gtk::TreeModel::Row row = *(completionModel->append());
+        row[_mCSSData._colCSSData] = prop;
+    }
+    Gtk::Entry *entry = dynamic_cast<Gtk::Entry *>(cell);
+    entry->set_completion(entry_completion);
+}
+
 /**
  * @brief StyleDialog::nameEdited
  * @param event
@@ -1014,20 +1090,22 @@ void StyleDialog::_nameEdited(const Glib::ustring &path, const Glib::ustring &na
     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] != "") {
             write = true;
         }
-        Glib::ustring value = row[_mColumns._colValue];
         Glib::ustring selector = row[_mColumns._colSelector];
+        Glib::ustring value = row[_mColumns._colValue];
+        bool is_attr = selector == "attributes";
+
         row[_mColumns._colName] = name;
         if (name.empty() && value.empty()) {
             store->erase(row);
         }
         gint col = 3;
-        if (pos < 1) {
+        if (pos < 1 || is_attr) {
             col = 2;
         }
         if (write) {
diff --git a/src/ui/dialog/styledialog.h b/src/ui/dialog/styledialog.h
index e4a621182..64ce43874 100644
--- a/src/ui/dialog/styledialog.h
+++ b/src/ui/dialog/styledialog.h
@@ -32,6 +32,8 @@
 #include <gtkmm/treeselection.h>
 #include <gtkmm/treestore.h>
 #include <gtkmm/treeview.h>
+#include <gtkmm/tooltip.h>
+#include <gtkmm/viewport.h>
 #include <ui/widget/panel.h>
 
 #include "ui/dialog/desktop-tracker.h"
@@ -87,6 +89,7 @@ class StyleDialog : public Widget::Panel {
             add(_colStrike);
             add(_colSelector);
             add(_colSelectorPos);
+            add(_colOwner);
         }
         Gtk::TreeModelColumn<bool> _colActive;            // Active or inative property
         Gtk::TreeModelColumn<Glib::ustring> _colName;     // Name of the property.
@@ -94,6 +97,7 @@ class StyleDialog : public Widget::Panel {
         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<Glib::ustring> _colOwner;    // Store the owner of the property for popup
     };
     ModelColumns _mColumns;
 
@@ -110,9 +114,6 @@ class StyleDialog : public Widget::Panel {
     Gtk::Box _styleBox;
     Gtk::Switch *_all_css;
 
-    // TreeViewCssProps
-    Glib::RefPtr<Gtk::EntryCompletion> _entry_completion;
-
     // Reading and writing the style element.
     Inkscape::XML::Node *_getStyleTextNode();
     void _readStyleElement();
@@ -129,6 +130,8 @@ class StyleDialog : public Widget::Panel {
 
     void _startValueEdit(Gtk::CellEditable* cell, const Glib::ustring& path, Glib::RefPtr<Gtk::TreeStore> store);
     void _setAutocompletion(Gtk::Entry *entry, SPStyleEnum const cssenum[]);
+    void _setAutocompletion(Gtk::Entry *entry, Glib::ustring name);
+    bool _on_foreach_iter(const Gtk::TreeModel::iterator& iter);
     void _reload();
 
     // Update watchers
@@ -138,7 +141,8 @@ class StyleDialog : public Widget::Panel {
     // Manipulate Tree
     std::vector<SPObject *> _getObjVec(Glib::ustring selector);
     std::map<Glib::ustring, Glib::ustring> parseStyle(Glib::ustring style_string);
-
+    std::map<Glib::ustring, Glib::ustring> _ownerStyle;
+    void _addOwnerStyle(Glib::ustring name, Glib::ustring selector);
     // 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