src/dialogs/layers-panel.cpp

   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
  14
  15 #include <glibmm/i18n.h>
  16
  17 #include <gtk/gtkstock.h>
  18 #include <gtk/gtkmain.h>
  19
  20 #include <gtkmm/icontheme.h>
  21
  22 #include "inkscape.h"
  23
  24 #include "layers-panel.h"
  25
  26 #include "layer-manager.h"
  27 #include "layer-fns.h"
  28
  29 #include "verbs.h"
  30 #include "helper/action.h"
  31
  32 #include "document.h"
  33 #include "desktop.h"
  34 #include "sp-object.h"
  35 #include "sp-item.h"
  36 #include "widgets/icon.h"
  37 #include "ui/widget/imagetoggler.h"
  38 #include <gtkmm/widget.h>
  39 #include "preferences.h"
  40 #include "xml/repr.h"
  41 #include "svg/css-ostringstream.h"
  42 #include "desktop-style.h"
  43
  44 //#define DUMP_LAYERS 1
  45
  46 namespace Inkscape {
  47 namespace UI {
  48 namespace Dialogs {
  49
  50 LayersPanel&
  51 LayersPanel::getInstance()
  52 {
  53     return *new LayersPanel();
  54 }
  55
  56 enum {
  57     COL_VISIBLE = 1,
  58     COL_LOCKED
  59 };
  60
  61 enum {
  62     BUTTON_NEW = 0,
  63     BUTTON_RENAME,
  64     BUTTON_TOP,
  65     BUTTON_BOTTOM,
  66     BUTTON_UP,
  67     BUTTON_DOWN,
  68     BUTTON_DUPLICATE,
  69     BUTTON_DELETE,
  70     BUTTON_SOLO
  71 };
  72
  73 class LayersPanel::InternalUIBounce
  74 {
  75 public:
  76     int _actionCode;
  77     SPObject* _target;
  78 };
  79
  80 static gboolean layers_panel_activated( GtkObject */*object*/, GdkEvent * /*event*/, gpointer data )
  81 {
  82     if ( data )
  83     {
  84         LayersPanel* panel = reinterpret_cast<LayersPanel*>(data);
  85         panel->setDesktop(panel->getDesktop());
  86     }
  87
  88     return FALSE;
  89 }
  90
  91 static gboolean layers_panel_deactivated( GtkObject */*object*/, GdkEvent * /*event*/, gpointer data )
  92 {
  93     if ( data )
  94     {
  95         LayersPanel* panel = reinterpret_cast<LayersPanel*>(data);
  96         panel->setDesktop(NULL);
  97     }
  98
  99     return FALSE;
 100 }
 101
 102
 103 void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback )
 104 {
 105     bool set = false;
 106
 107     if ( iconName ) {
 108         GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, iconName );
 109         gtk_widget_show( child );
 110         btn.add( *manage(Glib::wrap(child)) );
 111         set = true;
 112     }
 113
 114     if ( desktop ) {
 115         Verb *verb = Verb::get( code );
 116         if ( verb ) {
 117             SPAction *action = verb->get_action(desktop);
 118             if ( !set && action && action->image ) {
 119                 GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, action->image );
 120                 gtk_widget_show( child );
 121                 btn.add( *manage(Glib::wrap(child)) );
 122                 set = true;
 123             }
 124
 125             if ( action && action->tip ) {
 126                 _tips.set_tip( btn, action->tip );
 127             }
 128         }
 129     }
 130
 131     if ( !set && fallback ) {
 132         btn.set_label( fallback );
 133     }
 134 }
 135
 136
 137 Gtk::MenuItem& LayersPanel::_addPopupItem( SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback, int id )
 138 {
 139     GtkWidget* iconWidget = 0;
 140     const char* label = 0;
 141
 142     if ( iconName ) {
 143         iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, iconName );
 144     }
 145
 146     if ( desktop ) {
 147         Verb *verb = Verb::get( code );
 148         if ( verb ) {
 149             SPAction *action = verb->get_action(desktop);
 150             if ( !iconWidget && action && action->image ) {
 151                 iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, action->image );
 152             }
 153
 154             if ( action ) {
 155                 label = action->name;
 156             }
 157         }
 158     }
 159
 160     if ( !label && fallback ) {
 161         label = fallback;
 162     }
 163
 164     Gtk::Widget* wrapped = 0;
 165     if ( iconWidget ) {
 166         wrapped = manage(Glib::wrap(iconWidget));
 167         wrapped->show();
 168     }
 169
 170
 171
 172     Gtk::Menu::MenuList& menulist = _popupMenu.items();
 173
 174     if ( wrapped ) {
 175         menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem( label, *wrapped, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );
 176     } else {
 177         menulist.push_back( Gtk::Menu_Helpers::MenuElem( label, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );
 178     }
 179     return menulist.back();
 180 }
 181
 182 void LayersPanel::_fireAction( unsigned int code )
 183 {
 184     if ( _desktop ) {
 185         Verb *verb = Verb::get( code );
 186         if ( verb ) {
 187             SPAction *action = verb->get_action(_desktop);
 188             if ( action ) {
 189                 sp_action_perform( action, NULL );
 190 //             } else {
 191 //                 g_message("no action");
 192             }
 193 //         } else {
 194 //             g_message("no verb for %u", code);
 195         }
 196 //     } else {
 197 //         g_message("no active desktop");
 198     }
 199 }
 200
 201 //     SP_VERB_LAYER_NEXT,
 202 //     SP_VERB_LAYER_PREV,
 203 void LayersPanel::_takeAction( int val )
 204 {
 205     if ( !_pending ) {
 206         _pending = new InternalUIBounce();
 207         _pending->_actionCode = val;
 208         _pending->_target = _selectedLayer();
 209         Glib::signal_timeout().connect( sigc::mem_fun(*this, &LayersPanel::_executeAction), 0 );
 210     }
 211 }
 212
 213 bool LayersPanel::_executeAction()
 214 {
 215     // Make sure selected layer hasn't changed since the action was triggered
 216     if ( _pending
 217          && (
 218              (_pending->_actionCode == BUTTON_NEW)
 219              || !( (_desktop && _desktop->currentLayer())
 220                    && (_desktop->currentLayer() != _pending->_target)
 221                  )
 222              )
 223         ) {
 224         int val = _pending->_actionCode;
 225 //        SPObject* target = _pending->_target;
 226
 227         switch ( val ) {
 228             case BUTTON_NEW:
 229             {
 230                 _fireAction( SP_VERB_LAYER_NEW );
 231             }
 232             break;
 233             case BUTTON_RENAME:
 234             {
 235                 _fireAction( SP_VERB_LAYER_RENAME );
 236             }
 237             break;
 238             case BUTTON_TOP:
 239             {
 240                 _fireAction( SP_VERB_LAYER_TO_TOP );
 241             }
 242             break;
 243             case BUTTON_BOTTOM:
 244             {
 245                 _fireAction( SP_VERB_LAYER_TO_BOTTOM );
 246             }
 247             break;
 248             case BUTTON_UP:
 249             {
 250                 _fireAction( SP_VERB_LAYER_RAISE );
 251             }
 252             break;
 253             case BUTTON_DOWN:
 254             {
 255                 _fireAction( SP_VERB_LAYER_LOWER );
 256             }
 257             break;
 258             case BUTTON_DUPLICATE:
 259             {
 260                 _fireAction( SP_VERB_LAYER_DUPLICATE );
 261             }
 262             break;
 263             case BUTTON_DELETE:
 264             {
 265                 _fireAction( SP_VERB_LAYER_DELETE );
 266             }
 267             case BUTTON_SOLO:
 268             {
 269                 _fireAction( SP_VERB_LAYER_SOLO );
 270             }
 271             break;
 272         }
 273
 274         delete _pending;
 275         _pending = 0;
 276     }
 277
 278     return false;
 279 }
 280
 281 class LayersPanel::ModelColumns : public Gtk::TreeModel::ColumnRecord
 282 {
 283 public:
 284
 285     ModelColumns()
 286     {
 287         add(_colObject);
 288         add(_colVisible);
 289         add(_colLocked);
 290         add(_colLabel);
 291     }
 292     virtual ~ModelColumns() {}
 293
 294     Gtk::TreeModelColumn<SPObject*> _colObject;
 295     Gtk::TreeModelColumn<Glib::ustring> _colLabel;
 296     Gtk::TreeModelColumn<bool> _colVisible;
 297     Gtk::TreeModelColumn<bool> _colLocked;
 298 };
 299
 300 void LayersPanel::_updateLayer( SPObject *layer ) {
 301     _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) );
 302 }
 303
 304 bool LayersPanel::_checkForUpdated(const Gtk::TreePath &/*path*/, const Gtk::TreeIter& iter, SPObject* layer)
 305 {
 306     bool stopGoing = false;
 307     Gtk::TreeModel::Row row = *iter;
 308     Glib::ustring tmp = row[_model->_colLabel];
 309     if ( layer == row[_model->_colObject] )
 310     {
 311         row[_model->_colLabel] = layer->label() ? layer->label() : SP_OBJECT_ID(layer);
 312         row[_model->_colVisible] = SP_IS_ITEM(layer) ? !SP_ITEM(layer)->isHidden() : false;
 313         row[_model->_colLocked] = SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false;
 314
 315         stopGoing = true;
 316     }
 317
 318     return stopGoing;
 319 }
 320
 321 void LayersPanel::_selectLayer( SPObject *layer ) {
 322     if ( !layer || (_desktop && _desktop->doc() && (layer == _desktop->doc()->root)) ) {
 323         if ( _tree.get_selection()->count_selected_rows() != 0 ) {
 324             _tree.get_selection()->unselect_all();
 325         }
 326     } else {
 327         _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForSelected), layer) );
 328     }
 329
 330     _checkTreeSelection();
 331 }
 332
 333 bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
 334 {
 335     bool stopGoing = false;
 336
 337     Gtk::TreeModel::Row row = *iter;
 338     if ( layer == row[_model->_colObject] )
 339     {
 340         _tree.expand_to_path( path );
 341
 342         Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
 343
 344         select->select(iter);
 345
 346         stopGoing = true;
 347     }
 348
 349     return stopGoing;
 350 }
 351
 352 void LayersPanel::_layersChanged()
 353 {
 354 //    g_message("_layersChanged()");
 355     SPDocument* document = _desktop->doc();
 356     SPObject* root = document->root;
 357     if ( root ) {
 358         _selectedConnection.block();
 359         if ( _mgr && _mgr->includes( root ) ) {
 360             SPObject* target = _desktop->currentLayer();
 361             _store->clear();
 362
 363 #if DUMP_LAYERS
 364             g_message("root:%p  {%s}   [%s]", root, root->id, root->label() );
 365 #endif // DUMP_LAYERS
 366             _addLayer( document, root, 0, target, 0 );
 367         }
 368         _selectedConnection.unblock();
 369     }
 370 }
 371
 372 void LayersPanel::_addLayer( SPDocument* doc, SPObject* layer, Gtk::TreeModel::Row* parentRow, SPObject* target, int level )
 373 {
 374     if ( layer && (level < _maxNestDepth) ) {
 375         unsigned int counter = _mgr->childCount(layer);
 376         for ( unsigned int i = 0; i < counter; i++ ) {
 377             SPObject *child = _mgr->nthChildOf(layer, i);
 378             if ( child ) {
 379 #if DUMP_LAYERS
 380                 g_message(" %3d    layer:%p  {%s}   [%s]", level, child, child->id, child->label() );
 381 #endif // DUMP_LAYERS
 382
 383                 Gtk::TreeModel::iterator iter = parentRow ? _store->prepend(parentRow->children()) : _store->prepend();
 384                 Gtk::TreeModel::Row row = *iter;
 385                 row[_model->_colObject] = child;
 386                 row[_model->_colLabel] = child->label() ? child->label() : SP_OBJECT_ID(child);
 387                 row[_model->_colVisible] = SP_IS_ITEM(child) ? !SP_ITEM(child)->isHidden() : false;
 388                 row[_model->_colLocked] = SP_IS_ITEM(child) ? SP_ITEM(child)->isLocked() : false;
 389
 390                 if ( target && child == target ) {
 391                     _tree.expand_to_path( _store->get_path(iter) );
 392
 393                     Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
 394                     select->select(iter);
 395
 396                     _checkTreeSelection();
 397                 }
 398
 399                 _addLayer( doc, child, &row, target, level + 1 );
 400             }
 401         }
 402     }
 403 }
 404
 405 SPObject* LayersPanel::_selectedLayer()
 406 {
 407     SPObject* obj = 0;
 408
 409     Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();
 410     if ( iter ) {
 411         Gtk::TreeModel::Row row = *iter;
 412         obj = row[_model->_colObject];
 413     }
 414
 415     return obj;
 416 }
 417
 418 void LayersPanel::_pushTreeSelectionToCurrent()
 419 {
 420     SPObject* inTree = _selectedLayer();
 421     // TODO hunt down the possible API abuse in getting NULL
 422     if ( _desktop->currentRoot() ) {
 423         if ( inTree ) {
 424             SPObject* curr = _desktop->currentLayer();
 425             if ( curr != inTree ) {
 426                 _mgr->setCurrentLayer( inTree );
 427             }
 428         } else {
 429             _mgr->setCurrentLayer( _desktop->doc()->root );
 430         }
 431     }
 432 }
 433
 434 void LayersPanel::_checkTreeSelection()
 435 {
 436     bool sensitive = false;
 437     bool sensitiveNonTop = false;
 438     bool sensitiveNonBottom = false;
 439     if ( _tree.get_selection()->count_selected_rows() > 0 ) {
 440         sensitive = true;
 441
 442         SPObject* inTree = _selectedLayer();
 443         if ( inTree ) {
 444
 445             sensitiveNonTop = (Inkscape::next_layer(inTree->parent, inTree) != 0);
 446             sensitiveNonBottom = (Inkscape::previous_layer(inTree->parent, inTree) != 0);
 447
 448         }
 449     }
 450
 451
 452     for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
 453         (*it)->set_sensitive( sensitive );
 454     }
 455     for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {
 456         (*it)->set_sensitive( sensitiveNonTop );
 457     }
 458     for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {
 459         (*it)->set_sensitive( sensitiveNonBottom );
 460     }
 461 }
 462
 463 void LayersPanel::_preToggle( GdkEvent const *event )
 464 {
 465     if ( _toggleEvent ) {
 466         gdk_event_free(_toggleEvent);
 467         _toggleEvent = 0;
 468     }
 469
 470     if ( event && (event->type == GDK_BUTTON_PRESS) ) {
 471         // Make a copy so we can keep it around.
 472         _toggleEvent = gdk_event_copy(const_cast<GdkEvent*>(event));
 473     }
 474 }
 475
 476 void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )
 477 {
 478     Gtk::TreeModel::Children::iterator iter = _tree.get_model()->get_iter(str);
 479     Gtk::TreeModel::Row row = *iter;
 480
 481     Glib::ustring tmp = row[_model->_colLabel];
 482
 483     SPObject* obj = row[_model->_colObject];
 484     SPItem* item = ( obj && SP_IS_ITEM(obj) ) ? SP_ITEM(obj) : 0;
 485     if ( item ) {
 486         switch ( targetCol ) {
 487             case COL_VISIBLE:
 488             {
 489                 bool newValue = !row[_model->_colVisible];
 490                 row[_model->_colVisible] = newValue;
 491                 item->setHidden( !newValue  );
 492                 item->updateRepr();
 493                 sp_document_done( _desktop->doc() , SP_VERB_DIALOG_LAYERS,
 494                                   newValue? _("Unhide layer") : _("Hide layer"));
 495             }
 496             break;
 497
 498             case COL_LOCKED:
 499             {
 500                 bool newValue = !row[_model->_colLocked];
 501                 row[_model->_colLocked] = newValue;
 502                 item->setLocked( newValue );
 503                 item->updateRepr();
 504                 sp_document_done( _desktop->doc() , SP_VERB_DIALOG_LAYERS,
 505                                   newValue? _("Lock layer") : _("Unlock layer"));
 506             }
 507             break;
 508         }
 509     }
 510 }
 511
 512 void LayersPanel::_handleButtonEvent(GdkEventButton* evt)
 513 {
 514     // TODO - fix to a better is-popup function
 515     if ( (evt->type == GDK_BUTTON_PRESS) && (evt->button == 3) ) {
 516
 517
 518         {
 519             Gtk::TreeModel::Path path;
 520             Gtk::TreeViewColumn* col = 0;
 521             int x = static_cast<int>(evt->x);
 522             int y = static_cast<int>(evt->y);
 523             int x2 = 0;
 524             int y2 = 0;
 525             if ( _tree.get_path_at_pos( x, y,
 526                                         path, col,
 527                                         x2, y2 ) ) {
 528                 _checkTreeSelection();
 529                 _popupMenu.popup(evt->button, evt->time);
 530             }
 531         }
 532
 533     }
 534 }
 535
 536 void LayersPanel::_handleRowChange( Gtk::TreeModel::Path const& /*path*/, Gtk::TreeModel::iterator const& iter )
 537 {
 538     Gtk::TreeModel::Row row = *iter;
 539     if ( row ) {
 540         SPObject* obj = row[_model->_colObject];
 541         if ( obj ) {
 542             gchar const* oldLabel = obj->label();
 543             Glib::ustring tmp = row[_model->_colLabel];
 544             if ( oldLabel && oldLabel[0] && !tmp.empty() && (tmp != oldLabel) ) {
 545                 _mgr->renameLayer( obj, tmp.c_str() );
 546                 row[_model->_colLabel] = obj->label();
 547             }
 548         }
 549     }
 550 }
 551
 552 bool LayersPanel::_rowSelectFunction( Glib::RefPtr<Gtk::TreeModel> const & /*model*/, Gtk::TreeModel::Path const & /*path*/, bool currentlySelected )
 553 {
 554     bool val = true;
 555     if ( !currentlySelected && _toggleEvent )
 556     {
 557         GdkEvent* event = gtk_get_current_event();
 558         if ( event ) {
 559             // (keep these checks separate, so we know when to call gdk_event_free()
 560             if ( event->type == GDK_BUTTON_PRESS ) {
 561                 GdkEventButton const* target = reinterpret_cast<GdkEventButton const*>(_toggleEvent);
 562                 GdkEventButton const* evtb = reinterpret_cast<GdkEventButton const*>(event);
 563
 564                 if ( (evtb->window == target->window)
 565                      && (evtb->send_event == target->send_event)
 566                      && (evtb->time == target->time)
 567                      && (evtb->state == target->state)
 568                     )
 569                 {
 570                     // Ooooh! It's a magic one
 571                     val = false;
 572                 }
 573             }
 574             gdk_event_free(event);
 575         }
 576     }
 577     return val;
 578 }
 579
 580 /**
 581  * Constructor
 582  */
 583 LayersPanel::LayersPanel() :
 584     UI::Widget::Panel("", "/dialogs/layers", SP_VERB_DIALOG_LAYERS),
 585     _maxNestDepth(20),
 586     _mgr(0),
 587     _desktop(0),
 588     _model(0),
 589     _pending(0),
 590     _toggleEvent(0),
 591     _compositeSettings(SP_VERB_DIALOG_LAYERS, "layers", UI::Widget::SimpleFilterModifier::BLEND)
 592 {
 593     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 594     _maxNestDepth = prefs->getIntLimited("/dialogs/layers/maxDepth", 20, 1, 1000);
 595
 596     ModelColumns *zoop = new ModelColumns();
 597     _model = zoop;
 598
 599     _store = Gtk::TreeStore::create( *zoop );
 600
 601     _tree.set_model( _store );
 602     _tree.set_headers_visible(false);
 603
 604     Inkscape::UI::Widget::ImageToggler *eyeRenderer = manage( new Inkscape::UI::Widget::ImageToggler("visible", "hidden") );
 605     int visibleColNum = _tree.append_column("vis", *eyeRenderer) - 1;
 606     eyeRenderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
 607     eyeRenderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) );
 608     eyeRenderer->property_activatable() = true;
 609     Gtk::TreeViewColumn* col = _tree.get_column(visibleColNum);
 610     if ( col ) {
 611         col->add_attribute( eyeRenderer->property_active(), _model->_colVisible );
 612     }
 613
 614     Inkscape::UI::Widget::ImageToggler * renderer = manage( new Inkscape::UI::Widget::ImageToggler("width_height_lock", "lock_unlocked") );
 615     int lockedColNum = _tree.append_column("lock", *renderer) - 1;
 616     renderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) );
 617     renderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) );
 618     renderer->property_activatable() = true;
 619     col = _tree.get_column(lockedColNum);
 620     if ( col ) {
 621         col->add_attribute( renderer->property_active(), _model->_colLocked );
 622     }
 623
 624     int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;
 625
 626     _tree.set_expander_column( *_tree.get_column(nameColNum) );
 627
 628     _compositeSettings.setSubject(&_subject);
 629
 630     _selectedConnection = _tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_pushTreeSelectionToCurrent) );
 631     _tree.get_selection()->set_select_function( sigc::mem_fun(*this, &LayersPanel::_rowSelectFunction) );
 632
 633     _tree.get_model()->signal_row_changed().connect( sigc::mem_fun(*this, &LayersPanel::_handleRowChange) );
 634     _tree.signal_button_press_event().connect_notify( sigc::mem_fun(*this, &LayersPanel::_handleButtonEvent) );
 635
 636     _scroller.add( _tree );
 637     _scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );
 638     _scroller.set_shadow_type(Gtk::SHADOW_IN);
 639
 640     _watching.push_back( &_compositeSettings );
 641
 642     _layersPage.pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );
 643     _layersPage.pack_end(_compositeSettings, Gtk::PACK_SHRINK);
 644     _layersPage.pack_end(_buttonsRow, Gtk::PACK_SHRINK);
 645
 646     _notebook.append_page(_layersPage, _("Layers"));
 647
 648     _getContents()->pack_start(_notebook, Gtk::PACK_EXPAND_WIDGET);
 649
 650     SPDesktop* targetDesktop = getDesktop();
 651
 652     _buttonsRow.set_child_min_width( 16 );
 653
 654     Gtk::Button* btn = manage( new Gtk::Button() );
 655     _styleButton( *btn, targetDesktop, SP_VERB_LAYER_NEW, GTK_STOCK_ADD, _("New") );
 656     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_NEW) );
 657     _buttonsRow.add( *btn );
 658
 659     btn = manage( new Gtk::Button() );
 660     _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_TOP, GTK_STOCK_GOTO_TOP, _("Top") );
 661     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_TOP) );
 662     _watchingNonTop.push_back( btn );
 663     _buttonsRow.add( *btn );
 664
 665     btn = manage( new Gtk::Button() );
 666     _styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, _("Up") );
 667     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_UP) );
 668     _watchingNonTop.push_back( btn );
 669     _buttonsRow.add( *btn );
 670
 671     btn = manage( new Gtk::Button() );
 672     _styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, _("Dn") );
 673     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DOWN) );
 674     _watchingNonBottom.push_back( btn );
 675     _buttonsRow.add( *btn );
 676
 677     btn = manage( new Gtk::Button() );
 678     _styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_BOTTOM, GTK_STOCK_GOTO_BOTTOM, _("Bot") );
 679     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_BOTTOM) );
 680     _watchingNonBottom.push_back( btn );
 681     _buttonsRow.add( *btn );
 682
 683 //     btn = manage( new Gtk::Button("Dup") );
 684 //     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DUPLICATE) );
 685 //     _buttonsRow.add( *btn );
 686
 687     btn = manage( new Gtk::Button() );
 688     _styleButton( *btn, targetDesktop, SP_VERB_LAYER_DELETE, GTK_STOCK_REMOVE, _("X") );
 689     btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DELETE) );
 690     _watching.push_back( btn );
 691     _buttonsRow.add( *btn );
 692
 693
 694
 695
 696     // -------------------------------------------------------
 697     {
 698         _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RENAME, 0, "Rename", (int)BUTTON_RENAME ) );
 699         _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_DUPLICATE, 0, "Duplicate", (int)BUTTON_DUPLICATE ) );
 700         _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_NEW, 0, "New", (int)BUTTON_NEW ) );
 701         _watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_SOLO, 0, "Solo", (int)BUTTON_SOLO ) );
 702
 703          _popupMenu.items().push_back( Gtk::Menu_Helpers::SeparatorElem() );
 704
 705         _watchingNonTop.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, "Up", (int)BUTTON_UP ) );
 706         _watchingNonBottom.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, "Down", (int)BUTTON_DOWN ) );
 707
 708         _popupMenu.show_all_children();
 709     }
 710     // -------------------------------------------------------
 711
 712
 713
 714     for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {
 715         (*it)->set_sensitive( false );
 716     }
 717     for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {
 718         (*it)->set_sensitive( false );
 719     }
 720     for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {
 721         (*it)->set_sensitive( false );
 722     }
 723
 724     g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this );
 725     g_signal_connect( G_OBJECT(INKSCAPE), "deactivate_desktop", G_CALLBACK( layers_panel_deactivated ), this );
 726     setDesktop( targetDesktop );
 727
 728     show_all_children();
 729
 730     // restorePanelPrefs();
 731 }
 732
 733 LayersPanel::~LayersPanel()
 734 {
 735     setDesktop(NULL);
 736
 737     _compositeSettings.setSubject(NULL);
 738
 739     if ( _model )
 740     {
 741         delete _model;
 742     }
 743
 744     if ( _toggleEvent )
 745     {
 746         gdk_event_free( _toggleEvent );
 747         _toggleEvent = 0;
 748     }
 749 }
 750
 751
 752 void LayersPanel::setDesktop( SPDesktop* desktop )
 753 {
 754     Panel::setDesktop(desktop);
 755
 756     if ( desktop != _desktop ) {
 757         _layerChangedConnection.disconnect();
 758         _layerUpdatedConnection.disconnect();
 759         _changedConnection.disconnect();
 760         if ( _mgr ) {
 761             _mgr = 0;
 762         }
 763         if ( _desktop ) {
 764             _desktop = 0;
 765         }
 766
 767         _desktop = getDesktop();
 768         if ( _desktop ) {
 769             //setLabel( _desktop->doc()->name );
 770
 771             _mgr = _desktop->layer_manager;
 772             if ( _mgr ) {
 773                 _layerChangedConnection = _mgr->connectCurrentLayerChanged( sigc::mem_fun(*this, &LayersPanel::_selectLayer) );
 774                 _layerUpdatedConnection = _mgr->connectLayerDetailsChanged( sigc::mem_fun(*this, &LayersPanel::_updateLayer) );
 775                 _changedConnection = _mgr->connectChanged( sigc::mem_fun(*this, &LayersPanel::_layersChanged) );
 776             }
 777
 778             _layersChanged();
 779         }
 780     }
 781 /*
 782     GSList const *layers=sp_document_get_resource_list( _desktop->doc(), "layer" );
 783     g_message( "layers list starts at %p", layers );
 784     for ( GSList const *iter=layers ; iter ; iter = iter->next ) {
 785         SPObject *layer=static_cast<SPObject *>(iter->data);
 786         g_message("  {%s}   [%s]", layer->id, layer->label() );
 787     }
 788 */
 789 }
 790
 791
 792
 793 } //namespace Dialogs
 794 } //namespace UI
 795 } //namespace Inkscape
 796
 797
 798 /*
 799   Local Variables:
 800   mode:c++
 801   c-file-style:"stroustrup"
 802   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 803   indent-tabs-mode:nil
 804   fill-column:99
 805   End:
 806 */
 807 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :