1 /*
2 * Inkscape::Widgets::LayerSelector - layer selector widget
3 *
4 * Authors:
5 * MenTaLguY <mental@rydia.net>
6 *
7 * Copyright (C) 2004 MenTaLguY
8 *
9 * Released under GNU GPL, read the file 'COPYING' for more information
10 */
12 #ifdef HAVE_CONFIG_H
13 # include "config.h"
14 #endif
16 #include <glibmm/i18n.h>
18 #include "desktop-handles.h"
20 #include "widgets/layer-selector.h"
21 #include "widgets/shrink-wrap-button.h"
22 #include "widgets/icon.h"
24 #include "util/reverse-list.h"
25 #include "util/filter-list.h"
27 #include "sp-item.h"
28 #include "desktop.h"
29 #include "document.h"
30 #include "dialogs/layer-properties.h"
31 #include "layer-manager.h"
32 #include "xml/node-event-vector.h"
33 #include "verbs.h"
35 namespace Inkscape {
36 namespace Widgets {
38 namespace {
40 class AlternateIcons : public Gtk::HBox {
41 public:
42 AlternateIcons(Inkscape::IconSize size, gchar const *a, gchar const *b)
43 : _a(NULL), _b(NULL)
44 {
45 if (a) {
46 _a = Gtk::manage(sp_icon_get_icon(a, size));
47 _a->set_no_show_all(true);
48 add(*_a);
49 }
50 if (b) {
51 _b = Gtk::manage(sp_icon_get_icon(b, size));
52 _b->set_no_show_all(true);
53 add(*_b);
54 }
55 setState(false);
56 }
58 bool state() const { return _state; }
59 void setState(bool state) {
60 _state = state;
61 if (_state) {
62 if (_a) {
63 _a->hide();
64 }
65 if (_b) {
66 _b->show();
67 }
68 } else {
69 if (_a) {
70 _a->show();
71 }
72 if (_b) {
73 _b->hide();
74 }
75 }
76 }
78 private:
79 Gtk::Widget *_a;
80 Gtk::Widget *_b;
81 bool _state;
82 };
84 }
86 /** LayerSelector constructor. Creates lock and hide buttons,
87 * initalizes the layer dropdown selector with a label renderer,
88 * and hooks up signal for setting the desktop layer when the
89 * selector is changed.
90 */
91 LayerSelector::LayerSelector(SPDesktop *desktop)
92 : _desktop(NULL), _layer(NULL)
93 {
94 AlternateIcons *label;
96 label = Gtk::manage(new AlternateIcons(Inkscape::ICON_SIZE_DECORATION, "visible", "hidden"));
97 _visibility_toggle.add(*label);
98 _visibility_toggle.signal_toggled().connect(
99 sigc::compose(
100 sigc::mem_fun(*label, &AlternateIcons::setState),
101 sigc::mem_fun(_visibility_toggle, &Gtk::ToggleButton::get_active)
102 )
103 );
104 _visibility_toggled_connection = _visibility_toggle.signal_toggled().connect(
105 sigc::compose(
106 sigc::mem_fun(*this, &LayerSelector::_hideLayer),
107 sigc::mem_fun(_visibility_toggle, &Gtk::ToggleButton::get_active)
108 )
109 );
111 _visibility_toggle.set_relief(Gtk::RELIEF_NONE);
112 shrink_wrap_button(_visibility_toggle);
113 _tooltips.set_tip(_visibility_toggle, _("Toggle current layer visibility"));
114 pack_start(_visibility_toggle, Gtk::PACK_EXPAND_PADDING);
116 label = Gtk::manage(new AlternateIcons(Inkscape::ICON_SIZE_DECORATION, "lock_unlocked", "width_height_lock"));
117 _lock_toggle.add(*label);
118 _lock_toggle.signal_toggled().connect(
119 sigc::compose(
120 sigc::mem_fun(*label, &AlternateIcons::setState),
121 sigc::mem_fun(_lock_toggle, &Gtk::ToggleButton::get_active)
122 )
123 );
124 _lock_toggled_connection = _lock_toggle.signal_toggled().connect(
125 sigc::compose(
126 sigc::mem_fun(*this, &LayerSelector::_lockLayer),
127 sigc::mem_fun(_lock_toggle, &Gtk::ToggleButton::get_active)
128 )
129 );
131 _lock_toggle.set_relief(Gtk::RELIEF_NONE);
132 shrink_wrap_button(_lock_toggle);
133 _tooltips.set_tip(_lock_toggle, _("Lock or unlock current layer"));
134 pack_start(_lock_toggle, Gtk::PACK_EXPAND_PADDING);
136 _tooltips.set_tip(_selector, _("Current layer"));
137 pack_start(_selector, Gtk::PACK_EXPAND_WIDGET);
139 _layer_model = Gtk::ListStore::create(_model_columns);
140 _selector.set_model(_layer_model);
141 _selector.pack_start(_label_renderer);
142 _selector.set_cell_data_func(
143 _label_renderer,
144 sigc::mem_fun(*this, &LayerSelector::_prepareLabelRenderer)
145 );
147 _selection_changed_connection = _selector.signal_changed().connect(
148 sigc::mem_fun(*this, &LayerSelector::_setDesktopLayer)
149 );
150 setDesktop(desktop);
151 }
153 /** Destructor - disconnects signal handler
154 */
155 LayerSelector::~LayerSelector() {
156 setDesktop(NULL);
157 _selection_changed_connection.disconnect();
158 }
160 namespace {
162 /** Helper function - detaches desktop from selector
163 */
164 bool detach(LayerSelector *selector) {
165 selector->setDesktop(NULL);
166 return FALSE;
167 }
169 }
171 /** Sets the desktop for the widget. First disconnects signals
172 * for the current desktop, then stores the pointer to the
173 * given \a desktop, and attaches its signals to this one.
174 * Then it selects the current layer for the desktop.
175 */
176 void LayerSelector::setDesktop(SPDesktop *desktop) {
177 if ( desktop == _desktop ) {
178 return;
179 }
181 if (_desktop) {
182 // _desktop_shutdown_connection.disconnect();
183 _layer_changed_connection.disconnect();
184 // g_signal_handlers_disconnect_by_func(_desktop, (gpointer)&detach, this);
185 }
186 _desktop = desktop;
187 if (_desktop) {
188 // TODO we need a different signal for this, really..s
189 // _desktop_shutdown_connection = _desktop->connectShutdown(
190 // sigc::bind (sigc::ptr_fun (detach), this));
191 // g_signal_connect_after(_desktop, "shutdown", GCallback(detach), this);
193 _layer_changed_connection = _desktop->connectCurrentLayerChanged(
194 sigc::mem_fun(*this, &LayerSelector::_selectLayer)
195 );
196 _selectLayer(_desktop->currentLayer());
197 }
198 }
200 namespace {
202 class is_layer {
203 public:
204 is_layer(SPDesktop *desktop) : _desktop(desktop) {}
205 bool operator()(SPObject &object) const {
206 return _desktop->isLayer(&object);
207 }
208 private:
209 SPDesktop *_desktop;
210 };
212 class column_matches_object {
213 public:
214 column_matches_object(Gtk::TreeModelColumn<SPObject *> const &column,
215 SPObject &object)
216 : _column(column), _object(object) {}
217 bool operator()(Gtk::TreeModel::const_iterator const &iter) const {
218 SPObject *current=(*iter)[_column];
219 return current == &_object;
220 }
221 private:
222 Gtk::TreeModelColumn<SPObject *> const &_column;
223 SPObject &_object;
224 };
226 }
228 /** Selects the given layer in the dropdown selector.
229 */
230 void LayerSelector::_selectLayer(SPObject *layer) {
231 using Inkscape::Util::List;
232 using Inkscape::Util::cons;
233 using Inkscape::Util::reverse_list;
235 _selection_changed_connection.block();
237 while (!_layer_model->children().empty()) {
238 Gtk::ListStore::iterator first_row(_layer_model->children().begin());
239 _destroyEntry(first_row);
240 _layer_model->erase(first_row);
241 }
243 SPObject *root=_desktop->currentRoot();
245 if (_layer) {
246 sp_object_unref(_layer, NULL);
247 _layer = NULL;
248 }
250 if (layer) {
251 List<SPObject &> hierarchy=reverse_list<SPObject::ParentIterator>(layer, root);
252 if ( layer == root ) {
253 _buildEntries(0, cons(*root, hierarchy));
254 } else if (hierarchy) {
255 _buildSiblingEntries(0, *root, hierarchy);
256 }
258 Gtk::TreeIter row(
259 std::find_if(
260 _layer_model->children().begin(),
261 _layer_model->children().end(),
262 column_matches_object(_model_columns.object, *layer)
263 )
264 );
265 if ( row != _layer_model->children().end() ) {
266 _selector.set_active(row);
267 }
269 _layer = layer;
270 sp_object_ref(_layer, NULL);
271 }
273 if ( !layer || layer == root ) {
274 _visibility_toggle.set_sensitive(false);
275 _visibility_toggle.set_active(false);
276 _lock_toggle.set_sensitive(false);
277 _lock_toggle.set_active(false);
278 } else {
279 _visibility_toggle.set_sensitive(true);
280 _visibility_toggle.set_active(( SP_IS_ITEM(layer) ? SP_ITEM(layer)->isHidden() : false ));
281 _lock_toggle.set_sensitive(true);
282 _lock_toggle.set_active(( SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false ));
283 }
285 _selection_changed_connection.unblock();
286 }
288 /** Sets the current desktop layer to the actively selected layer.
289 */
290 void LayerSelector::_setDesktopLayer() {
291 Gtk::ListStore::iterator selected(_selector.get_active());
292 SPObject *layer=_selector.get_active()->get_value(_model_columns.object);
293 if ( _desktop && layer ) {
294 _layer_changed_connection.block();
296 _desktop->layer_manager->setCurrentLayer(layer);
298 _layer_changed_connection.unblock();
300 _selectLayer(_desktop->currentLayer());
301 }
302 if (_desktop && _desktop->canvas) {
303 gtk_widget_grab_focus (GTK_WIDGET(_desktop->canvas));
304 }
305 }
307 /** Creates rows in the _layer_model data structure for each item
308 * in \a hierarchy, to a given \a depth.
309 */
310 void LayerSelector::_buildEntries(unsigned depth,
311 Inkscape::Util::List<SPObject &> hierarchy)
312 {
313 using Inkscape::Util::List;
314 using Inkscape::Util::rest;
316 _buildEntry(depth, *hierarchy);
318 List<SPObject &> remainder=rest(hierarchy);
319 if (remainder) {
320 _buildEntries(depth+1, remainder);
321 } else {
322 _buildSiblingEntries(depth+1, *hierarchy, remainder);
323 }
324 }
326 /** Creates entries in the _layer_model data structure for
327 * all siblings of the first child in \a parent.
328 */
329 void LayerSelector::_buildSiblingEntries(
330 unsigned depth, SPObject &parent,
331 Inkscape::Util::List<SPObject &> hierarchy
332 ) {
333 using Inkscape::Util::List;
334 using Inkscape::Util::rest;
335 using Inkscape::Util::reverse_list_in_place;
336 using Inkscape::Util::filter_list;
338 Inkscape::Util::List<SPObject &> siblings(
339 reverse_list_in_place(
340 filter_list<SPObject::SiblingIterator>(
341 is_layer(_desktop), parent.firstChild(), NULL
342 )
343 )
344 );
346 SPObject *layer( hierarchy ? &*hierarchy : NULL );
348 while (siblings) {
349 _buildEntry(depth, *siblings);
350 if ( &*siblings == layer ) {
351 _buildSiblingEntries(depth+1, *layer, rest(hierarchy));
352 }
353 ++siblings;
354 }
355 }
357 namespace {
359 struct Callbacks {
360 sigc::slot<void> update_row;
361 sigc::slot<void> update_list;
362 };
364 void attribute_changed(Inkscape::XML::Node */*repr*/, gchar const *name,
365 gchar const */*old_value*/, gchar const */*new_value*/,
366 bool /*is_interactive*/, void *data)
367 {
368 if ( !std::strcmp(name, "inkscape:groupmode") ) {
369 reinterpret_cast<Callbacks *>(data)->update_list();
370 } else {
371 reinterpret_cast<Callbacks *>(data)->update_row();
372 }
373 }
375 void node_added(Inkscape::XML::Node */*parent*/, Inkscape::XML::Node *child, Inkscape::XML::Node */*ref*/, void *data) {
376 gchar const *mode=child->attribute("inkscape:groupmode");
377 if ( mode && !std::strcmp(mode, "layer") ) {
378 reinterpret_cast<Callbacks *>(data)->update_list();
379 }
380 }
382 void node_removed(Inkscape::XML::Node */*parent*/, Inkscape::XML::Node *child, Inkscape::XML::Node */*ref*/, void *data) {
383 gchar const *mode=child->attribute("inkscape:groupmode");
384 if ( mode && !std::strcmp(mode, "layer") ) {
385 reinterpret_cast<Callbacks *>(data)->update_list();
386 }
387 }
389 void node_reordered(Inkscape::XML::Node */*parent*/, Inkscape::XML::Node *child,
390 Inkscape::XML::Node */*old_ref*/, Inkscape::XML::Node */*new_ref*/,
391 void *data)
392 {
393 gchar const *mode=child->attribute("inkscape:groupmode");
394 if ( mode && !std::strcmp(mode, "layer") ) {
395 reinterpret_cast<Callbacks *>(data)->update_list();
396 }
397 }
399 void update_row_for_object(SPObject *object,
400 Gtk::TreeModelColumn<SPObject *> const &column,
401 Glib::RefPtr<Gtk::ListStore> const &model)
402 {
403 Gtk::TreeIter row(
404 std::find_if(
405 model->children().begin(),
406 model->children().end(),
407 column_matches_object(column, *object)
408 )
409 );
410 if ( row != model->children().end() ) {
411 model->row_changed(model->get_path(row), row);
412 }
413 }
415 void rebuild_all_rows(sigc::slot<void, SPObject *> rebuild, SPDesktop *desktop)
416 {
417 rebuild(desktop->currentLayer());
418 }
420 }
422 void LayerSelector::_protectUpdate(sigc::slot<void> slot) {
423 bool visibility_blocked=_visibility_toggled_connection.blocked();
424 bool lock_blocked=_lock_toggled_connection.blocked();
425 _visibility_toggled_connection.block(true);
426 _lock_toggled_connection.block(true);
427 slot();
429 SPObject *layer = _desktop ? _desktop->currentLayer() : 0;
430 if ( layer ) {
431 bool wantedValue = ( SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false );
432 if ( _lock_toggle.get_active() != wantedValue ) {
433 _lock_toggle.set_active( wantedValue );
434 }
435 wantedValue = ( SP_IS_ITEM(layer) ? SP_ITEM(layer)->isHidden() : false );
436 if ( _visibility_toggle.get_active() != wantedValue ) {
437 _visibility_toggle.set_active( wantedValue );
438 }
439 }
440 _visibility_toggled_connection.block(visibility_blocked);
441 _lock_toggled_connection.block(lock_blocked);
442 }
444 /** Builds and appends a row in the layer model object.
445 */
446 void LayerSelector::_buildEntry(unsigned depth, SPObject &object) {
447 Inkscape::XML::NodeEventVector *vector;
449 Callbacks *callbacks=new Callbacks();
451 callbacks->update_row = sigc::bind(
452 sigc::mem_fun(*this, &LayerSelector::_protectUpdate),
453 sigc::bind(
454 sigc::ptr_fun(&update_row_for_object),
455 &object, _model_columns.object, _layer_model
456 )
457 );
459 SPObject *layer=_desktop->currentLayer();
460 if ( &object == layer || &object == SP_OBJECT_PARENT(layer) ) {
461 callbacks->update_list = sigc::bind(
462 sigc::mem_fun(*this, &LayerSelector::_protectUpdate),
463 sigc::bind(
464 sigc::ptr_fun(&rebuild_all_rows),
465 sigc::mem_fun(*this, &LayerSelector::_selectLayer),
466 _desktop
467 )
468 );
470 Inkscape::XML::NodeEventVector events = {
471 &node_added,
472 &node_removed,
473 &attribute_changed,
474 NULL,
475 &node_reordered
476 };
478 vector = new Inkscape::XML::NodeEventVector(events);
479 } else {
480 Inkscape::XML::NodeEventVector events = {
481 NULL,
482 NULL,
483 &attribute_changed,
484 NULL,
485 NULL
486 };
488 vector = new Inkscape::XML::NodeEventVector(events);
489 }
491 Gtk::ListStore::iterator row(_layer_model->append());
493 row->set_value(_model_columns.depth, depth);
495 sp_object_ref(&object, NULL);
496 row->set_value(_model_columns.object, &object);
498 Inkscape::GC::anchor(SP_OBJECT_REPR(&object));
499 row->set_value(_model_columns.repr, SP_OBJECT_REPR(&object));
501 row->set_value(_model_columns.callbacks, reinterpret_cast<void *>(callbacks));
503 sp_repr_add_listener(SP_OBJECT_REPR(&object), vector, callbacks);
504 }
506 /** Removes a row from the _model_columns object, disconnecting listeners
507 * on the slot.
508 */
509 void LayerSelector::_destroyEntry(Gtk::ListStore::iterator const &row) {
510 Callbacks *callbacks=reinterpret_cast<Callbacks *>(row->get_value(_model_columns.callbacks));
511 SPObject *object=row->get_value(_model_columns.object);
512 if (object) {
513 sp_object_unref(object, NULL);
514 }
515 Inkscape::XML::Node *repr=row->get_value(_model_columns.repr);
516 if (repr) {
517 sp_repr_remove_listener_by_data(repr, callbacks);
518 Inkscape::GC::release(repr);
519 }
520 delete callbacks;
521 }
523 /** Formats the label for a given layer row
524 */
525 void LayerSelector::_prepareLabelRenderer(
526 Gtk::TreeModel::const_iterator const &row
527 ) {
528 unsigned depth=(*row)[_model_columns.depth];
529 SPObject *object=(*row)[_model_columns.object];
530 bool label_defaulted(false);
532 // TODO: when the currently selected row is removed,
533 // (or before one has been selected) something appears to
534 // "invent" an iterator with null data and try to render it;
535 // where does it come from, and how can we avoid it?
536 if ( object && SP_OBJECT_REPR(object) ) {
537 SPObject *layer=( _desktop ? _desktop->currentLayer() : NULL );
538 SPObject *root=( _desktop ? _desktop->currentRoot() : NULL );
540 bool isancestor = !( layer && SP_OBJECT_PARENT(object) == SP_OBJECT_PARENT(layer) || layer == root && SP_OBJECT_PARENT(object) == root);
542 bool iscurrent = ( object == layer && object != root );
544 gchar *format = g_strdup_printf (
545 "<span size=\"smaller\" %s><tt>%*s%s</tt>%s%s%s%%s%s%s%s</span>",
546 ( _desktop && _desktop->itemIsHidden (SP_ITEM(object)) ? "foreground=\"gray50\"" : "" ),
547 depth, "", ( iscurrent ? "•" : " " ),
548 ( iscurrent ? "<b>" : "" ),
549 ( SP_ITEM(object)->isLocked() ? "[" : "" ),
550 ( isancestor ? "<small>" : "" ),
551 ( isancestor ? "</small>" : "" ),
552 ( SP_ITEM(object)->isLocked() ? "]" : "" ),
553 ( iscurrent ? "</b>" : "" )
554 );
556 gchar const *label;
557 if ( object != root ) {
558 label = object->label();
559 if (!label) {
560 label = object->defaultLabel();
561 label_defaulted = true;
562 }
563 } else {
564 label = _("(root)");
565 }
567 gchar *text = g_markup_printf_escaped(format, label);
568 _label_renderer.property_markup() = text;
569 g_free(text);
570 g_free(format);
571 } else {
572 _label_renderer.property_markup() = "<small> </small>";
573 }
575 _label_renderer.property_ypad() = 1;
576 _label_renderer.property_style() = ( label_defaulted ?
577 Pango::STYLE_ITALIC :
578 Pango::STYLE_NORMAL );
579 }
581 void LayerSelector::_lockLayer(bool lock) {
582 if ( _layer && SP_IS_ITEM(_layer) ) {
583 SP_ITEM(_layer)->setLocked(lock);
584 sp_document_done(sp_desktop_document(_desktop), SP_VERB_NONE,
585 lock? _("Lock layer") : _("Unlock layer"));
586 }
587 }
589 void LayerSelector::_hideLayer(bool hide) {
590 if ( _layer && SP_IS_ITEM(_layer) ) {
591 SP_ITEM(_layer)->setHidden(hide);
592 sp_document_done(sp_desktop_document(_desktop), SP_VERB_NONE,
593 hide? _("Hide layer") : _("Unhide layer"));
594 }
595 }
597 }
598 }
600 /*
601 Local Variables:
602 mode:c++
603 c-file-style:"stroustrup"
604 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
605 indent-tabs-mode:nil
606 fill-column:99
607 End:
608 */
609 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :