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