X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fdialogs%2Flayers-panel.cpp;h=383d11f57b0e54a0559bd418c21ce9e09bf2fa6b;hb=569ef8f6dbacc8a8b0b933d02a806c2e091ce02b;hp=186aad70b2e7e81fec1bed86eafeab199d097e10;hpb=b18eff4079085241a6b79ef775cf4a620e30b6eb;p=inkscape.git

diff --git a/src/dialogs/layers-panel.cpp b/src/dialogs/layers-panel.cpp
index 186aad70b..383d11f57 100644
--- a/src/dialogs/layers-panel.cpp
+++ b/src/dialogs/layers-panel.cpp
@@ -12,7 +12,10 @@
 # include <config.h>
 #endif
 
+#include <glibmm/i18n.h>
+
 #include <gtk/gtkstock.h>
+#include <gtk/gtkmain.h>
 
 #include "inkscape.h"
 
@@ -31,6 +34,9 @@
 #include "widgets/icon.h"
 #include <gtkmm/widget.h>
 #include "prefs-utils.h"
+#include "xml/repr.h"
+#include "svg/css-ostringstream.h"
+#include "desktop-style.h"
 
 //#define DUMP_LAYERS 1
 
@@ -40,13 +46,14 @@ namespace Dialogs {
 
 LayersPanel* LayersPanel::instance = 0;
 
-LayersPanel& LayersPanel::getInstance()
+LayersPanel*
+LayersPanel::create(Inkscape::UI::Dialog::Behavior::BehaviorFactory behavior_factory)
 {
     if ( !instance ) {
-        instance = new LayersPanel();
+        instance = new LayersPanel(behavior_factory);
     }
 
-    return *instance;
+    return instance;
 }
 
 enum {
@@ -65,6 +72,115 @@ enum {
     BUTTON_DELETE
 };
 
+class ImageToggler : public Gtk::CellRendererPixbuf {
+public:
+    ImageToggler( char const* on, char const* off) :
+        Glib::ObjectBase(typeid(ImageToggler)),
+        Gtk::CellRendererPixbuf(),
+        _pixOnName(on),
+        _pixOffName(off),
+        _property_active(*this, "active", false),
+        _property_activatable(*this, "activatable", true),
+        _property_pixbuf_on(*this, "pixbuf_on", Glib::RefPtr<Gdk::Pixbuf>(0)),
+        _property_pixbuf_off(*this, "pixbuf_off", Glib::RefPtr<Gdk::Pixbuf>(0))
+    {
+        property_mode() = Gtk::CELL_RENDERER_MODE_ACTIVATABLE;
+
+        Gtk::Widget* thingie = sp_icon_get_icon(_pixOnName.c_str(), Inkscape::ICON_SIZE_DECORATION);
+        if ( thingie ) {
+            if ( SP_IS_ICON(thingie->gobj()) ) {
+                SPIcon* icon = SP_ICON(thingie->gobj());
+                sp_icon_fetch_pixbuf( icon );
+                _property_pixbuf_on = Glib::wrap( icon->pb, true );
+            }
+            delete thingie;
+        }
+        thingie = sp_icon_get_icon(_pixOffName.c_str(), Inkscape::ICON_SIZE_DECORATION);
+        if ( thingie ) {
+            if ( SP_IS_ICON(thingie->gobj()) ) {
+                SPIcon* icon = SP_ICON(thingie->gobj());
+                sp_icon_fetch_pixbuf( icon );
+                _property_pixbuf_off = Glib::wrap( icon->pb, true );
+            }
+            delete thingie;
+        }
+        property_pixbuf() = _property_pixbuf_off.get_value();
+    }
+
+    sigc::signal<void, const Glib::ustring&> signal_toggled()
+    {
+        return _signal_toggled;
+    }
+
+    sigc::signal<void, GdkEvent const *> signal_pre_toggle()
+    {
+        return _signal_pre_toggle;
+    }
+
+    Glib::PropertyProxy<bool> property_active() { return _property_active.get_proxy(); }
+    Glib::PropertyProxy<bool> property_activatable() { return _property_activatable.get_proxy(); }
+    Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_on();
+    Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_off();
+//  virtual Glib::PropertyProxy_Base _property_renderable(); //override
+
+protected:
+
+    virtual void get_size_vfunc( Gtk::Widget& widget,
+                                 const Gdk::Rectangle* cell_area,
+                                 int* x_offset,
+                                 int* y_offset,
+                                 int* width,
+                                 int* height ) const
+    {
+        Gtk::CellRendererPixbuf::get_size_vfunc( widget, cell_area, x_offset, y_offset, width, height );
+
+        if ( width ) {
+            *width += (*width) >> 1;
+        }
+        if ( height ) {
+            *height += (*height) >> 1;
+        }
+    }
+
+
+    virtual void render_vfunc( const Glib::RefPtr<Gdk::Drawable>& window,
+                               Gtk::Widget& widget,
+                               const Gdk::Rectangle& background_area,
+                               const Gdk::Rectangle& cell_area,
+                               const Gdk::Rectangle& expose_area,
+                               Gtk::CellRendererState flags )
+    {
+        property_pixbuf() = _property_active.get_value() ? _property_pixbuf_on : _property_pixbuf_off;
+        Gtk::CellRendererPixbuf::render_vfunc( window, widget, background_area, cell_area, expose_area, flags );
+    }
+
+    virtual bool activate_vfunc(GdkEvent* event,
+                                Gtk::Widget& widget,
+                                const Glib::ustring& path,
+                                const Gdk::Rectangle& background_area,
+                                const Gdk::Rectangle& cell_area,
+                                Gtk::CellRendererState flags)
+    {
+        _signal_pre_toggle.emit(event);
+        _signal_toggled.emit(path);
+
+        return false;
+    }
+
+
+private:
+    Glib::ustring _pixOnName;
+    Glib::ustring _pixOffName;
+
+    Glib::Property<bool> _property_active;
+    Glib::Property<bool> _property_activatable;
+    Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_on;
+    Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_off;
+
+    sigc::signal<void, const Glib::ustring&> _signal_toggled;
+    sigc::signal<void, GdkEvent const *> _signal_pre_toggle;
+};
+
 class LayersPanel::InternalUIBounce
 {
 public:
@@ -198,9 +314,13 @@ bool LayersPanel::_executeAction()
 {
     // Make sure selected layer hasn't changed since the action was triggered
     if ( _pending
-         && !( (_desktop && _desktop->currentLayer())
-               && (_desktop->currentLayer() != _pending->_target)
-             ) ) {
+         && (
+             (_pending->_actionCode == BUTTON_NEW)
+             || !( (_desktop && _desktop->currentLayer())
+                   && (_desktop->currentLayer() != _pending->_target)
+                 )
+             )
+        ) {
         int val = _pending->_actionCode;
 //        SPObject* target = _pending->_target;
 
@@ -268,6 +388,27 @@ public:
     Gtk::TreeModelColumn<bool> _colLocked;
 };
 
+void LayersPanel::_updateLayer( SPObject *layer ) {
+    _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) );
+}
+
+bool LayersPanel::_checkForUpdated(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
+{
+    bool stopGoing = false;
+    Gtk::TreeModel::Row row = *iter;
+    Glib::ustring tmp = row[_model->_colLabel];
+    if ( layer == row[_model->_colObject] )
+    {
+        row[_model->_colLabel] = layer->label() ? layer->label() : SP_OBJECT_ID(layer);
+        row[_model->_colVisible] = SP_IS_ITEM(layer) ? !SP_ITEM(layer)->isHidden() : false;
+        row[_model->_colLocked] = SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false;
+
+        stopGoing = true;
+    }
+
+    return stopGoing;
+}
+
 void LayersPanel::_selectLayer( SPObject *layer ) {
     if ( !layer || (_desktop && _desktop->doc() && (layer == _desktop->doc()->root)) ) {
         if ( _tree.get_selection()->count_selected_rows() != 0 ) {
@@ -285,12 +426,12 @@ bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIt
     bool stopGoing = false;
 
     Gtk::TreeModel::Row row = *iter;
-    Glib::ustring tmp = row[_model->_colLabel];
     if ( layer == row[_model->_colObject] )
     {
         _tree.expand_to_path( path );
 
         Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
+
         select->select(iter);
 
         stopGoing = true;
@@ -305,6 +446,7 @@ void LayersPanel::_layersChanged()
     SPDocument* document = _desktop->doc();
     SPObject* root = document->root;
     if ( root ) {
+        _selectedConnection.block();
         if ( _mgr && _mgr->includes( root ) ) {
             SPObject* target = _desktop->currentLayer();
             _store->clear();
@@ -314,6 +456,7 @@ void LayersPanel::_layersChanged()
 #endif // DUMP_LAYERS
             _addLayer( document, root, 0, target, 0 );
         }
+        _selectedConnection.unblock();
     }
 }
 
@@ -340,6 +483,7 @@ void LayersPanel::_addLayer( SPDocument* doc, SPObject* layer, Gtk::TreeModel::R
 
                     Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
                     select->select(iter);
+
                     _checkTreeSelection();
                 }
 
@@ -365,13 +509,16 @@ SPObject* LayersPanel::_selectedLayer()
 void LayersPanel::_pushTreeSelectionToCurrent()
 {
     SPObject* inTree = _selectedLayer();
-    if ( inTree ) {
-        SPObject* curr = _desktop->currentLayer();
-        if ( curr != inTree ) {
-            _desktop->setCurrentLayer( inTree );
+    // TODO hunt down the possible API abuse in getting NULL
+    if ( _desktop->currentRoot() ) {
+        if ( inTree ) {
+            SPObject* curr = _desktop->currentLayer();
+            if ( curr != inTree ) {
+                _mgr->setCurrentLayer( inTree );
+            }
+        } else {
+            _mgr->setCurrentLayer( _desktop->doc()->root );
         }
-    } else {
-        _desktop->setCurrentLayer( _desktop->doc()->root );
     }
 }
 
@@ -388,9 +535,19 @@ void LayersPanel::_checkTreeSelection()
 
             sensitiveNonTop = (Inkscape::next_layer(inTree->parent, inTree) != 0);
             sensitiveNonBottom = (Inkscape::previous_layer(inTree->parent, inTree) != 0);
+
+            if ( inTree->repr ) {
+                SPCSSAttr *css = sp_repr_css_attr(inTree->repr, "style");
+                if ( css ) {
+                    _opacityConnection.block();
+                    _opacity.set_value( sp_repr_css_double_property( css, "opacity", 1.0 ) * 100 );
+                    _opacityConnection.unblock();
+                }
+            }
         }
     }
 
+
     for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
         (*it)->set_sensitive( sensitive );
     }
@@ -402,6 +559,19 @@ void LayersPanel::_checkTreeSelection()
     }
 }
 
+void LayersPanel::_preToggle( GdkEvent const *event )
+{
+    if ( _toggleEvent ) {
+        gdk_event_free(_toggleEvent);
+        _toggleEvent = 0;
+    }
+
+    if ( event && (event->type == GDK_BUTTON_PRESS) ) {
+        // Make a copy so we can keep it around.
+        _toggleEvent = gdk_event_copy(const_cast<GdkEvent*>(event));
+    }
+}
+
 void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
 {
     Gtk::TreeModel::Children::iterator iter = _tree.get_model()->get_iter(str);
@@ -419,7 +589,8 @@ void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
                 row[_model->_colVisible] = newValue;
                 item->setHidden( !newValue  );
                 item->updateRepr();
-                sp_document_done( _desktop->doc() );
+                sp_document_done( _desktop->doc() , SP_VERB_DIALOG_LAYERS, 
+                                  newValue? _("Unhide layer") : _("Hide layer"));
             }
             break;
 
@@ -429,7 +600,8 @@ void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
                 row[_model->_colLocked] = newValue;
                 item->setLocked( newValue );
                 item->updateRepr();
-                sp_document_done( _desktop->doc() );
+                sp_document_done( _desktop->doc() , SP_VERB_DIALOG_LAYERS, 
+                                  newValue? _("Lock layer") : _("Unlock layer"));
             }
             break;
         }
@@ -438,6 +610,7 @@ void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
 
 void LayersPanel::_handleButtonEvent(GdkEventButton* evt)
 {
+    // TODO - fix to a better is-popup function
     if ( (evt->type == GDK_BUTTON_PRESS) && (evt->button == 3) ) {
 
 
@@ -468,22 +641,81 @@ void LayersPanel::_handleRowChange( Gtk::TreeModel::Path const& path, Gtk::TreeM
             gchar const* oldLabel = obj->label();
             Glib::ustring tmp = row[_model->_colLabel];
             if ( oldLabel && oldLabel[0] && !tmp.empty() && (tmp != oldLabel) ) {
-                obj->setLabel(tmp.c_str());
+                _mgr->renameLayer( obj, tmp.c_str() );
+                row[_model->_colLabel] = obj->label();
             }
         }
     }
 }
 
+bool LayersPanel::_rowSelectFunction( Glib::RefPtr<Gtk::TreeModel> const & model, Gtk::TreeModel::Path const & path, bool currentlySelected )
+{
+    bool val = true;
+    if ( !currentlySelected && _toggleEvent )
+    {
+        GdkEvent* event = gtk_get_current_event();
+        if ( event ) {
+            // (keep these checks separate, so we know when to call gdk_event_free()
+            if ( event->type == GDK_BUTTON_PRESS ) {
+                GdkEventButton const* target = reinterpret_cast<GdkEventButton const*>(_toggleEvent);
+                GdkEventButton const* evtb = reinterpret_cast<GdkEventButton const*>(event);
+
+                if ( (evtb->window == target->window)
+                     && (evtb->send_event == target->send_event)
+                     && (evtb->time == target->time)
+                     && (evtb->state == target->state)
+                    )
+                {
+                    // Ooooh! It's a magic one
+                    val = false;
+                }
+            }
+            gdk_event_free(event);
+        }
+    }
+    return val;
+}
+
+
+void LayersPanel::_opacityChanged()
+{
+    SPObject* layer = _selectedLayer();
+
+    if ( _desktop && layer && !_opacityConnection.blocked() ) {
+        _opacityConnection.block();
+
+        Gtk::Adjustment* adj = _opacity.get_adjustment();
+        SPCSSAttr *css = sp_repr_css_attr_new();
+
+        Inkscape::CSSOStringStream os;
+        os << CLAMP( adj->get_value() / 100, 0.0, 1.0 );
+        sp_repr_css_set_property( css, "opacity", os.str().c_str() );
+
+        sp_desktop_apply_css_recursive( layer, css, true );
+        layer->updateRepr();
+
+        sp_repr_css_attr_unref( css );
+
+        sp_document_maybe_done( _desktop->doc(), "layers:opacity", SP_VERB_DIALOG_LAYERS, 
+                                _("Change layer opacity"));
+
+        _opacityConnection.unblock();
+    }
+}
+
+
+
 /**
  * Constructor
  */
-LayersPanel::LayersPanel() :
-    Inkscape::UI::Widget::Panel( "dialogs.layers" ),
+LayersPanel::LayersPanel(Inkscape::UI::Dialog::Behavior::BehaviorFactory behavior_factory) :
+    Inkscape::UI::Dialog::Dialog(behavior_factory, "dialogs.layers", SP_VERB_DIALOG_LAYERS),
     _maxNestDepth(20),
     _mgr(0),
     _desktop(0),
     _model(0),
-    _pending(0)
+    _pending(0),
+    _toggleEvent(0)
 {
     _maxNestDepth = prefs_get_int_attribute_limited("dialogs.layers", "maxDepth", 20, 1, 1000);
 
@@ -492,76 +724,107 @@ LayersPanel::LayersPanel() :
 
     _store = Gtk::TreeStore::create( *zoop );
 
-    Gtk::CellRendererToggle* cell = 0;
     _tree.set_model( _store );
-    int visibleColNum = _tree.append_column("vis", _model->_colVisible) - 1;
-    int lockedColNum = _tree.append_column("lock", _model->_colLocked) - 1;
-    int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;
+    _tree.set_headers_visible(false);
 
-    _tree.set_expander_column( *_tree.get_column(nameColNum) );
-
-    cell = dynamic_cast<Gtk::CellRendererToggle*>(_tree.get_column_cell_renderer(visibleColNum));
-    if ( cell ) {
-        cell->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) );
-        cell->property_activatable() = true;
+    ImageToggler* eyeRenderer = manage( new ImageToggler("visible", "hidden") );
+    int visibleColNum = _tree.append_column("vis", *eyeRenderer) - 1;
+    eyeRenderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
+    eyeRenderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) );
+    eyeRenderer->property_activatable() = true;
+    Gtk::TreeViewColumn* col = _tree.get_column(visibleColNum);
+    if ( col ) {
+        col->add_attribute( eyeRenderer->property_active(), _model->_colVisible );
     }
 
-    cell = dynamic_cast<Gtk::CellRendererToggle*>(_tree.get_column_cell_renderer(lockedColNum));
-    if ( cell ) {
-        cell->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) );
-        cell->property_activatable() = true;
+    ImageToggler * renderer = manage( new ImageToggler("width_height_lock", "lock_unlocked") );
+    int lockedColNum = _tree.append_column("lock", *renderer) - 1;
+    renderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
+    renderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) );
+    renderer->property_activatable() = true;
+    col = _tree.get_column(lockedColNum);
+    if ( col ) {
+        col->add_attribute( renderer->property_active(), _model->_colLocked );
     }
 
-    _tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_pushTreeSelectionToCurrent) );
+    int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;
+
+    _tree.set_expander_column( *_tree.get_column(nameColNum) );
+
+
+    _selectedConnection = _tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_pushTreeSelectionToCurrent) );
+    _tree.get_selection()->set_select_function( sigc::mem_fun(*this, &LayersPanel::_rowSelectFunction) );
 
     _tree.get_model()->signal_row_changed().connect( sigc::mem_fun(*this, &LayersPanel::_handleRowChange) );
     _tree.signal_button_press_event().connect_notify( sigc::mem_fun(*this, &LayersPanel::_handleButtonEvent) );
 
     _scroller.add( _tree );
     _scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );
-    _getContents()->pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );
-    _getContents()->pack_end(_buttonsRow, Gtk::PACK_SHRINK);
+
+
+    _opacityBox.pack_start( *manage( new Gtk::Label(_("Opacity, %:"))), Gtk::PACK_SHRINK );
+
+    _opacity.set_draw_value(false);
+    _opacity.set_value(100.0);
+    _opacity.set_range(0.0, 100.0);
+    _opacity.set_increments(1, 10);
+    _opacityBox.pack_start( _opacity, Gtk::PACK_EXPAND_WIDGET );
+
+    _spinBtn.configure(*_opacity.get_adjustment(), 0, 1);
+
+    _spinBtn.set_width_chars(5);
+    _opacityBox.pack_end( _spinBtn, Gtk::PACK_SHRINK );
+    _watching.push_back( &_opacityBox );
+
+    get_vbox()->pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );
+
+    get_vbox()->pack_end(_opacityBox, Gtk::PACK_SHRINK);
+    get_vbox()->pack_end(_buttonsRow, Gtk::PACK_SHRINK);
+
+    _opacityConnection = _opacity.get_adjustment()->signal_value_changed().connect( sigc::mem_fun(*this, &LayersPanel::_opacityChanged) );
 
     SPDesktop* targetDesktop = SP_ACTIVE_DESKTOP;
 
+    _buttonsRow.set_child_min_width( 16 );
+
     Gtk::Button* btn = manage( new Gtk::Button() );
-    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_NEW, GTK_STOCK_ADD, "Ne" );
+    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_NEW, GTK_STOCK_ADD, _("New") );
     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_NEW) );
-    _buttonsRow.pack_start( *btn );
+    _buttonsRow.add( *btn );
 
     btn = manage( new Gtk::Button() );
-    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_TOP, GTK_STOCK_GOTO_TOP, "Top" );
+    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_TOP, GTK_STOCK_GOTO_TOP, _("Top") );
     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_TOP) );
     _watchingNonTop.push_back( btn );
-    _buttonsRow.pack_start( *btn );
+    _buttonsRow.add( *btn );
 
     btn = manage( new Gtk::Button() );
-    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, "Up" );
+    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, _("Up") );
     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_UP) );
     _watchingNonTop.push_back( btn );
-    _buttonsRow.pack_start( *btn );
+    _buttonsRow.add( *btn );
 
     btn = manage( new Gtk::Button() );
-    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, "Dn" );
+    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, _("Dn") );
     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DOWN) );
     _watchingNonBottom.push_back( btn );
-    _buttonsRow.pack_start( *btn );
+    _buttonsRow.add( *btn );
 
     btn = manage( new Gtk::Button() );
-    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_BOTTOM, GTK_STOCK_GOTO_BOTTOM, "Btm" );
+    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_BOTTOM, GTK_STOCK_GOTO_BOTTOM, _("Bot") );
     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_BOTTOM) );
     _watchingNonBottom.push_back( btn );
-    _buttonsRow.pack_start( *btn );
+    _buttonsRow.add( *btn );
 
 //     btn = manage( new Gtk::Button("Dup") );
 //     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DUPLICATE) );
-//     _buttonsRow.pack_start( *btn );
+//     _buttonsRow.add( *btn );
 
     btn = manage( new Gtk::Button() );
-    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_DELETE, GTK_STOCK_REMOVE, "X" );
+    _styleButton( *btn, targetDesktop, SP_VERB_LAYER_DELETE, GTK_STOCK_REMOVE, _("X") );
     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DELETE) );
     _watching.push_back( btn );
-    _buttonsRow.pack_start( *btn );
+    _buttonsRow.add( *btn );
 
 
 
@@ -593,15 +856,11 @@ LayersPanel::LayersPanel() :
     }
 
     g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this );
-
-
     setDesktop( targetDesktop );
 
-
-
     show_all_children();
 
-    restorePanelPrefs();
+    // restorePanelPrefs();
 }
 
 LayersPanel::~LayersPanel()
@@ -610,6 +869,12 @@ LayersPanel::~LayersPanel()
     {
         delete _model;
     }
+
+    if ( _toggleEvent )
+    {
+        gdk_event_free( _toggleEvent );
+        _toggleEvent = 0;
+    }
 }
 
 
@@ -617,6 +882,7 @@ void LayersPanel::setDesktop( SPDesktop* desktop )
 {
     if ( desktop != _desktop ) {
         _layerChangedConnection.disconnect();
+        _layerUpdatedConnection.disconnect();
         _changedConnection.disconnect();
         if ( _mgr ) {
             _mgr = 0;
@@ -627,13 +893,13 @@ void LayersPanel::setDesktop( SPDesktop* desktop )
 
         _desktop = SP_ACTIVE_DESKTOP;
         if ( _desktop ) {
-            _layerChangedConnection = _desktop->connectCurrentLayerChanged( sigc::mem_fun(*this, &LayersPanel::_selectLayer) );
-
-            setLabel( _desktop->doc()->name );
+            //setLabel( _desktop->doc()->name );
 
             _mgr = _desktop->layer_manager;
             if ( _mgr ) {
-                _mgr->connectChanged( sigc::mem_fun(*this, &LayersPanel::_layersChanged) );
+                _layerChangedConnection = _mgr->connectCurrentLayerChanged( sigc::mem_fun(*this, &LayersPanel::_selectLayer) );
+                _layerUpdatedConnection = _mgr->connectLayerDetailsChanged( sigc::mem_fun(*this, &LayersPanel::_updateLayer) );
+                _changedConnection = _mgr->connectChanged( sigc::mem_fun(*this, &LayersPanel::_layersChanged) );
             }
 
             _layersChanged();