383d11f57b0e54a0559bd418c21ce9e09bf2fa6b
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"
37 #include "xml/repr.h"
38 #include "svg/css-ostringstream.h"
39 #include "desktop-style.h"
41 //#define DUMP_LAYERS 1
43 namespace Inkscape {
44 namespace UI {
45 namespace Dialogs {
47 LayersPanel* LayersPanel::instance = 0;
49 LayersPanel*
50 LayersPanel::create(Inkscape::UI::Dialog::Behavior::BehaviorFactory behavior_factory)
51 {
52 if ( !instance ) {
53 instance = new LayersPanel(behavior_factory);
54 }
56 return instance;
57 }
59 enum {
60 COL_VISIBLE = 1,
61 COL_LOCKED
62 };
64 enum {
65 BUTTON_NEW = 0,
66 BUTTON_RENAME,
67 BUTTON_TOP,
68 BUTTON_BOTTOM,
69 BUTTON_UP,
70 BUTTON_DOWN,
71 // BUTTON_DUPLICATE,
72 BUTTON_DELETE
73 };
75 class ImageToggler : public Gtk::CellRendererPixbuf {
76 public:
77 ImageToggler( char const* on, char const* off) :
78 Glib::ObjectBase(typeid(ImageToggler)),
79 Gtk::CellRendererPixbuf(),
80 _pixOnName(on),
81 _pixOffName(off),
82 _property_active(*this, "active", false),
83 _property_activatable(*this, "activatable", true),
84 _property_pixbuf_on(*this, "pixbuf_on", Glib::RefPtr<Gdk::Pixbuf>(0)),
85 _property_pixbuf_off(*this, "pixbuf_off", Glib::RefPtr<Gdk::Pixbuf>(0))
86 {
87 property_mode() = Gtk::CELL_RENDERER_MODE_ACTIVATABLE;
89 Gtk::Widget* thingie = sp_icon_get_icon(_pixOnName.c_str(), Inkscape::ICON_SIZE_DECORATION);
90 if ( thingie ) {
91 if ( SP_IS_ICON(thingie->gobj()) ) {
92 SPIcon* icon = SP_ICON(thingie->gobj());
93 sp_icon_fetch_pixbuf( icon );
94 _property_pixbuf_on = Glib::wrap( icon->pb, true );
95 }
96 delete thingie;
97 }
98 thingie = sp_icon_get_icon(_pixOffName.c_str(), Inkscape::ICON_SIZE_DECORATION);
99 if ( thingie ) {
100 if ( SP_IS_ICON(thingie->gobj()) ) {
101 SPIcon* icon = SP_ICON(thingie->gobj());
102 sp_icon_fetch_pixbuf( icon );
103 _property_pixbuf_off = Glib::wrap( icon->pb, true );
104 }
105 delete thingie;
106 }
107 property_pixbuf() = _property_pixbuf_off.get_value();
108 }
110 sigc::signal<void, const Glib::ustring&> signal_toggled()
111 {
112 return _signal_toggled;
113 }
115 sigc::signal<void, GdkEvent const *> signal_pre_toggle()
116 {
117 return _signal_pre_toggle;
118 }
120 Glib::PropertyProxy<bool> property_active() { return _property_active.get_proxy(); }
121 Glib::PropertyProxy<bool> property_activatable() { return _property_activatable.get_proxy(); }
122 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_on();
123 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_off();
124 // virtual Glib::PropertyProxy_Base _property_renderable(); //override
126 protected:
128 virtual void get_size_vfunc( Gtk::Widget& widget,
129 const Gdk::Rectangle* cell_area,
130 int* x_offset,
131 int* y_offset,
132 int* width,
133 int* height ) const
134 {
135 Gtk::CellRendererPixbuf::get_size_vfunc( widget, cell_area, x_offset, y_offset, width, height );
137 if ( width ) {
138 *width += (*width) >> 1;
139 }
140 if ( height ) {
141 *height += (*height) >> 1;
142 }
143 }
146 virtual void render_vfunc( const Glib::RefPtr<Gdk::Drawable>& window,
147 Gtk::Widget& widget,
148 const Gdk::Rectangle& background_area,
149 const Gdk::Rectangle& cell_area,
150 const Gdk::Rectangle& expose_area,
151 Gtk::CellRendererState flags )
152 {
153 property_pixbuf() = _property_active.get_value() ? _property_pixbuf_on : _property_pixbuf_off;
154 Gtk::CellRendererPixbuf::render_vfunc( window, widget, background_area, cell_area, expose_area, flags );
155 }
157 virtual bool activate_vfunc(GdkEvent* event,
158 Gtk::Widget& widget,
159 const Glib::ustring& path,
160 const Gdk::Rectangle& background_area,
161 const Gdk::Rectangle& cell_area,
162 Gtk::CellRendererState flags)
163 {
164 _signal_pre_toggle.emit(event);
165 _signal_toggled.emit(path);
167 return false;
168 }
171 private:
172 Glib::ustring _pixOnName;
173 Glib::ustring _pixOffName;
175 Glib::Property<bool> _property_active;
176 Glib::Property<bool> _property_activatable;
177 Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_on;
178 Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_off;
180 sigc::signal<void, const Glib::ustring&> _signal_toggled;
181 sigc::signal<void, GdkEvent const *> _signal_pre_toggle;
182 };
184 class LayersPanel::InternalUIBounce
185 {
186 public:
187 int _actionCode;
188 SPObject* _target;
189 };
191 static gboolean layers_panel_activated( GtkObject *object, GdkEvent * /*event*/, gpointer data )
192 {
193 if ( data )
194 {
195 LayersPanel* panel = reinterpret_cast<LayersPanel*>(data);
196 panel->setDesktop( SP_ACTIVE_DESKTOP );
197 }
199 return FALSE;
200 }
203 void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback )
204 {
205 bool set = false;
207 if ( iconName ) {
208 GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, iconName );
209 gtk_widget_show( child );
210 btn.add( *manage(Glib::wrap(child)) );
211 set = true;
212 }
214 if ( desktop ) {
215 Verb *verb = Verb::get( code );
216 if ( verb ) {
217 SPAction *action = verb->get_action(desktop);
218 if ( !set && action && action->image ) {
219 GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, action->image );
220 gtk_widget_show( child );
221 btn.add( *manage(Glib::wrap(child)) );
222 set = true;
223 }
225 if ( action && action->tip ) {
226 _tips.set_tip( btn, action->tip );
227 }
228 }
229 }
231 if ( !set && fallback ) {
232 btn.set_label( fallback );
233 }
234 }
237 Gtk::MenuItem& LayersPanel::_addPopupItem( SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback, int id )
238 {
239 GtkWidget* iconWidget = 0;
240 const char* label = 0;
242 if ( iconName ) {
243 iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, iconName );
244 }
246 if ( desktop ) {
247 Verb *verb = Verb::get( code );
248 if ( verb ) {
249 SPAction *action = verb->get_action(desktop);
250 if ( !iconWidget && action && action->image ) {
251 iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, action->image );
252 }
254 if ( action ) {
255 label = action->name;
256 }
257 }
258 }
260 if ( !label && fallback ) {
261 label = fallback;
262 }
264 Gtk::Widget* wrapped = 0;
265 if ( iconWidget ) {
266 wrapped = manage(Glib::wrap(iconWidget));
267 wrapped->show();
268 }
272 Gtk::Menu::MenuList& menulist = _popupMenu.items();
274 if ( wrapped ) {
275 menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem( label, *wrapped, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );
276 } else {
277 menulist.push_back( Gtk::Menu_Helpers::MenuElem( label, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );
278 }
279 return menulist.back();
280 }
282 void LayersPanel::_fireAction( unsigned int code )
283 {
284 if ( _desktop ) {
285 Verb *verb = Verb::get( code );
286 if ( verb ) {
287 SPAction *action = verb->get_action(_desktop);
288 if ( action ) {
289 sp_action_perform( action, NULL );
290 // } else {
291 // g_message("no action");
292 }
293 // } else {
294 // g_message("no verb for %u", code);
295 }
296 // } else {
297 // g_message("no active desktop");
298 }
299 }
301 // SP_VERB_LAYER_NEXT,
302 // SP_VERB_LAYER_PREV,
303 void LayersPanel::_takeAction( int val )
304 {
305 if ( !_pending ) {
306 _pending = new InternalUIBounce();
307 _pending->_actionCode = val;
308 _pending->_target = _selectedLayer();
309 Glib::signal_timeout().connect( sigc::mem_fun(*this, &LayersPanel::_executeAction), 0 );
310 }
311 }
313 bool LayersPanel::_executeAction()
314 {
315 // Make sure selected layer hasn't changed since the action was triggered
316 if ( _pending
317 && (
318 (_pending->_actionCode == BUTTON_NEW)
319 || !( (_desktop && _desktop->currentLayer())
320 && (_desktop->currentLayer() != _pending->_target)
321 )
322 )
323 ) {
324 int val = _pending->_actionCode;
325 // SPObject* target = _pending->_target;
327 switch ( val ) {
328 case BUTTON_NEW:
329 {
330 _fireAction( SP_VERB_LAYER_NEW );
331 }
332 break;
333 case BUTTON_RENAME:
334 {
335 _fireAction( SP_VERB_LAYER_RENAME );
336 }
337 break;
338 case BUTTON_TOP:
339 {
340 _fireAction( SP_VERB_LAYER_TO_TOP );
341 }
342 break;
343 case BUTTON_BOTTOM:
344 {
345 _fireAction( SP_VERB_LAYER_TO_BOTTOM );
346 }
347 break;
348 case BUTTON_UP:
349 {
350 _fireAction( SP_VERB_LAYER_RAISE );
351 }
352 break;
353 case BUTTON_DOWN:
354 {
355 _fireAction( SP_VERB_LAYER_LOWER );
356 }
357 break;
358 case BUTTON_DELETE:
359 {
360 _fireAction( SP_VERB_LAYER_DELETE );
361 }
362 break;
363 }
365 delete _pending;
366 _pending = 0;
367 }
369 return false;
370 }
372 class LayersPanel::ModelColumns : public Gtk::TreeModel::ColumnRecord
373 {
374 public:
376 ModelColumns()
377 {
378 add(_colObject);
379 add(_colVisible);
380 add(_colLocked);
381 add(_colLabel);
382 }
383 virtual ~ModelColumns() {}
385 Gtk::TreeModelColumn<SPObject*> _colObject;
386 Gtk::TreeModelColumn<Glib::ustring> _colLabel;
387 Gtk::TreeModelColumn<bool> _colVisible;
388 Gtk::TreeModelColumn<bool> _colLocked;
389 };
391 void LayersPanel::_updateLayer( SPObject *layer ) {
392 _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) );
393 }
395 bool LayersPanel::_checkForUpdated(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
396 {
397 bool stopGoing = false;
398 Gtk::TreeModel::Row row = *iter;
399 Glib::ustring tmp = row[_model->_colLabel];
400 if ( layer == row[_model->_colObject] )
401 {
402 row[_model->_colLabel] = layer->label() ? layer->label() : SP_OBJECT_ID(layer);
403 row[_model->_colVisible] = SP_IS_ITEM(layer) ? !SP_ITEM(layer)->isHidden() : false;
404 row[_model->_colLocked] = SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false;
406 stopGoing = true;
407 }
409 return stopGoing;
410 }
412 void LayersPanel::_selectLayer( SPObject *layer ) {
413 if ( !layer || (_desktop && _desktop->doc() && (layer == _desktop->doc()->root)) ) {
414 if ( _tree.get_selection()->count_selected_rows() != 0 ) {
415 _tree.get_selection()->unselect_all();
416 }
417 } else {
418 _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForSelected), layer) );
419 }
421 _checkTreeSelection();
422 }
424 bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
425 {
426 bool stopGoing = false;
428 Gtk::TreeModel::Row row = *iter;
429 if ( layer == row[_model->_colObject] )
430 {
431 _tree.expand_to_path( path );
433 Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
435 select->select(iter);
437 stopGoing = true;
438 }
440 return stopGoing;
441 }
443 void LayersPanel::_layersChanged()
444 {
445 // g_message("_layersChanged()");
446 SPDocument* document = _desktop->doc();
447 SPObject* root = document->root;
448 if ( root ) {
449 _selectedConnection.block();
450 if ( _mgr && _mgr->includes( root ) ) {
451 SPObject* target = _desktop->currentLayer();
452 _store->clear();
454 #if DUMP_LAYERS
455 g_message("root:%p {%s} [%s]", root, root->id, root->label() );
456 #endif // DUMP_LAYERS
457 _addLayer( document, root, 0, target, 0 );
458 }
459 _selectedConnection.unblock();
460 }
461 }
463 void LayersPanel::_addLayer( SPDocument* doc, SPObject* layer, Gtk::TreeModel::Row* parentRow, SPObject* target, int level )
464 {
465 if ( layer && (level < _maxNestDepth) ) {
466 unsigned int counter = _mgr->childCount(layer);
467 for ( unsigned int i = 0; i < counter; i++ ) {
468 SPObject *child = _mgr->nthChildOf(layer, i);
469 if ( child ) {
470 #if DUMP_LAYERS
471 g_message(" %3d layer:%p {%s} [%s]", level, child, child->id, child->label() );
472 #endif // DUMP_LAYERS
474 Gtk::TreeModel::iterator iter = parentRow ? _store->prepend(parentRow->children()) : _store->prepend();
475 Gtk::TreeModel::Row row = *iter;
476 row[_model->_colObject] = child;
477 row[_model->_colLabel] = child->label() ? child->label() : SP_OBJECT_ID(child);
478 row[_model->_colVisible] = SP_IS_ITEM(child) ? !SP_ITEM(child)->isHidden() : false;
479 row[_model->_colLocked] = SP_IS_ITEM(child) ? SP_ITEM(child)->isLocked() : false;
481 if ( target && child == target ) {
482 _tree.expand_to_path( _store->get_path(iter) );
484 Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
485 select->select(iter);
487 _checkTreeSelection();
488 }
490 _addLayer( doc, child, &row, target, level + 1 );
491 }
492 }
493 }
494 }
496 SPObject* LayersPanel::_selectedLayer()
497 {
498 SPObject* obj = 0;
500 Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();
501 if ( iter ) {
502 Gtk::TreeModel::Row row = *iter;
503 obj = row[_model->_colObject];
504 }
506 return obj;
507 }
509 void LayersPanel::_pushTreeSelectionToCurrent()
510 {
511 SPObject* inTree = _selectedLayer();
512 // TODO hunt down the possible API abuse in getting NULL
513 if ( _desktop->currentRoot() ) {
514 if ( inTree ) {
515 SPObject* curr = _desktop->currentLayer();
516 if ( curr != inTree ) {
517 _mgr->setCurrentLayer( inTree );
518 }
519 } else {
520 _mgr->setCurrentLayer( _desktop->doc()->root );
521 }
522 }
523 }
525 void LayersPanel::_checkTreeSelection()
526 {
527 bool sensitive = false;
528 bool sensitiveNonTop = false;
529 bool sensitiveNonBottom = false;
530 if ( _tree.get_selection()->count_selected_rows() > 0 ) {
531 sensitive = true;
533 SPObject* inTree = _selectedLayer();
534 if ( inTree ) {
536 sensitiveNonTop = (Inkscape::next_layer(inTree->parent, inTree) != 0);
537 sensitiveNonBottom = (Inkscape::previous_layer(inTree->parent, inTree) != 0);
539 if ( inTree->repr ) {
540 SPCSSAttr *css = sp_repr_css_attr(inTree->repr, "style");
541 if ( css ) {
542 _opacityConnection.block();
543 _opacity.set_value( sp_repr_css_double_property( css, "opacity", 1.0 ) * 100 );
544 _opacityConnection.unblock();
545 }
546 }
547 }
548 }
551 for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
552 (*it)->set_sensitive( sensitive );
553 }
554 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {
555 (*it)->set_sensitive( sensitiveNonTop );
556 }
557 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {
558 (*it)->set_sensitive( sensitiveNonBottom );
559 }
560 }
562 void LayersPanel::_preToggle( GdkEvent const *event )
563 {
564 if ( _toggleEvent ) {
565 gdk_event_free(_toggleEvent);
566 _toggleEvent = 0;
567 }
569 if ( event && (event->type == GDK_BUTTON_PRESS) ) {
570 // Make a copy so we can keep it around.
571 _toggleEvent = gdk_event_copy(const_cast<GdkEvent*>(event));
572 }
573 }
575 void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
576 {
577 Gtk::TreeModel::Children::iterator iter = _tree.get_model()->get_iter(str);
578 Gtk::TreeModel::Row row = *iter;
580 Glib::ustring tmp = row[_model->_colLabel];
582 SPObject* obj = row[_model->_colObject];
583 SPItem* item = ( obj && SP_IS_ITEM(obj) ) ? SP_ITEM(obj) : 0;
584 if ( item ) {
585 switch ( targetCol ) {
586 case COL_VISIBLE:
587 {
588 bool newValue = !row[_model->_colVisible];
589 row[_model->_colVisible] = newValue;
590 item->setHidden( !newValue );
591 item->updateRepr();
592 sp_document_done( _desktop->doc() , SP_VERB_DIALOG_LAYERS,
593 newValue? _("Unhide layer") : _("Hide layer"));
594 }
595 break;
597 case COL_LOCKED:
598 {
599 bool newValue = !row[_model->_colLocked];
600 row[_model->_colLocked] = newValue;
601 item->setLocked( newValue );
602 item->updateRepr();
603 sp_document_done( _desktop->doc() , SP_VERB_DIALOG_LAYERS,
604 newValue? _("Lock layer") : _("Unlock layer"));
605 }
606 break;
607 }
608 }
609 }
611 void LayersPanel::_handleButtonEvent(GdkEventButton* evt)
612 {
613 // TODO - fix to a better is-popup function
614 if ( (evt->type == GDK_BUTTON_PRESS) && (evt->button == 3) ) {
617 {
618 Gtk::TreeModel::Path path;
619 Gtk::TreeViewColumn* col = 0;
620 int x = static_cast<int>(evt->x);
621 int y = static_cast<int>(evt->y);
622 int x2 = 0;
623 int y2 = 0;
624 if ( _tree.get_path_at_pos( x, y,
625 path, col,
626 x2, y2 ) ) {
627 _checkTreeSelection();
628 _popupMenu.popup(evt->button, evt->time);
629 }
630 }
632 }
633 }
635 void LayersPanel::_handleRowChange( Gtk::TreeModel::Path const& path, Gtk::TreeModel::iterator const& iter )
636 {
637 Gtk::TreeModel::Row row = *iter;
638 if ( row ) {
639 SPObject* obj = row[_model->_colObject];
640 if ( obj ) {
641 gchar const* oldLabel = obj->label();
642 Glib::ustring tmp = row[_model->_colLabel];
643 if ( oldLabel && oldLabel[0] && !tmp.empty() && (tmp != oldLabel) ) {
644 _mgr->renameLayer( obj, tmp.c_str() );
645 row[_model->_colLabel] = obj->label();
646 }
647 }
648 }
649 }
651 bool LayersPanel::_rowSelectFunction( Glib::RefPtr<Gtk::TreeModel> const & model, Gtk::TreeModel::Path const & path, bool currentlySelected )
652 {
653 bool val = true;
654 if ( !currentlySelected && _toggleEvent )
655 {
656 GdkEvent* event = gtk_get_current_event();
657 if ( event ) {
658 // (keep these checks separate, so we know when to call gdk_event_free()
659 if ( event->type == GDK_BUTTON_PRESS ) {
660 GdkEventButton const* target = reinterpret_cast<GdkEventButton const*>(_toggleEvent);
661 GdkEventButton const* evtb = reinterpret_cast<GdkEventButton const*>(event);
663 if ( (evtb->window == target->window)
664 && (evtb->send_event == target->send_event)
665 && (evtb->time == target->time)
666 && (evtb->state == target->state)
667 )
668 {
669 // Ooooh! It's a magic one
670 val = false;
671 }
672 }
673 gdk_event_free(event);
674 }
675 }
676 return val;
677 }
680 void LayersPanel::_opacityChanged()
681 {
682 SPObject* layer = _selectedLayer();
684 if ( _desktop && layer && !_opacityConnection.blocked() ) {
685 _opacityConnection.block();
687 Gtk::Adjustment* adj = _opacity.get_adjustment();
688 SPCSSAttr *css = sp_repr_css_attr_new();
690 Inkscape::CSSOStringStream os;
691 os << CLAMP( adj->get_value() / 100, 0.0, 1.0 );
692 sp_repr_css_set_property( css, "opacity", os.str().c_str() );
694 sp_desktop_apply_css_recursive( layer, css, true );
695 layer->updateRepr();
697 sp_repr_css_attr_unref( css );
699 sp_document_maybe_done( _desktop->doc(), "layers:opacity", SP_VERB_DIALOG_LAYERS,
700 _("Change layer opacity"));
702 _opacityConnection.unblock();
703 }
704 }
708 /**
709 * Constructor
710 */
711 LayersPanel::LayersPanel(Inkscape::UI::Dialog::Behavior::BehaviorFactory behavior_factory) :
712 Inkscape::UI::Dialog::Dialog(behavior_factory, "dialogs.layers", SP_VERB_DIALOG_LAYERS),
713 _maxNestDepth(20),
714 _mgr(0),
715 _desktop(0),
716 _model(0),
717 _pending(0),
718 _toggleEvent(0)
719 {
720 _maxNestDepth = prefs_get_int_attribute_limited("dialogs.layers", "maxDepth", 20, 1, 1000);
722 ModelColumns *zoop = new ModelColumns();
723 _model = zoop;
725 _store = Gtk::TreeStore::create( *zoop );
727 _tree.set_model( _store );
728 _tree.set_headers_visible(false);
730 ImageToggler* eyeRenderer = manage( new ImageToggler("visible", "hidden") );
731 int visibleColNum = _tree.append_column("vis", *eyeRenderer) - 1;
732 eyeRenderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
733 eyeRenderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) );
734 eyeRenderer->property_activatable() = true;
735 Gtk::TreeViewColumn* col = _tree.get_column(visibleColNum);
736 if ( col ) {
737 col->add_attribute( eyeRenderer->property_active(), _model->_colVisible );
738 }
740 ImageToggler * renderer = manage( new ImageToggler("width_height_lock", "lock_unlocked") );
741 int lockedColNum = _tree.append_column("lock", *renderer) - 1;
742 renderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
743 renderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) );
744 renderer->property_activatable() = true;
745 col = _tree.get_column(lockedColNum);
746 if ( col ) {
747 col->add_attribute( renderer->property_active(), _model->_colLocked );
748 }
750 int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;
752 _tree.set_expander_column( *_tree.get_column(nameColNum) );
755 _selectedConnection = _tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_pushTreeSelectionToCurrent) );
756 _tree.get_selection()->set_select_function( sigc::mem_fun(*this, &LayersPanel::_rowSelectFunction) );
758 _tree.get_model()->signal_row_changed().connect( sigc::mem_fun(*this, &LayersPanel::_handleRowChange) );
759 _tree.signal_button_press_event().connect_notify( sigc::mem_fun(*this, &LayersPanel::_handleButtonEvent) );
761 _scroller.add( _tree );
762 _scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );
765 _opacityBox.pack_start( *manage( new Gtk::Label(_("Opacity, %:"))), Gtk::PACK_SHRINK );
767 _opacity.set_draw_value(false);
768 _opacity.set_value(100.0);
769 _opacity.set_range(0.0, 100.0);
770 _opacity.set_increments(1, 10);
771 _opacityBox.pack_start( _opacity, Gtk::PACK_EXPAND_WIDGET );
773 _spinBtn.configure(*_opacity.get_adjustment(), 0, 1);
775 _spinBtn.set_width_chars(5);
776 _opacityBox.pack_end( _spinBtn, Gtk::PACK_SHRINK );
777 _watching.push_back( &_opacityBox );
779 get_vbox()->pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );
781 get_vbox()->pack_end(_opacityBox, Gtk::PACK_SHRINK);
782 get_vbox()->pack_end(_buttonsRow, Gtk::PACK_SHRINK);
784 _opacityConnection = _opacity.get_adjustment()->signal_value_changed().connect( sigc::mem_fun(*this, &LayersPanel::_opacityChanged) );
786 SPDesktop* targetDesktop = SP_ACTIVE_DESKTOP;
788 _buttonsRow.set_child_min_width( 16 );
790 Gtk::Button* btn = manage( new Gtk::Button() );
791 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_NEW, GTK_STOCK_ADD, _("New") );
792 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_NEW) );
793 _buttonsRow.add( *btn );
795 btn = manage( new Gtk::Button() );
796 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_TOP, GTK_STOCK_GOTO_TOP, _("Top") );
797 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_TOP) );
798 _watchingNonTop.push_back( btn );
799 _buttonsRow.add( *btn );
801 btn = manage( new Gtk::Button() );
802 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, _("Up") );
803 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_UP) );
804 _watchingNonTop.push_back( btn );
805 _buttonsRow.add( *btn );
807 btn = manage( new Gtk::Button() );
808 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, _("Dn") );
809 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DOWN) );
810 _watchingNonBottom.push_back( btn );
811 _buttonsRow.add( *btn );
813 btn = manage( new Gtk::Button() );
814 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_BOTTOM, GTK_STOCK_GOTO_BOTTOM, _("Bot") );
815 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_BOTTOM) );
816 _watchingNonBottom.push_back( btn );
817 _buttonsRow.add( *btn );
819 // btn = manage( new Gtk::Button("Dup") );
820 // btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DUPLICATE) );
821 // _buttonsRow.add( *btn );
823 btn = manage( new Gtk::Button() );
824 _styleButton( *btn, targetDesktop, SP_VERB_LAYER_DELETE, GTK_STOCK_REMOVE, _("X") );
825 btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DELETE) );
826 _watching.push_back( btn );
827 _buttonsRow.add( *btn );
832 // -------------------------------------------------------
833 {
834 _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RENAME, 0, "Rename", (int)BUTTON_RENAME ) );
835 _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_NEW, 0, "New", (int)BUTTON_NEW ) );
837 _popupMenu.items().push_back( Gtk::Menu_Helpers::SeparatorElem() );
839 _watchingNonTop.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, "Up", (int)BUTTON_UP ) );
840 _watchingNonBottom.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, "Down", (int)BUTTON_DOWN ) );
842 _popupMenu.show_all_children();
843 }
844 // -------------------------------------------------------
848 for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
849 (*it)->set_sensitive( false );
850 }
851 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {
852 (*it)->set_sensitive( false );
853 }
854 for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {
855 (*it)->set_sensitive( false );
856 }
858 g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this );
859 setDesktop( targetDesktop );
861 show_all_children();
863 // restorePanelPrefs();
864 }
866 LayersPanel::~LayersPanel()
867 {
868 if ( _model )
869 {
870 delete _model;
871 }
873 if ( _toggleEvent )
874 {
875 gdk_event_free( _toggleEvent );
876 _toggleEvent = 0;
877 }
878 }
881 void LayersPanel::setDesktop( SPDesktop* desktop )
882 {
883 if ( desktop != _desktop ) {
884 _layerChangedConnection.disconnect();
885 _layerUpdatedConnection.disconnect();
886 _changedConnection.disconnect();
887 if ( _mgr ) {
888 _mgr = 0;
889 }
890 if ( _desktop ) {
891 _desktop = 0;
892 }
894 _desktop = SP_ACTIVE_DESKTOP;
895 if ( _desktop ) {
896 //setLabel( _desktop->doc()->name );
898 _mgr = _desktop->layer_manager;
899 if ( _mgr ) {
900 _layerChangedConnection = _mgr->connectCurrentLayerChanged( sigc::mem_fun(*this, &LayersPanel::_selectLayer) );
901 _layerUpdatedConnection = _mgr->connectLayerDetailsChanged( sigc::mem_fun(*this, &LayersPanel::_updateLayer) );
902 _changedConnection = _mgr->connectChanged( sigc::mem_fun(*this, &LayersPanel::_layersChanged) );
903 }
905 _layersChanged();
906 }
907 }
908 /*
909 GSList const *layers=sp_document_get_resource_list( _desktop->doc(), "layer" );
910 g_message( "layers list starts at %p", layers );
911 for ( GSList const *iter=layers ; iter ; iter = iter->next ) {
912 SPObject *layer=static_cast<SPObject *>(iter->data);
913 g_message(" {%s} [%s]", layer->id, layer->label() );
914 }
915 */
916 }
920 } //namespace Dialogs
921 } //namespace UI
922 } //namespace Inkscape
925 /*
926 Local Variables:
927 mode:c++
928 c-file-style:"stroustrup"
929 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
930 indent-tabs-mode:nil
931 fill-column:99
932 End:
933 */
934 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :