X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fdialogs%2Flayers-panel.cpp;h=383d11f57b0e54a0559bd418c21ce9e09bf2fa6b;hb=569ef8f6dbacc8a8b0b933d02a806c2e091ce02b;hp=5404672efe1d2451993c6e120c1d21760eefc65a;hpb=bfdf250d303bf7983bcee0959fe3f5abbef8cfaf;p=inkscape.git diff --git a/src/dialogs/layers-panel.cpp b/src/dialogs/layers-panel.cpp index 5404672ef..383d11f57 100644 --- a/src/dialogs/layers-panel.cpp +++ b/src/dialogs/layers-panel.cpp @@ -12,11 +12,18 @@ # include #endif +#include + +#include +#include + #include "inkscape.h" #include "layers-panel.h" #include "layer-manager.h" +#include "layer-fns.h" + #include "verbs.h" #include "helper/action.h" @@ -26,6 +33,10 @@ #include "sp-item.h" #include "widgets/icon.h" #include +#include "prefs-utils.h" +#include "xml/repr.h" +#include "svg/css-ostringstream.h" +#include "desktop-style.h" //#define DUMP_LAYERS 1 @@ -35,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 { @@ -51,6 +63,7 @@ enum { enum { BUTTON_NEW = 0, + BUTTON_RENAME, BUTTON_TOP, BUTTON_BOTTOM, BUTTON_UP, @@ -59,14 +72,150 @@ enum { BUTTON_DELETE }; -void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* fallback ) +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(0)), + _property_pixbuf_off(*this, "pixbuf_off", Glib::RefPtr(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 signal_toggled() + { + return _signal_toggled; + } + + sigc::signal signal_pre_toggle() + { + return _signal_pre_toggle; + } + + Glib::PropertyProxy property_active() { return _property_active.get_proxy(); } + Glib::PropertyProxy property_activatable() { return _property_activatable.get_proxy(); } + Glib::PropertyProxy< Glib::RefPtr > property_pixbuf_on(); + Glib::PropertyProxy< Glib::RefPtr > 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& 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 _property_active; + Glib::Property _property_activatable; + Glib::Property< Glib::RefPtr > _property_pixbuf_on; + Glib::Property< Glib::RefPtr > _property_pixbuf_off; + + sigc::signal _signal_toggled; + sigc::signal _signal_pre_toggle; +}; + +class LayersPanel::InternalUIBounce +{ +public: + int _actionCode; + SPObject* _target; +}; + +static gboolean layers_panel_activated( GtkObject *object, GdkEvent * /*event*/, gpointer data ) +{ + if ( data ) + { + LayersPanel* panel = reinterpret_cast(data); + panel->setDesktop( SP_ACTIVE_DESKTOP ); + } + + return FALSE; +} + + +void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback ) { bool set = false; + + if ( iconName ) { + GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, iconName ); + gtk_widget_show( child ); + btn.add( *manage(Glib::wrap(child)) ); + set = true; + } + if ( desktop ) { Verb *verb = Verb::get( code ); if ( verb ) { SPAction *action = verb->get_action(desktop); - if ( action && action->image ) { + if ( !set && action && action->image ) { GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, action->image ); gtk_widget_show( child ); btn.add( *manage(Glib::wrap(child)) ); @@ -78,11 +227,58 @@ void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned i } } } + if ( !set && fallback ) { btn.set_label( fallback ); } } + +Gtk::MenuItem& LayersPanel::_addPopupItem( SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback, int id ) +{ + GtkWidget* iconWidget = 0; + const char* label = 0; + + if ( iconName ) { + iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, iconName ); + } + + if ( desktop ) { + Verb *verb = Verb::get( code ); + if ( verb ) { + SPAction *action = verb->get_action(desktop); + if ( !iconWidget && action && action->image ) { + iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, action->image ); + } + + if ( action ) { + label = action->name; + } + } + } + + if ( !label && fallback ) { + label = fallback; + } + + Gtk::Widget* wrapped = 0; + if ( iconWidget ) { + wrapped = manage(Glib::wrap(iconWidget)); + wrapped->show(); + } + + + + Gtk::Menu::MenuList& menulist = _popupMenu.items(); + + if ( wrapped ) { + menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem( label, *wrapped, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) ); + } else { + menulist.push_back( Gtk::Menu_Helpers::MenuElem( label, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) ); + } + return menulist.back(); +} + void LayersPanel::_fireAction( unsigned int code ) { if ( _desktop ) { @@ -106,42 +302,71 @@ void LayersPanel::_fireAction( unsigned int code ) // SP_VERB_LAYER_PREV, void LayersPanel::_takeAction( int val ) { - switch ( val ) { - case BUTTON_NEW: - { - _fireAction( SP_VERB_LAYER_NEW ); - } - break; - case BUTTON_TOP: - { - _fireAction( SP_VERB_LAYER_TO_TOP ); - } - break; - case BUTTON_BOTTOM: - { - _fireAction( SP_VERB_LAYER_TO_BOTTOM ); - } - break; - case BUTTON_UP: - { - _fireAction( SP_VERB_LAYER_RAISE ); - } - break; - case BUTTON_DOWN: - { - _fireAction( SP_VERB_LAYER_LOWER ); - } - break; - case BUTTON_DELETE: - { - _fireAction( SP_VERB_LAYER_DELETE ); - } - break; + if ( !_pending ) { + _pending = new InternalUIBounce(); + _pending->_actionCode = val; + _pending->_target = _selectedLayer(); + Glib::signal_timeout().connect( sigc::mem_fun(*this, &LayersPanel::_executeAction), 0 ); } +} - if ( _desktop && _desktop->currentLayer() ) { - _selectLayer( _desktop->currentLayer() ); +bool LayersPanel::_executeAction() +{ + // Make sure selected layer hasn't changed since the action was triggered + if ( _pending + && ( + (_pending->_actionCode == BUTTON_NEW) + || !( (_desktop && _desktop->currentLayer()) + && (_desktop->currentLayer() != _pending->_target) + ) + ) + ) { + int val = _pending->_actionCode; +// SPObject* target = _pending->_target; + + switch ( val ) { + case BUTTON_NEW: + { + _fireAction( SP_VERB_LAYER_NEW ); + } + break; + case BUTTON_RENAME: + { + _fireAction( SP_VERB_LAYER_RENAME ); + } + break; + case BUTTON_TOP: + { + _fireAction( SP_VERB_LAYER_TO_TOP ); + } + break; + case BUTTON_BOTTOM: + { + _fireAction( SP_VERB_LAYER_TO_BOTTOM ); + } + break; + case BUTTON_UP: + { + _fireAction( SP_VERB_LAYER_RAISE ); + } + break; + case BUTTON_DOWN: + { + _fireAction( SP_VERB_LAYER_LOWER ); + } + break; + case BUTTON_DELETE: + { + _fireAction( SP_VERB_LAYER_DELETE ); + } + break; + } + + delete _pending; + _pending = 0; } + + return false; } class LayersPanel::ModelColumns : public Gtk::TreeModel::ColumnRecord @@ -163,20 +388,37 @@ public: Gtk::TreeModelColumn _colLocked; }; +void LayersPanel::_updateLayer( SPObject *layer ) { + _store->foreach( sigc::bind(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) ); +} -static gboolean layers_panel_activated( GtkObject *object, GdkEvent * /*event*/, gpointer data ) +bool LayersPanel::_checkForUpdated(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer) { - if ( data ) + bool stopGoing = false; + Gtk::TreeModel::Row row = *iter; + Glib::ustring tmp = row[_model->_colLabel]; + if ( layer == row[_model->_colObject] ) { - LayersPanel* panel = reinterpret_cast(data); - panel->setDesktop( SP_ACTIVE_DESKTOP ); + 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 FALSE; + return stopGoing; } void LayersPanel::_selectLayer( SPObject *layer ) { - _store->foreach( sigc::bind(sigc::mem_fun(*this, &LayersPanel::_checkForSelected), layer) ); + if ( !layer || (_desktop && _desktop->doc() && (layer == _desktop->doc()->root)) ) { + if ( _tree.get_selection()->count_selected_rows() != 0 ) { + _tree.get_selection()->unselect_all(); + } + } else { + _store->foreach( sigc::bind(sigc::mem_fun(*this, &LayersPanel::_checkForSelected), layer) ); + } + + _checkTreeSelection(); } bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer) @@ -184,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 select = _tree.get_selection(); + select->select(iter); stopGoing = true; @@ -204,48 +446,51 @@ 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(); #if DUMP_LAYERS g_message("root:%p {%s} [%s]", root, root->id, root->label() ); #endif // DUMP_LAYERS - unsigned int counter = _mgr->childCount(root); - for ( unsigned int i = 0; i < counter; i++ ) { - SPObject *child = _mgr->nthChildOf(root, i); - if ( child ) { + _addLayer( document, root, 0, target, 0 ); + } + _selectedConnection.unblock(); + } +} + +void LayersPanel::_addLayer( SPDocument* doc, SPObject* layer, Gtk::TreeModel::Row* parentRow, SPObject* target, int level ) +{ + if ( layer && (level < _maxNestDepth) ) { + unsigned int counter = _mgr->childCount(layer); + for ( unsigned int i = 0; i < counter; i++ ) { + SPObject *child = _mgr->nthChildOf(layer, i); + if ( child ) { #if DUMP_LAYERS - g_message(" layer:%p {%s} [%s]", child, child->id, child->label() ); + g_message(" %3d layer:%p {%s} [%s]", level, child, child->id, child->label() ); #endif // DUMP_LAYERS - Gtk::TreeModel::Row row = *(_store->append()); - row[_model->_colObject] = child; - row[_model->_colLabel] = child->label() ? child->label() : SP_OBJECT_ID(child); - row[_model->_colVisible] = SP_IS_ITEM(child) ? !SP_ITEM(child)->isHidden() : false; - row[_model->_colLocked] = SP_IS_ITEM(child) ? SP_ITEM(child)->isLocked() : false; + Gtk::TreeModel::iterator iter = parentRow ? _store->prepend(parentRow->children()) : _store->prepend(); + Gtk::TreeModel::Row row = *iter; + row[_model->_colObject] = child; + row[_model->_colLabel] = child->label() ? child->label() : SP_OBJECT_ID(child); + row[_model->_colVisible] = SP_IS_ITEM(child) ? !SP_ITEM(child)->isHidden() : false; + row[_model->_colLocked] = SP_IS_ITEM(child) ? SP_ITEM(child)->isLocked() : false; - // TODO - implement walking deeper, not hardcoded + if ( target && child == target ) { + _tree.expand_to_path( _store->get_path(iter) ); - unsigned int counter2 = _mgr->childCount(child); - for ( unsigned int i2 = 0; i2 < counter2; i2++ ) { - SPObject *child2 = _mgr->nthChildOf(child, i2); - if ( child2 ) { -#if DUMP_LAYERS - g_message(" layer:%p {%s} [%s]", child, child->id, child->label() ); -#endif // DUMP_LAYERS - Gtk::TreeModel::Row row2 = *(_store->append(row.children())); - row2[_model->_colObject] = child2; - row2[_model->_colLabel] = child2->label() ? child2->label() : SP_OBJECT_ID(child2); - row2[_model->_colVisible] = SP_IS_ITEM(child2) ? !SP_ITEM(child2)->isHidden() : false; - row2[_model->_colLocked] = SP_IS_ITEM(child2) ? SP_ITEM(child2)->isLocked() : false; - } - } + Glib::RefPtr select = _tree.get_selection(); + select->select(iter); + _checkTreeSelection(); } + + _addLayer( doc, child, &row, target, level + 1 ); } } } - } SPObject* LayersPanel::_selectedLayer() @@ -261,31 +506,70 @@ SPObject* LayersPanel::_selectedLayer() return obj; } +void LayersPanel::_pushTreeSelectionToCurrent() +{ + SPObject* inTree = _selectedLayer(); + // 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 ); + } + } +} + void LayersPanel::_checkTreeSelection() { bool sensitive = false; + bool sensitiveNonTop = false; + bool sensitiveNonBottom = false; if ( _tree.get_selection()->count_selected_rows() > 0 ) { sensitive = true; SPObject* inTree = _selectedLayer(); if ( inTree ) { - SPObject* curr = _desktop->currentLayer(); - if ( curr != inTree ) { - _layerChangedConnection.block(); - _desktop->setCurrentLayer(inTree); - _layerChangedConnection.unblock(); - if ( _tree.get_selection()->count_selected_rows() < 1 ) { - _selectLayer( inTree ); + + 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(); } } } - } else { - sensitive = false; } - for ( std::vector::iterator it = _watching.begin(); it != _watching.end(); ++it ) { + + for ( std::vector::iterator it = _watching.begin(); it != _watching.end(); ++it ) { (*it)->set_sensitive( sensitive ); } + for ( std::vector::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) { + (*it)->set_sensitive( sensitiveNonTop ); + } + for ( std::vector::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) { + (*it)->set_sensitive( sensitiveNonBottom ); + } +} + +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(event)); + } } void LayersPanel::_toggled( Glib::ustring const& str, int targetCol ) @@ -305,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; @@ -315,111 +600,267 @@ 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; } } } +void LayersPanel::_handleButtonEvent(GdkEventButton* evt) +{ + // TODO - fix to a better is-popup function + if ( (evt->type == GDK_BUTTON_PRESS) && (evt->button == 3) ) { + + + { + Gtk::TreeModel::Path path; + Gtk::TreeViewColumn* col = 0; + int x = static_cast(evt->x); + int y = static_cast(evt->y); + int x2 = 0; + int y2 = 0; + if ( _tree.get_path_at_pos( x, y, + path, col, + x2, y2 ) ) { + _checkTreeSelection(); + _popupMenu.popup(evt->button, evt->time); + } + } + + } +} + +void LayersPanel::_handleRowChange( Gtk::TreeModel::Path const& path, Gtk::TreeModel::iterator const& iter ) +{ + Gtk::TreeModel::Row row = *iter; + if ( row ) { + SPObject* obj = row[_model->_colObject]; + if ( obj ) { + gchar const* oldLabel = obj->label(); + Glib::ustring tmp = row[_model->_colLabel]; + if ( oldLabel && oldLabel[0] && !tmp.empty() && (tmp != oldLabel) ) { + _mgr->renameLayer( obj, tmp.c_str() ); + row[_model->_colLabel] = obj->label(); + } + } + } +} + +bool LayersPanel::_rowSelectFunction( Glib::RefPtr 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(_toggleEvent); + GdkEventButton const* evtb = reinterpret_cast(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) + _model(0), + _pending(0), + _toggleEvent(0) { + _maxNestDepth = prefs_get_int_attribute_limited("dialogs.layers", "maxDepth", 20, 1, 1000); + ModelColumns *zoop = new ModelColumns(); _model = zoop; _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("Name", _model->_colLabel) - 1; + _tree.set_headers_visible(false); + + 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 ); + } + + 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 ); + } + + int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1; _tree.set_expander_column( *_tree.get_column(nameColNum) ); - cell = dynamic_cast(_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; - } - cell = dynamic_cast(_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; - } + _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 ); - _tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_checkTreeSelection) ); - _getContents()->pack_start(_tree, Gtk::PACK_EXPAND_WIDGET); + _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 ); - _getContents()->pack_end(_buttonsRow, Gtk::PACK_SHRINK); + _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, "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, "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) ); - _watching.push_back( btn ); - _buttonsRow.pack_start( *btn ); + _watchingNonTop.push_back( btn ); + _buttonsRow.add( *btn ); btn = manage( new Gtk::Button() ); - _styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, "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) ); - _watching.push_back( btn ); - _buttonsRow.pack_start( *btn ); + _watchingNonTop.push_back( btn ); + _buttonsRow.add( *btn ); btn = manage( new Gtk::Button() ); - _styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, "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) ); - _watching.push_back( btn ); - _buttonsRow.pack_start( *btn ); + _watchingNonBottom.push_back( btn ); + _buttonsRow.add( *btn ); btn = manage( new Gtk::Button() ); - _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_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) ); - _watching.push_back( btn ); - _buttonsRow.pack_start( *btn ); + _watchingNonBottom.push_back( 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, "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 ); - for ( std::vector::iterator it = _watching.begin(); it != _watching.end(); ++it ) { - (*it)->set_sensitive( false ); - } - g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this ); + // ------------------------------------------------------- + { + _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RENAME, 0, "Rename", (int)BUTTON_RENAME ) ); + _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_NEW, 0, "New", (int)BUTTON_NEW ) ); - setDesktop( targetDesktop ); + _popupMenu.items().push_back( Gtk::Menu_Helpers::SeparatorElem() ); + _watchingNonTop.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, "Up", (int)BUTTON_UP ) ); + _watchingNonBottom.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, "Down", (int)BUTTON_DOWN ) ); + + _popupMenu.show_all_children(); + } + // ------------------------------------------------------- + + for ( std::vector::iterator it = _watching.begin(); it != _watching.end(); ++it ) { + (*it)->set_sensitive( false ); + } + for ( std::vector::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) { + (*it)->set_sensitive( false ); + } + for ( std::vector::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) { + (*it)->set_sensitive( false ); + } + + g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this ); + setDesktop( targetDesktop ); + show_all_children(); - restorePanelPrefs(); + // restorePanelPrefs(); } LayersPanel::~LayersPanel() @@ -428,6 +869,12 @@ LayersPanel::~LayersPanel() { delete _model; } + + if ( _toggleEvent ) + { + gdk_event_free( _toggleEvent ); + _toggleEvent = 0; + } } @@ -435,6 +882,7 @@ void LayersPanel::setDesktop( SPDesktop* desktop ) { if ( desktop != _desktop ) { _layerChangedConnection.disconnect(); + _layerUpdatedConnection.disconnect(); _changedConnection.disconnect(); if ( _mgr ) { _mgr = 0; @@ -445,17 +893,16 @@ 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(); - _selectLayer( _desktop->currentLayer() ); } } /*