a09ce152724821604c93ba30dde9191a0a98aeae
1 /*
2 * A simple panel for layers
3 *
4 * Authors:
5 * Jon A. Cruz
6 *
7 * Copyright (C) 2006 Jon A. Cruz
8 *
9 * Released under GNU GPL, read the file 'COPYING' for more information
10 */
11 #ifdef HAVE_CONFIG_H
12 # include <config.h>
13 #endif
15 #include <glibmm/i18n.h>
17 #include <gtk/gtkstock.h>
18 #include <gtk/gtkmain.h>
20 #include "inkscape.h"
22 #include "layers-panel.h"
24 #include "layer-manager.h"
25 #include "layer-fns.h"
27 #include "verbs.h"
28 #include "helper/action.h"
30 #include "document.h"
31 #include "desktop.h"
32 #include "sp-object.h"
33 #include "sp-item.h"
34 #include "widgets/icon.h"
35 #include <gtkmm/widget.h>
36 #include "prefs-utils.h"
38 //#define DUMP_LAYERS 1
40 namespace Inkscape {
41 namespace UI {
42 namespace Dialogs {
44 LayersPanel* LayersPanel::instance = 0;
46 LayersPanel& LayersPanel::getInstance()
47 {
48 if ( !instance ) {
49 instance = new LayersPanel();
50 }
52 return *instance;
53 }
55 enum {
56 COL_VISIBLE = 1,
57 COL_LOCKED
58 };
60 enum {
61 BUTTON_NEW = 0,
62 BUTTON_RENAME,
63 BUTTON_TOP,
64 BUTTON_BOTTOM,
65 BUTTON_UP,
66 BUTTON_DOWN,
67 // BUTTON_DUPLICATE,
68 BUTTON_DELETE
69 };
71 class ImageToggler : public Gtk::CellRendererPixbuf {
72 public:
73 ImageToggler( char const* on, char const* off) :
74 Glib::ObjectBase(typeid(ImageToggler)),
75 Gtk::CellRendererPixbuf(),
76 _pixOnName(on),
77 _pixOffName(off),
78 _property_active(*this, "active", false),
79 _property_activatable(*this, "activatable", true),
80 _property_pixbuf_on(*this, "pixbuf_on", Glib::RefPtr<Gdk::Pixbuf>(0)),
81 _property_pixbuf_off(*this, "pixbuf_off", Glib::RefPtr<Gdk::Pixbuf>(0))
82 {
83 property_mode() = Gtk::CELL_RENDERER_MODE_ACTIVATABLE;
85 Gtk::Widget* thingie = sp_icon_get_icon(_pixOnName.c_str(), Inkscape::ICON_SIZE_DECORATION);
86 if ( thingie ) {
87 if ( SP_IS_ICON(thingie->gobj()) ) {
88 SPIcon* icon = SP_ICON(thingie->gobj());
89 sp_icon_fetch_pixbuf( icon );
90 _property_pixbuf_on = Glib::wrap( icon->pb, true );
91 }
92 delete thingie;
93 }
94 thingie = sp_icon_get_icon(_pixOffName.c_str(), Inkscape::ICON_SIZE_DECORATION);
95 if ( thingie ) {
96 if ( SP_IS_ICON(thingie->gobj()) ) {
97 SPIcon* icon = SP_ICON(thingie->gobj());
98 sp_icon_fetch_pixbuf( icon );
99 _property_pixbuf_off = Glib::wrap( icon->pb, true );
100 }
101 delete thingie;
102 }
103 property_pixbuf() = _property_pixbuf_off.get_value();
104 }
106 sigc::signal<void, const Glib::ustring&> signal_toggled()
107 {
108 return _signal_toggled;
109 }
111 sigc::signal<void, GdkEvent const *> signal_pre_toggle()
112 {
113 return _signal_pre_toggle;
114 }
116 Glib::PropertyProxy<bool> property_active() { return _property_active.get_proxy(); }
117 Glib::PropertyProxy<bool> property_activatable() { return _property_activatable.get_proxy(); }
118 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_on();
119 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_off();
120 // virtual Glib::PropertyProxy_Base _property_renderable(); //override
122 protected:
124 virtual void get_size_vfunc( Gtk::Widget& widget,
125 const Gdk::Rectangle* cell_area,
126 int* x_offset,
127 int* y_offset,
128 int* width,
129 int* height ) const
130 {
131 Gtk::CellRendererPixbuf::get_size_vfunc( widget, cell_area, x_offset, y_offset, width, height );
133 if ( width ) {
134 *width += (*width) >> 1;
135 }
136 if ( height ) {
137 *height += (*height) >> 1;
138 }
139 }
142 virtual void render_vfunc( const Glib::RefPtr<Gdk::Drawable>& window,
143 Gtk::Widget& widget,
144 const Gdk::Rectangle& background_area,
145 const Gdk::Rectangle& cell_area,
146 const Gdk::Rectangle& expose_area,
147 Gtk::CellRendererState flags )
148 {
149 property_pixbuf() = _property_active.get_value() ? _property_pixbuf_on : _property_pixbuf_off;
150 Gtk::CellRendererPixbuf::render_vfunc( window, widget, background_area, cell_area, expose_area, flags );
151 }
153 virtual bool activate_vfunc(GdkEvent* event,
154 Gtk::Widget& widget,
155 const Glib::ustring& path,
156 const Gdk::Rectangle& background_area,
157 const Gdk::Rectangle& cell_area,
158 Gtk::CellRendererState flags)
159 {
160 _signal_pre_toggle.emit(event);
161 _signal_toggled.emit(path);
163 return false;
164 }
167 private:
168 Glib::ustring _pixOnName;
169 Glib::ustring _pixOffName;
171 Glib::Property<bool> _property_active;
172 Glib::Property<bool> _property_activatable;
173 Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_on;
174 Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_off;
176 sigc::signal<void, const Glib::ustring&> _signal_toggled;
177 sigc::signal<void, GdkEvent const *> _signal_pre_toggle;
178 };
180 class LayersPanel::InternalUIBounce
181 {
182 public:
183 int _actionCode;
184 SPObject* _target;
185 };
187 static gboolean layers_panel_activated( GtkObject *object, GdkEvent * /*event*/, gpointer data )
188 {
189 if ( data )
190 {
191 LayersPanel* panel = reinterpret_cast<LayersPanel*>(data);
192 panel->setDesktop( SP_ACTIVE_DESKTOP );
193 }
195 return FALSE;
196 }
199 void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback )
200 {
201 bool set = false;
203 if ( iconName ) {
204 GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, iconName );
205 gtk_widget_show( child );
206 btn.add( *manage(Glib::wrap(child)) );
207 set = true;
208 }
210 if ( desktop ) {
211 Verb *verb = Verb::get( code );
212 if ( verb ) {
213 SPAction *action = verb->get_action(desktop);
214 if ( !set && action && action->image ) {
215 GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, action->image );
216 gtk_widget_show( child );
217 btn.add( *manage(Glib::wrap(child)) );
218 set = true;
219 }
221 if ( action && action->tip ) {
222 _tips.set_tip( btn, action->tip );
223 }
224 }
225 }
227 if ( !set && fallback ) {
228 btn.set_label( fallback );
229 }
230 }
233 Gtk::MenuItem& LayersPanel::_addPopupItem( SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback, int id )
234 {
235 GtkWidget* iconWidget = 0;
236 const char* label = 0;
238 if ( iconName ) {
239 iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, iconName );
240 }
242 if ( desktop ) {
243 Verb *verb = Verb::get( code );
244 if ( verb ) {
245 SPAction *action = verb->get_action(desktop);
246 if ( !iconWidget && action && action->image ) {
247 iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, action->image );
248 }
250 if ( action ) {
251 label = action->name;
252 }
253 }
254 }
256 if ( !label && fallback ) {
257 label = fallback;
258 }
260 Gtk::Widget* wrapped = 0;
261 if ( iconWidget ) {
262 wrapped = manage(Glib::wrap(iconWidget));
263 wrapped->show();
264 }
268 Gtk::Menu::MenuList& menulist = _popupMenu.items();
270 if ( wrapped ) {
271 menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem( label, *wrapped, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );
272 } else {
273 menulist.push_back( Gtk::Menu_Helpers::MenuElem( label, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );
274 }
275 return menulist.back();
276 }
278 void LayersPanel::_fireAction( unsigned int code )
279 {
280 if ( _desktop ) {
281 Verb *verb = Verb::get( code );
282 if ( verb ) {
283 SPAction *action = verb->get_action(_desktop);
284 if ( action ) {
285 sp_action_perform( action, NULL );
286 // } else {
287 // g_message("no action");
288 }
289 // } else {
290 // g_message("no verb for %u", code);
291 }
292 // } else {
293 // g_message("no active desktop");
294 }
295 }
297 // SP_VERB_LAYER_NEXT,
298 // SP_VERB_LAYER_PREV,
299 void LayersPanel::_takeAction( int val )
300 {
301 if ( !_pending ) {
302 _pending = new InternalUIBounce();
303 _pending->_actionCode = val;
304 _pending->_target = _selectedLayer();
305 Glib::signal_timeout().connect( sigc::mem_fun(*this, &LayersPanel::_executeAction), 0 );
306 }
307 }
309 bool LayersPanel::_executeAction()
310 {
311 // Make sure selected layer hasn't changed since the action was triggered
312 if ( _pending
313 && !( (_desktop && _desktop->currentLayer())
314 && (_desktop->currentLayer() != _pending->_target)
315 ) ) {
316 int val = _pending->_actionCode;
317 // SPObject* target = _pending->_target;
319 switch ( val ) {
320 case BUTTON_NEW:
321 {
322 _fireAction( SP_VERB_LAYER_NEW );
323 }
324 break;
325 case BUTTON_RENAME:
326 {
327 _fireAction( SP_VERB_LAYER_RENAME );
328 }
329 break;
330 case BUTTON_TOP:
331 {
332 _fireAction( SP_VERB_LAYER_TO_TOP );
333 }
334 break;
335 case BUTTON_BOTTOM:
336 {
337 _fireAction( SP_VERB_LAYER_TO_BOTTOM );
338 }
339 break;
340 case BUTTON_UP:
341 {
342 _fireAction( SP_VERB_LAYER_RAISE );
343 }
344 break;
345 case BUTTON_DOWN:
346 {
347 _fireAction( SP_VERB_LAYER_LOWER );
348 }
349 break;
350 case BUTTON_DELETE:
351 {
352 _fireAction( SP_VERB_LAYER_DELETE );
353 }
354 break;
355 }
357 delete _pending;
358 _pending = 0;
359 }
361 return false;
362 }
364 class LayersPanel::ModelColumns : public Gtk::TreeModel::ColumnRecord
365 {
366 public:
368 ModelColumns()
369 {
370 add(_colObject);
371 add(_colVisible);
372 add(_colLocked);
373 add(_colLabel);
374 }
375 virtual ~ModelColumns() {}
377 Gtk::TreeModelColumn<SPObject*> _colObject;
378 Gtk::TreeModelColumn<Glib::ustring> _colLabel;
379 Gtk::TreeModelColumn<bool> _colVisible;
380 Gtk::TreeModelColumn<bool> _colLocked;
381 };
383 void LayersPanel::_updateLayer( SPObject *layer ) {
384 _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) );
385 }
387 bool LayersPanel::_checkForUpdated(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
388 {
389 bool stopGoing = false;
390 Gtk::TreeModel::Row row = *iter;
391 Glib::ustring tmp = row[_model->_colLabel];
392 if ( layer == row[_model->_colObject] )
393 {
394 row[_model->_colLabel] = layer->label() ? layer->label() : SP_OBJECT_ID(layer);
395 row[_model->_colVisible] = SP_IS_ITEM(layer) ? !SP_ITEM(layer)->isHidden() : false;
396 row[_model->_colLocked] = SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false;
398 stopGoing = true;
399 }
401 return stopGoing;
402 }
404 void LayersPanel::_selectLayer( SPObject *layer ) {
405 if ( !layer || (_desktop && _desktop->doc() && (layer == _desktop->doc()->root)) ) {
406 if ( _tree.get_selection()->count_selected_rows() != 0 ) {
407 _tree.get_selection()->unselect_all();
408 }
409 } else {
410 _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForSelected), layer) );
411 }
413 _checkTreeSelection();
414 }
416 bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
417 {
418 bool stopGoing = false;
420 Gtk::TreeModel::Row row = *iter;
421 if ( layer == row[_model->_colObject] )
422 {
423 _tree.expand_to_path( path );
425 Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
427 select->select(iter);
429 stopGoing = true;
430 }
432 return stopGoing;
433 }
435 void LayersPanel::_layersChanged()
436 {
437 // g_message("_layersChanged()");
438 SPDocument* document = _desktop->doc();
439 SPObject* root = document->root;
440 if ( root ) {
441 if ( _mgr && _mgr->includes( root ) ) {
442 SPObject* target = _desktop->currentLayer();
443 _store->clear();
445 #if DUMP_LAYERS
446 g_message("root:%p {%s} [%s]", root, root->id, root->label() );
447 #endif // DUMP_LAYERS
448 _addLayer( document, root, 0, target, 0 );
449 }
450 }
451 }
453 void LayersPanel::_addLayer( SPDocument* doc, SPObject* layer, Gtk::TreeModel::Row* parentRow, SPObject* target, int level )
454 {
455 if ( layer && (level < _maxNestDepth) ) {
456 unsigned int counter = _mgr->childCount(layer);
457 for ( unsigned int i = 0; i < counter; i++ ) {
458 SPObject *child = _mgr->nthChildOf(layer, i);
459 if ( child ) {
460 #if DUMP_LAYERS
461 g_message(" %3d layer:%p {%s} [%s]", level, child, child->id, child->label() );
462 #endif // DUMP_LAYERS
464 Gtk::TreeModel::iterator iter = parentRow ? _store->prepend(parentRow->children()) : _store->prepend();
465 Gtk::TreeModel::Row row = *iter;
466 row[_model->_colObject] = child;
467 row[_model->_colLabel] = child->label() ? child->label() : SP_OBJECT_ID(child);
468 row[_model->_colVisible] = SP_IS_ITEM(child) ? !SP_ITEM(child)->isHidden() : false;
469 row[_model->_colLocked] = SP_IS_ITEM(child) ? SP_ITEM(child)->isLocked() : false;
471 if ( target && child == target ) {
472 _tree.expand_to_path( _store->get_path(iter) );
474 Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
475 select->select(iter);
477 _checkTreeSelection();
478 }
480 _addLayer( doc, child, &row, target, level + 1 );
481 }
482 }
483 }
484 }
486 SPObject* LayersPanel::_selectedLayer()
487 {
488 SPObject* obj = 0;
490 Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();
491 if ( iter ) {
492 Gtk::TreeModel::Row row = *iter;
493 obj = row[_model->_colObject];
494 }
496 return obj;
497 }
499 void LayersPanel::_pushTreeSelectionToCurrent()
500 {
501 SPObject* inTree = _selectedLayer();
502 // TODO hunt down the possible API abuse in getting NULL
503 if ( _desktop->currentRoot() ) {
504 if ( inTree ) {
505 SPObject* curr = _desktop->currentLayer();
506 if ( curr != inTree ) {
507 _mgr->setCurrentLayer( inTree );
508 }
509 } else {
510 _mgr->setCurrentLayer( _desktop->doc()->root );
511 }
512 }
513 }
515 void LayersPanel::_checkTreeSelection()
516 {
517 bool sensitive = false;
518 bool sensitiveNonTop = false;
519 bool sensitiveNonBottom = false;
520 if ( _tree.get_selection()->count_selected_rows() > 0 ) {
521 sensitive = true;
523 SPObject* inTree = _selectedLayer();
524 if ( inTree ) {
526 sensitiveNonTop = (Inkscape::next_layer(inTree->parent, inTree) != 0);
527 sensitiveNonBottom = (Inkscape::previous_layer(inTree->parent, inTree) != 0);
528 }
529 }
531 for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
532 (*it)->set_sensitive( sensitive );
533 }
534 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {
535 (*it)->set_sensitive( sensitiveNonTop );
536 }
537 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {
538 (*it)->set_sensitive( sensitiveNonBottom );
539 }
540 }
542 void LayersPanel::_preToggle( GdkEvent const *event )
543 {
544 if ( _toggleEvent ) {
545 gdk_event_free(_toggleEvent);
546 _toggleEvent = 0;
547 }
549 if ( event && (event->type == GDK_BUTTON_PRESS) ) {
550 // Make a copy so we can keep it around.
551 _toggleEvent = gdk_event_copy(const_cast<GdkEvent*>(event));
552 }
553 }
555 void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
556 {
557 Gtk::TreeModel::Children::iterator iter = _tree.get_model()->get_iter(str);
558 Gtk::TreeModel::Row row = *iter;
560 Glib::ustring tmp = row[_model->_colLabel];
562 SPObject* obj = row[_model->_colObject];
563 SPItem* item = ( obj && SP_IS_ITEM(obj) ) ? SP_ITEM(obj) : 0;
564 if ( item ) {
565 switch ( targetCol ) {
566 case COL_VISIBLE:
567 {
568 bool newValue = !row[_model->_colVisible];
569 row[_model->_colVisible] = newValue;
570 item->setHidden( !newValue );
571 item->updateRepr();
572 sp_document_done( _desktop->doc() );
573 }
574 break;
576 case COL_LOCKED:
577 {
578 bool newValue = !row[_model->_colLocked];
579 row[_model->_colLocked] = newValue;
580 item->setLocked( newValue );
581 item->updateRepr();
582 sp_document_done( _desktop->doc() );
583 }
584 break;
585 }
586 }
587 }
589 void LayersPanel::_handleButtonEvent(GdkEventButton* evt)
590 {
591 // TODO - fix to a better is-popup function
592 if ( (evt->type == GDK_BUTTON_PRESS) && (evt->button == 3) ) {
595 {
596 Gtk::TreeModel::Path path;
597 Gtk::TreeViewColumn* col = 0;
598 int x = static_cast<int>(evt->x);
599 int y = static_cast<int>(evt->y);
600 int x2 = 0;
601 int y2 = 0;
602 if ( _tree.get_path_at_pos( x, y,
603 path, col,
604 x2, y2 ) ) {
605 _checkTreeSelection();
606 _popupMenu.popup(evt->button, evt->time);
607 }
608 }
610 }
611 }
613 void LayersPanel::_handleRowChange( Gtk::TreeModel::Path const& path, Gtk::TreeModel::iterator const& iter )
614 {
615 Gtk::TreeModel::Row row = *iter;
616 if ( row ) {
617 SPObject* obj = row[_model->_colObject];
618 if ( obj ) {
619 gchar const* oldLabel = obj->label();
620 Glib::ustring tmp = row[_model->_colLabel];
621 if ( oldLabel && oldLabel[0] && !tmp.empty() && (tmp != oldLabel) ) {
622 _mgr->renameLayer( obj, tmp.c_str() );
623 row[_model->_colLabel] = obj->label();
624 }
625 }
626 }
627 }
629 bool LayersPanel::_rowSelectFunction( Glib::RefPtr<Gtk::TreeModel> const & model, Gtk::TreeModel::Path const & path, bool currentlySelected )
630 {
631 bool val = true;
632 if ( !currentlySelected && _toggleEvent )
633 {
634 GdkEvent* event = gtk_get_current_event();
635 if ( event ) {
636 // (keep these checks separate, so we know when to call gdk_event_free()
637 if ( event->type == GDK_BUTTON_PRESS ) {
638 GdkEventButton const* target = reinterpret_cast<GdkEventButton const*>(_toggleEvent);
639 GdkEventButton const* evtb = reinterpret_cast<GdkEventButton const*>(event);
641 if ( (evtb->window == target->window)
642 && (evtb->send_event == target->send_event)
643 && (evtb->time == target->time)
644 && (evtb->state == target->state)
645 )
646 {
647 // Ooooh! It's a magic one
648 val = false;
649 }
650 }
651 gdk_event_free(event);
652 }
653 }
654 return val;
655 }
657 /**
658 * Constructor
659 */
660 LayersPanel::LayersPanel() :
661 Inkscape::UI::Widget::Panel( Glib::ustring(), "dialogs.layers" ),
662 _maxNestDepth(20),
663 _mgr(0),
664 _desktop(0),
665 _model(0),
666 _pending(0),
667 _toggleEvent(0)
668 {
669 _maxNestDepth = prefs_get_int_attribute_limited("dialogs.layers", "maxDepth", 20, 1, 1000);
671 ModelColumns *zoop = new ModelColumns();
672 _model = zoop;
674 _store = Gtk::TreeStore::create( *zoop );
676 _tree.set_model( _store );
677 _tree.set_headers_visible(false);
679 ImageToggler* eyeRenderer = manage( new ImageToggler("visible", "hidden") );
680 int visibleColNum = _tree.append_column("vis", *eyeRenderer) - 1;
681 eyeRenderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
682 eyeRenderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) );
683 eyeRenderer->property_activatable() = true;
684 Gtk::TreeViewColumn* col = _tree.get_column(visibleColNum);
685 if ( col ) {
686 col->add_attribute( eyeRenderer->property_active(), _model->_colVisible );
687 }
689 ImageToggler * renderer = manage( new ImageToggler("width_height_lock", "lock_unlocked") );
690 int lockedColNum = _tree.append_column("lock", *renderer) - 1;
691 renderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
692 renderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) );
693 renderer->property_activatable() = true;
694 col = _tree.get_column(lockedColNum);
695 if ( col ) {
696 col->add_attribute( renderer->property_active(), _model->_colLocked );
697 }
699 int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;
701 _tree.set_expander_column( *_tree.get_column(nameColNum) );
704 _tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_pushTreeSelectionToCurrent) );
705 _tree.get_selection()->set_select_function( sigc::mem_fun(*this, &LayersPanel::_rowSelectFunction) );
707 _tree.get_model()->signal_row_changed().connect( sigc::mem_fun(*this, &LayersPanel::_handleRowChange) );
708 _tree.signal_button_press_event().connect_notify( sigc::mem_fun(*this, &LayersPanel::_handleButtonEvent) );
710 _scroller.add( _tree );
711 _scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );
712 _getContents()->pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );
713 _getContents()->pack_end(_buttonsRow, Gtk::PACK_SHRINK);
715 SPDesktop* targetDesktop = SP_ACTIVE_DESKTOP;
717 _buttonsRow.set_child_min_width( 16 );
719 Gtk::Button* btn = manage( new Gtk::Button() );
720 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_NEW, GTK_STOCK_ADD, _("New") );
721 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_NEW) );
722 _buttonsRow.add( *btn );
724 btn = manage( new Gtk::Button() );
725 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_TOP, GTK_STOCK_GOTO_TOP, _("Top") );
726 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_TOP) );
727 _watchingNonTop.push_back( btn );
728 _buttonsRow.add( *btn );
730 btn = manage( new Gtk::Button() );
731 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, _("Up") );
732 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_UP) );
733 _watchingNonTop.push_back( btn );
734 _buttonsRow.add( *btn );
736 btn = manage( new Gtk::Button() );
737 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, _("Dn") );
738 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DOWN) );
739 _watchingNonBottom.push_back( btn );
740 _buttonsRow.add( *btn );
742 btn = manage( new Gtk::Button() );
743 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_BOTTOM, GTK_STOCK_GOTO_BOTTOM, _("Bot") );
744 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_BOTTOM) );
745 _watchingNonBottom.push_back( btn );
746 _buttonsRow.add( *btn );
748 // btn = manage( new Gtk::Button("Dup") );
749 // btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DUPLICATE) );
750 // _buttonsRow.add( *btn );
752 btn = manage( new Gtk::Button() );
753 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_DELETE, GTK_STOCK_REMOVE, _("X") );
754 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DELETE) );
755 _watching.push_back( btn );
756 _buttonsRow.add( *btn );
761 // -------------------------------------------------------
762 {
763 _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RENAME, 0, "Rename", (int)BUTTON_RENAME ) );
764 _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_NEW, 0, "New", (int)BUTTON_NEW ) );
766 _popupMenu.items().push_back( Gtk::Menu_Helpers::SeparatorElem() );
768 _watchingNonTop.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, "Up", (int)BUTTON_UP ) );
769 _watchingNonBottom.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, "Down", (int)BUTTON_DOWN ) );
771 _popupMenu.show_all_children();
772 }
773 // -------------------------------------------------------
777 for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
778 (*it)->set_sensitive( false );
779 }
780 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {
781 (*it)->set_sensitive( false );
782 }
783 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {
784 (*it)->set_sensitive( false );
785 }
787 g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this );
790 setDesktop( targetDesktop );
794 show_all_children();
796 restorePanelPrefs();
797 }
799 LayersPanel::~LayersPanel()
800 {
801 if ( _model )
802 {
803 delete _model;
804 }
806 if ( _toggleEvent )
807 {
808 gdk_event_free( _toggleEvent );
809 _toggleEvent = 0;
810 }
811 }
814 void LayersPanel::setDesktop( SPDesktop* desktop )
815 {
816 if ( desktop != _desktop ) {
817 _layerChangedConnection.disconnect();
818 _layerUpdatedConnection.disconnect();
819 _changedConnection.disconnect();
820 if ( _mgr ) {
821 _mgr = 0;
822 }
823 if ( _desktop ) {
824 _desktop = 0;
825 }
827 _desktop = SP_ACTIVE_DESKTOP;
828 if ( _desktop ) {
829 setLabel( _desktop->doc()->name );
831 _mgr = _desktop->layer_manager;
832 if ( _mgr ) {
833 _layerChangedConnection = _mgr->connectCurrentLayerChanged( sigc::mem_fun(*this, &LayersPanel::_selectLayer) );
834 _layerUpdatedConnection = _mgr->connectLayerDetailsChanged( sigc::mem_fun(*this, &LayersPanel::_updateLayer) );
835 _changedConnection = _mgr->connectChanged( sigc::mem_fun(*this, &LayersPanel::_layersChanged) );
836 }
838 _layersChanged();
839 }
840 }
841 /*
842 GSList const *layers=sp_document_get_resource_list( _desktop->doc(), "layer" );
843 g_message( "layers list starts at %p", layers );
844 for ( GSList const *iter=layers ; iter ; iter = iter->next ) {
845 SPObject *layer=static_cast<SPObject *>(iter->data);
846 g_message(" {%s} [%s]", layer->id, layer->label() );
847 }
848 */
849 }
853 } //namespace Dialogs
854 } //namespace UI
855 } //namespace Inkscape
858 /*
859 Local Variables:
860 mode:c++
861 c-file-style:"stroustrup"
862 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
863 indent-tabs-mode:nil
864 fill-column:99
865 End:
866 */
867 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :