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 "inkscape.h"
  21
  22 #include "layers-panel.h"
  23
  24 #include "layer-manager.h"
  25 #include "layer-fns.h"
  26
  27 #include "verbs.h"
  28 #include "helper/action.h"
  29
  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"
  40
  41 //#define DUMP_LAYERS 1
  42
  43 namespace Inkscape {
  44 namespace UI {
  45 namespace Dialogs {
  46
  47 LayersPanel* LayersPanel::instance = 0;
  48
  49 LayersPanel*
  50 LayersPanel::create(Inkscape::UI::Dialog::Behavior::BehaviorFactory behavior_factory)
  51 {
  52     if ( !instance ) {
  53         instance = new LayersPanel(behavior_factory);
  54     }
  55
  56     return instance;
  57 }
  58
  59 enum {
  60     COL_VISIBLE = 1,
  61     COL_LOCKED
  62 };
  63
  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 };
  74
  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;
  88
  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     }
 109
 110     sigc::signal<void, const Glib::ustring&> signal_toggled()
 111     {
 112         return _signal_toggled;
 113     }
 114
 115     sigc::signal<void, GdkEvent const *> signal_pre_toggle()
 116     {
 117         return _signal_pre_toggle;
 118     }
 119
 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
 125
 126 protected:
 127
 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 );
 136
 137         if ( width ) {
 138             *width += (*width) >> 1;
 139         }
 140         if ( height ) {
 141             *height += (*height) >> 1;
 142         }
 143     }
 144
 145
 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     }
 156
 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);
 166
 167         return false;
 168     }
 169
 170
 171 private:
 172     Glib::ustring _pixOnName;
 173     Glib::ustring _pixOffName;
 174
 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;
 179
 180     sigc::signal<void, const Glib::ustring&> _signal_toggled;
 181     sigc::signal<void, GdkEvent const *> _signal_pre_toggle;
 182 };
 183
 184 class LayersPanel::InternalUIBounce
 185 {
 186 public:
 187     int _actionCode;
 188     SPObject* _target;
 189 };
 190
 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     }
 198
 199     return FALSE;
 200 }
 201
 202
 203 void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback )
 204 {
 205     bool set = false;
 206
 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     }
 213
 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             }
 224
 225             if ( action && action->tip ) {
 226                 _tips.set_tip( btn, action->tip );
 227             }
 228         }
 229     }
 230
 231     if ( !set && fallback ) {
 232         btn.set_label( fallback );
 233     }
 234 }
 235
 236
 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;
 241
 242     if ( iconName ) {
 243         iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, iconName );
 244     }
 245
 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             }
 253
 254             if ( action ) {
 255                 label = action->name;
 256             }
 257         }
 258     }
 259
 260     if ( !label && fallback ) {
 261         label = fallback;
 262     }
 263
 264     Gtk::Widget* wrapped = 0;
 265     if ( iconWidget ) {
 266         wrapped = manage(Glib::wrap(iconWidget));
 267         wrapped->show();
 268     }
 269
 270
 271
 272     Gtk::Menu::MenuList& menulist = _popupMenu.items();
 273
 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 }
 281
 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 }
 300
 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 }
 312
 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;
 326
 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         }
 364
 365         delete _pending;
 366         _pending = 0;
 367     }
 368
 369     return false;
 370 }
 371
 372 class LayersPanel::ModelColumns : public Gtk::TreeModel::ColumnRecord
 373 {
 374 public:
 375
 376     ModelColumns()
 377     {
 378         add(_colObject);
 379         add(_colVisible);
 380         add(_colLocked);
 381         add(_colLabel);
 382     }
 383     virtual ~ModelColumns() {}
 384
 385     Gtk::TreeModelColumn<SPObject*> _colObject;
 386     Gtk::TreeModelColumn<Glib::ustring> _colLabel;
 387     Gtk::TreeModelColumn<bool> _colVisible;
 388     Gtk::TreeModelColumn<bool> _colLocked;
 389 };
 390
 391 void LayersPanel::_updateLayer( SPObject *layer ) {
 392     _store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) );
 393 }
 394
 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;
 405
 406         stopGoing = true;
 407     }
 408
 409     return stopGoing;
 410 }
 411
 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     }
 420
 421     _checkTreeSelection();
 422 }
 423
 424 bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)
 425 {
 426     bool stopGoing = false;
 427
 428     Gtk::TreeModel::Row row = *iter;
 429     if ( layer == row[_model->_colObject] )
 430     {
 431         _tree.expand_to_path( path );
 432
 433         Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
 434
 435         select->select(iter);
 436
 437         stopGoing = true;
 438     }
 439
 440     return stopGoing;
 441 }
 442
 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();
 453
 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 }
 462
 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
 473
 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;
 480
 481                 if ( target && child == target ) {
 482                     _tree.expand_to_path( _store->get_path(iter) );
 483
 484                     Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();
 485                     select->select(iter);
 486
 487                     _checkTreeSelection();
 488                 }
 489
 490                 _addLayer( doc, child, &row, target, level + 1 );
 491             }
 492         }
 493     }
 494 }
 495
 496 SPObject* LayersPanel::_selectedLayer()
 497 {
 498     SPObject* obj = 0;
 499
 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     }
 505
 506     return obj;
 507 }
 508
 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 }
 524
 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;
 532
 533         SPObject* inTree = _selectedLayer();
 534         if ( inTree ) {
 535
 536             sensitiveNonTop = (Inkscape::next_layer(inTree->parent, inTree) != 0);
 537             sensitiveNonBottom = (Inkscape::previous_layer(inTree->parent, inTree) != 0);
 538
 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     }
 549
 550
 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 }
 561
 562 void LayersPanel::_preToggle( GdkEvent const *event )
 563 {
 564     if ( _toggleEvent ) {
 565         gdk_event_free(_toggleEvent);
 566         _toggleEvent = 0;
 567     }
 568
 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 }
 574
 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;
 579
 580     Glib::ustring tmp = row[_model->_colLabel];
 581
 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;
 596
 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 }
 610
 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) ) {
 615
 616
 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         }
 631
 632     }
 633 }
 634
 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 }
 650
 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);
 662
 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 }
 678
 679
 680 void LayersPanel::_opacityChanged()
 681 {
 682     SPObject* layer = _selectedLayer();
 683
 684     if ( _desktop && layer && !_opacityConnection.blocked() ) {
 685         _opacityConnection.block();
 686
 687         Gtk::Adjustment* adj = _opacity.get_adjustment();
 688         SPCSSAttr *css = sp_repr_css_attr_new();
 689
 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() );
 693
 694         sp_desktop_apply_css_recursive( layer, css, true );
 695         layer->updateRepr();
 696
 697         sp_repr_css_attr_unref( css );
 698
 699         sp_document_maybe_done( _desktop->doc(), "layers:opacity", SP_VERB_DIALOG_LAYERS,
 700                                 _("Change layer opacity"));
 701
 702         _opacityConnection.unblock();
 703     }
 704 }
 705
 706
 707
 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);
 721
 722     ModelColumns *zoop = new ModelColumns();
 723     _model = zoop;
 724
 725     _store = Gtk::TreeStore::create( *zoop );
 726
 727     _tree.set_model( _store );
 728     _tree.set_headers_visible(false);
 729
 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     }
 739
 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     }
 749
 750     int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;
 751
 752     _tree.set_expander_column( *_tree.get_column(nameColNum) );
 753
 754
 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) );
 757
 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) );
 760
 761     _scroller.add( _tree );
 762     _scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );
 763
 764
 765     _opacityBox.pack_start( *manage( new Gtk::Label(_("Opacity, %:"))), Gtk::PACK_SHRINK );
 766
 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 );
 772
 773     _spinBtn.configure(*_opacity.get_adjustment(), 0, 1);
 774
 775     _spinBtn.set_width_chars(5);
 776     _opacityBox.pack_end( _spinBtn, Gtk::PACK_SHRINK );
 777     _watching.push_back( &_opacityBox );
 778
 779     get_vbox()->pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );
 780
 781     get_vbox()->pack_end(_opacityBox, Gtk::PACK_SHRINK);
 782     get_vbox()->pack_end(_buttonsRow, Gtk::PACK_SHRINK);
 783
 784     _opacityConnection = _opacity.get_adjustment()->signal_value_changed().connect( sigc::mem_fun(*this, &LayersPanel::_opacityChanged) );
 785
 786     SPDesktop* targetDesktop = SP_ACTIVE_DESKTOP;
 787
 788     _buttonsRow.set_child_min_width( 16 );
 789
 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 );
 794
 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 );
 800
 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 );
 806
 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 );
 812
 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 );
 818
 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 );
 822
 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 );
 828
 829
 830
 831
 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 ) );
 836
 837          _popupMenu.items().push_back( Gtk::Menu_Helpers::SeparatorElem() );
 838
 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 ) );
 841
 842         _popupMenu.show_all_children();
 843     }
 844     // -------------------------------------------------------
 845
 846
 847
 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     }
 857
 858     g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this );
 859     setDesktop( targetDesktop );
 860
 861     show_all_children();
 862
 863     // restorePanelPrefs();
 864 }
 865
 866 LayersPanel::~LayersPanel()
 867 {
 868     if ( _model )
 869     {
 870         delete _model;
 871     }
 872
 873     if ( _toggleEvent )
 874     {
 875         gdk_event_free( _toggleEvent );
 876         _toggleEvent = 0;
 877     }
 878 }
 879
 880
 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         }
 893
 894         _desktop = SP_ACTIVE_DESKTOP;
 895         if ( _desktop ) {
 896             //setLabel( _desktop->doc()->name );
 897
 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             }
 904
 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 }
 917
 918
 919
 920 } //namespace Dialogs
 921 } //namespace UI
 922 } //namespace Inkscape
 923
 924
 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 :