c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop#ifdef HAVE_CONFIG_H

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop# include <config.h>

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop#endif

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop#include <glibmm/i18n.h>

3d408b5e5a2327b0f8e777e5c540e8da2a3491fanicholasbishop

aa916bee1f1106fa94adb62552cb286b998f4f24nicholasbishop#include <gtk/gtkstock.h>

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop

a14ff477fb6d8003e2817a894e4b63bb2773e407nicholasbishop#include "inkscape.h"

e83c8c22aeee166a8062cf991004c63217761be4nicholasbishop

000dfc9dd0bc3d8cd37fabe93f6f9d1ede190adfnicholasbishop#include "layers-panel.h"

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop

6c3e745a94ef6b25a4ef9f018d350a7535aa45afTed Gould#include "layer-manager.h"

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop#include "layer-fns.h"

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop#include "verbs.h"

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen#include "helper/action.h"

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "document.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "desktop.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "desktop-handles.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "selection.h"

6ec5144d37a7fc9228eb04f7ebd8b2c7bfead332nicholasbishop#include "sp-object.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "sp-item.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "widgets/icon.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include <gtkmm/widget.h>

d3af895e39575a428183b753c2870086ec224e38nicholasbishop#include "prefs-utils.h"

d3af895e39575a428183b753c2870086ec224e38nicholasbishop

d3af895e39575a428183b753c2870086ec224e38nicholasbishop

d3af895e39575a428183b753c2870086ec224e38nicholasbishopnamespace Inkscape {

d3af895e39575a428183b753c2870086ec224e38nicholasbishopnamespace UI {

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishopnamespace Dialogs {

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelenLayersPanel* LayersPanel::instance = 0;

3d408b5e5a2327b0f8e777e5c540e8da2a3491fanicholasbishop

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelenLayersPanel& LayersPanel::getInstance()

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen{

aa916bee1f1106fa94adb62552cb286b998f4f24nicholasbishop if ( !instance ) {

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen instance = new LayersPanel();

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen }

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop return *instance;

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop}

a14ff477fb6d8003e2817a894e4b63bb2773e407nicholasbishop

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelenenum {

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen COL_VISIBLE = 1,

9cd2476096fe25e62c8390886312882856039ad8nicholasbishop COL_LOCKED

2b3b5a2a04c62bc07b7f0740e7c705f142f9b173jucablues};

2b3b5a2a04c62bc07b7f0740e7c705f142f9b173jucablues

e83c8c22aeee166a8062cf991004c63217761be4nicholasbishopenum {

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen BUTTON_NEW = 0,

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen BUTTON_RENAME,

000dfc9dd0bc3d8cd37fabe93f6f9d1ede190adfnicholasbishop BUTTON_TOP,

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen BUTTON_BOTTOM,

d9a7c806ee7f408ddb61ff4f233c9d96111ee2b5johanengelen BUTTON_UP,

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishop BUTTON_DOWN,

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishop BUTTON_DELETE

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishop};

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishop

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishopclass ImageToggler : public Gtk::CellRendererPixbuf {

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishoppublic:

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishop ImageToggler( char const* on, char const* off) :

d16763fbe2a4e6b778d417469a8f047e86ffab91nicholasbishop Glib::ObjectBase(typeid(ImageToggler)),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop Gtk::CellRendererPixbuf(),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop _pixOnName(on),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop _pixOffName(off),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop _property_active(*this, "active", false),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop _property_activatable(*this, "activatable", true),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop _property_pixbuf_on(*this, "pixbuf_on", Glib::RefPtr<Gdk::Pixbuf>(0)),

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop _property_pixbuf_off(*this, "pixbuf_off", Glib::RefPtr<Gdk::Pixbuf>(0))

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop {

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop property_mode() = Gtk::CELL_RENDERER_MODE_ACTIVATABLE;

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop Gtk::Widget* thingie = sp_icon_get_icon(_pixOnName.c_str(), Inkscape::ICON_SIZE_DECORATION);

c9f29ccf73d68064b0e869847ce640bd27b94b82nicholasbishop if ( thingie ) {

a4030d5ca449e7e384bc699cd249ee704faaeab0Chris Morgan if ( SP_IS_ICON(thingie->gobj()) ) {

SPIcon* icon = SP_ICON(thingie->gobj());

sp_icon_fetch_pixbuf( icon );

_property_pixbuf_on = Glib::wrap( icon->pb, true );

}

delete thingie;

}

thingie = sp_icon_get_icon(_pixOffName.c_str(), Inkscape::ICON_SIZE_DECORATION);

if ( thingie ) {

if ( SP_IS_ICON(thingie->gobj()) ) {

SPIcon* icon = SP_ICON(thingie->gobj());

sp_icon_fetch_pixbuf( icon );

_property_pixbuf_off = Glib::wrap( icon->pb, true );

}

delete thingie;

}

property_pixbuf() = _property_pixbuf_off.get_value();

}

sigc::signal<void, const Glib::ustring&> signal_toggled()

{

return _signal_toggled;

}

Glib::PropertyProxy<bool> property_active() { return _property_active.get_proxy(); }

Glib::PropertyProxy<bool> property_activatable() { return _property_activatable.get_proxy(); }

Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_on();

Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_off();

protected:

virtual void render_vfunc( const Glib::RefPtr<Gdk::Drawable>& window,

Gtk::Widget& widget,

const Gdk::Rectangle& background_area,

const Gdk::Rectangle& cell_area,

const Gdk::Rectangle& expose_area,

Gtk::CellRendererState flags )

{

property_pixbuf() = _property_active.get_value() ? _property_pixbuf_on : _property_pixbuf_off;

Gtk::CellRendererPixbuf::render_vfunc( window, widget, background_area, cell_area, expose_area, flags );

}

virtual bool activate_vfunc(GdkEvent* event,

Gtk::Widget& widget,

const Glib::ustring& path,

const Gdk::Rectangle& background_area,

const Gdk::Rectangle& cell_area,

Gtk::CellRendererState flags)

{

_signal_toggled.emit(path);

return false;

}

private:

Glib::ustring _pixOnName;

Glib::ustring _pixOffName;

Glib::Property<bool> _property_active;

Glib::Property<bool> _property_activatable;

Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_on;

Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > _property_pixbuf_off;

sigc::signal<void, const Glib::ustring&> _signal_toggled;

};

class LayersPanel::InternalUIBounce

{

public:

int _actionCode;

SPObject* _target;

};

static gboolean layers_panel_activated( GtkObject *object, GdkEvent * /*event*/, gpointer data )

{

if ( data )

{

LayersPanel* panel = reinterpret_cast<LayersPanel*>(data);

panel->setDesktop( SP_ACTIVE_DESKTOP );

}

return FALSE;

}

void LayersPanel::_styleButton( Gtk::Button& btn, SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback )

{

bool set = false;

if ( iconName ) {

GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, iconName );

gtk_widget_show( child );

btn.add( *manage(Glib::wrap(child)) );

set = true;

}

if ( desktop ) {

Verb *verb = Verb::get( code );

if ( verb ) {

SPAction *action = verb->get_action(desktop);

if ( !set && action && action->image ) {

GtkWidget *child = sp_icon_new( Inkscape::ICON_SIZE_SMALL_TOOLBAR, action->image );

gtk_widget_show( child );

btn.add( *manage(Glib::wrap(child)) );

set = true;

}

if ( action && action->tip ) {

_tips.set_tip( btn, action->tip );

}

}

}

if ( !set && fallback ) {

btn.set_label( fallback );

}

}

Gtk::MenuItem& LayersPanel::_addPopupItem( SPDesktop *desktop, unsigned int code, char const* iconName, char const* fallback, int id )

{

GtkWidget* iconWidget = 0;

const char* label = 0;

if ( iconName ) {

iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, iconName );

}

if ( desktop ) {

Verb *verb = Verb::get( code );

if ( verb ) {

SPAction *action = verb->get_action(desktop);

if ( !iconWidget && action && action->image ) {

iconWidget = sp_icon_new( Inkscape::ICON_SIZE_MENU, action->image );

}

if ( action ) {

label = action->name;

}

}

}

if ( !label && fallback ) {

label = fallback;

}

Gtk::Widget* wrapped = 0;

if ( iconWidget ) {

wrapped = manage(Glib::wrap(iconWidget));

wrapped->show();

}

Gtk::Menu::MenuList& menulist = _popupMenu.items();

if ( wrapped ) {

menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem( label, *wrapped, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );

} else {

menulist.push_back( Gtk::Menu_Helpers::MenuElem( label, sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), id)) );

}

return menulist.back();

}

void LayersPanel::_fireAction( unsigned int code )

{

if ( _desktop ) {

Verb *verb = Verb::get( code );

if ( verb ) {

SPAction *action = verb->get_action(_desktop);

if ( action ) {

sp_action_perform( action, NULL );

}

}

}

}

void LayersPanel::_takeAction( int val )

{

if ( !_pending ) {

_pending = new InternalUIBounce();

_pending->_actionCode = val;

_pending->_target = _selectedLayer();

Glib::signal_timeout().connect( sigc::mem_fun(*this, &LayersPanel::_executeAction), 0 );

}

}

bool LayersPanel::_executeAction()

{

// Make sure selected layer hasn't changed since the action was triggered

if ( _pending

&& !( (_desktop && _desktop->currentLayer())

&& (_desktop->currentLayer() != _pending->_target)

) ) {

int val = _pending->_actionCode;

switch ( val ) {

case BUTTON_NEW:

{

_fireAction( SP_VERB_LAYER_NEW );

}

break;

case BUTTON_RENAME:

{

_fireAction( SP_VERB_LAYER_RENAME );

}

break;

case BUTTON_TOP:

{

_fireAction( SP_VERB_LAYER_TO_TOP );

}

break;

case BUTTON_BOTTOM:

{

_fireAction( SP_VERB_LAYER_TO_BOTTOM );

}

break;

case BUTTON_UP:

{

_fireAction( SP_VERB_LAYER_RAISE );

}

break;

case BUTTON_DOWN:

{

_fireAction( SP_VERB_LAYER_LOWER );

}

break;

case BUTTON_DELETE:

{

_fireAction( SP_VERB_LAYER_DELETE );

}

break;

}

delete _pending;

_pending = 0;

}

return false;

}

class LayersPanel::ModelColumns : public Gtk::TreeModel::ColumnRecord

{

public:

ModelColumns()

{

add(_colObject);

add(_colVisible);

add(_colLocked);

add(_colLabel);

}

virtual ~ModelColumns() {}

Gtk::TreeModelColumn<SPObject*> _colObject;

Gtk::TreeModelColumn<Glib::ustring> _colLabel;

Gtk::TreeModelColumn<bool> _colVisible;

Gtk::TreeModelColumn<bool> _colLocked;

};

void LayersPanel::_updateLayer( SPObject *layer ) {

_store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForUpdated), layer) );

}

bool LayersPanel::_checkForUpdated(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)

{

bool stopGoing = false;

Gtk::TreeModel::Row row = *iter;

Glib::ustring tmp = row[_model->_colLabel];

if ( layer == row[_model->_colObject] )

{

row[_model->_colLabel] = layer->label() ? layer->label() : SP_OBJECT_ID(layer);

row[_model->_colVisible] = SP_IS_ITEM(layer) ? !SP_ITEM(layer)->isHidden() : false;

row[_model->_colLocked] = SP_IS_ITEM(layer) ? SP_ITEM(layer)->isLocked() : false;

stopGoing = true;

}

return stopGoing;

}

void LayersPanel::_selectLayer( SPObject *layer ) {

if ( !layer || (_desktop && _desktop->doc() && (layer == _desktop->doc()->root)) ) {

if ( _tree.get_selection()->count_selected_rows() != 0 ) {

_tree.get_selection()->unselect_all();

}

} else {

_store->foreach( sigc::bind<SPObject*>(sigc::mem_fun(*this, &LayersPanel::_checkForSelected), layer) );

}

_checkTreeSelection();

}

bool LayersPanel::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPObject* layer)

{

bool stopGoing = false;

Gtk::TreeModel::Row row = *iter;

if ( layer == row[_model->_colObject] )

{

_tree.expand_to_path( path );

Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();

select->select(iter);

stopGoing = true;

}

return stopGoing;

}

void LayersPanel::_layersChanged()

{

SPDocument* document = _desktop->doc();

SPObject* root = document->root;

if ( root ) {

if ( _mgr && _mgr->includes( root ) ) {

SPObject* target = _desktop->currentLayer();

_store->clear();

#if DUMP_LAYERS

g_message("root:%p {%s} [%s]", root, root->id, root->label() );

#endif // DUMP_LAYERS

_addLayer( document, root, 0, target, 0 );

}

}

}

void LayersPanel::_addLayer( SPDocument* doc, SPObject* layer, Gtk::TreeModel::Row* parentRow, SPObject* target, int level )

{

if ( layer && (level < _maxNestDepth) ) {

unsigned int counter = _mgr->childCount(layer);

for ( unsigned int i = 0; i < counter; i++ ) {

SPObject *child = _mgr->nthChildOf(layer, i);

if ( child ) {

#if DUMP_LAYERS

g_message(" %3d layer:%p {%s} [%s]", level, child, child->id, child->label() );

#endif // DUMP_LAYERS

Gtk::TreeModel::iterator iter = parentRow ? _store->prepend(parentRow->children()) : _store->prepend();

Gtk::TreeModel::Row row = *iter;

row[_model->_colObject] = child;

row[_model->_colLabel] = child->label() ? child->label() : SP_OBJECT_ID(child);

row[_model->_colVisible] = SP_IS_ITEM(child) ? !SP_ITEM(child)->isHidden() : false;

row[_model->_colLocked] = SP_IS_ITEM(child) ? SP_ITEM(child)->isLocked() : false;

if ( target && child == target ) {

_tree.expand_to_path( _store->get_path(iter) );

Glib::RefPtr<Gtk::TreeSelection> select = _tree.get_selection();

select->select(iter);

_checkTreeSelection();

}

_addLayer( doc, child, &row, target, level + 1 );

}

}

}

}

SPObject* LayersPanel::_selectedLayer()

{

SPObject* obj = 0;

Gtk::TreeModel::iterator iter = _tree.get_selection()->get_selected();

if ( iter ) {

Gtk::TreeModel::Row row = *iter;

obj = row[_model->_colObject];

}

return obj;

}

void LayersPanel::_pushTreeSelectionToCurrent()

{

SPObject* inTree = _selectedLayer();

if ( inTree ) {

SPObject* curr = _desktop->currentLayer();

if ( curr != inTree ) {

// TODO - move these to a function in layer-manager.cpp

_desktop->setCurrentLayer( inTree );

sp_desktop_selection(_desktop)->clear();

}

} else {

// TODO - move these to a function in layer-manager.cpp

_desktop->setCurrentLayer( _desktop->doc()->root );

sp_desktop_selection(_desktop)->clear();

}

}

void LayersPanel::_checkTreeSelection()

{

bool sensitive = false;

bool sensitiveNonTop = false;

bool sensitiveNonBottom = false;

if ( _tree.get_selection()->count_selected_rows() > 0 ) {

sensitive = true;

SPObject* inTree = _selectedLayer();

if ( inTree ) {

sensitiveNonTop = (Inkscape::next_layer(inTree->parent, inTree) != 0);

sensitiveNonBottom = (Inkscape::previous_layer(inTree->parent, inTree) != 0);

}

}

for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {

(*it)->set_sensitive( sensitive );

}

for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {

(*it)->set_sensitive( sensitiveNonTop );

}

for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {

(*it)->set_sensitive( sensitiveNonBottom );

}

}

void LayersPanel::_toggled( Glib::ustring const& str, int targetCol )

{

Gtk::TreeModel::Children::iterator iter = _tree.get_model()->get_iter(str);

Gtk::TreeModel::Row row = *iter;

Glib::ustring tmp = row[_model->_colLabel];

SPObject* obj = row[_model->_colObject];

SPItem* item = ( obj && SP_IS_ITEM(obj) ) ? SP_ITEM(obj) : 0;

if ( item ) {

switch ( targetCol ) {

case COL_VISIBLE:

{

bool newValue = !row[_model->_colVisible];

row[_model->_colVisible] = newValue;

item->setHidden( !newValue );

item->updateRepr();

sp_document_done( _desktop->doc() );

}

break;

case COL_LOCKED:

{

bool newValue = !row[_model->_colLocked];

row[_model->_colLocked] = newValue;

item->setLocked( newValue );

item->updateRepr();

sp_document_done( _desktop->doc() );

}

break;

}

}

}

void LayersPanel::_handleButtonEvent(GdkEventButton* evt)

{

if ( (evt->type == GDK_BUTTON_PRESS) && (evt->button == 3) ) {

{

Gtk::TreeModel::Path path;

Gtk::TreeViewColumn* col = 0;

int x = static_cast<int>(evt->x);

int y = static_cast<int>(evt->y);

int x2 = 0;

int y2 = 0;

if ( _tree.get_path_at_pos( x, y,

path, col,

x2, y2 ) ) {

_checkTreeSelection();

_popupMenu.popup(evt->button, evt->time);

}

}

}

}

void LayersPanel::_handleRowChange( Gtk::TreeModel::Path const& path, Gtk::TreeModel::iterator const& iter )

{

Gtk::TreeModel::Row row = *iter;

if ( row ) {

SPObject* obj = row[_model->_colObject];

if ( obj ) {

gchar const* oldLabel = obj->label();

Glib::ustring tmp = row[_model->_colLabel];

if ( oldLabel && oldLabel[0] && !tmp.empty() && (tmp != oldLabel) ) {

_mgr->renameLayer( obj, tmp.c_str() );

row[_model->_colLabel] = obj->label();

}

}

}

}

LayersPanel::LayersPanel() :

Inkscape::UI::Widget::Panel( Glib::ustring(), "dialogs.layers" ),

_maxNestDepth(20),

_mgr(0),

_desktop(0),

_model(0),

_pending(0)

{

_maxNestDepth = prefs_get_int_attribute_limited("dialogs.layers", "maxDepth", 20, 1, 1000);

ModelColumns *zoop = new ModelColumns();

_model = zoop;

_store = Gtk::TreeStore::create( *zoop );

_tree.set_model( _store );

_tree.set_headers_visible(false);

ImageToggler* eyeRenderer = manage( new ImageToggler("visible", "hidden") );

int visibleColNum = _tree.append_column("vis", *eyeRenderer) - 1;

eyeRenderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) );

eyeRenderer->property_activatable() = true;

Gtk::TreeViewColumn* col = _tree.get_column(visibleColNum);

if ( col ) {

col->add_attribute( eyeRenderer->property_active(), _model->_colVisible );

}

ImageToggler * renderer = manage( new ImageToggler("width_height_lock", "lock_unlocked") );

int lockedColNum = _tree.append_column("lock", *renderer) - 1;

renderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) );

renderer->property_activatable() = true;

col = _tree.get_column(lockedColNum);

if ( col ) {

col->add_attribute( renderer->property_active(), _model->_colLocked );

}

int nameColNum = _tree.append_column_editable("Name", _model->_colLabel) - 1;

_tree.set_expander_column( *_tree.get_column(nameColNum) );

_tree.get_selection()->signal_changed().connect( sigc::mem_fun(*this, &LayersPanel::_pushTreeSelectionToCurrent) );

_tree.get_model()->signal_row_changed().connect( sigc::mem_fun(*this, &LayersPanel::_handleRowChange) );

_tree.signal_button_press_event().connect_notify( sigc::mem_fun(*this, &LayersPanel::_handleButtonEvent) );

_scroller.add( _tree );

_scroller.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC );

_getContents()->pack_start( _scroller, Gtk::PACK_EXPAND_WIDGET );

_getContents()->pack_end(_buttonsRow, Gtk::PACK_SHRINK);

SPDesktop* targetDesktop = SP_ACTIVE_DESKTOP;

_buttonsRow.set_child_min_width( 16 );

Gtk::Button* btn = manage( new Gtk::Button() );

_styleButton( *btn, targetDesktop, SP_VERB_LAYER_NEW, GTK_STOCK_ADD, _("New") );

btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_NEW) );

_buttonsRow.add( *btn );

btn = manage( new Gtk::Button() );

_styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_TOP, GTK_STOCK_GOTO_TOP, _("Top") );

btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_TOP) );

_watchingNonTop.push_back( btn );

_buttonsRow.add( *btn );

btn = manage( new Gtk::Button() );

_styleButton( *btn, targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, _("Up") );

btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_UP) );

_watchingNonTop.push_back( btn );

_buttonsRow.add( *btn );

btn = manage( new Gtk::Button() );

_styleButton( *btn, targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, _("Dn") );

btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DOWN) );

_watchingNonBottom.push_back( btn );

_buttonsRow.add( *btn );

btn = manage( new Gtk::Button() );

_styleButton( *btn, targetDesktop, SP_VERB_LAYER_TO_BOTTOM, GTK_STOCK_GOTO_BOTTOM, _("Bot") );

btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_BOTTOM) );

_watchingNonBottom.push_back( btn );

_buttonsRow.add( *btn );

btn = manage( new Gtk::Button() );

_styleButton( *btn, targetDesktop, SP_VERB_LAYER_DELETE, GTK_STOCK_REMOVE, _("X") );

btn->signal_clicked().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_takeAction), (int)BUTTON_DELETE) );

_watching.push_back( btn );

_buttonsRow.add( *btn );

// -------------------------------------------------------

{

_watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RENAME, 0, "Rename", (int)BUTTON_RENAME ) );

_watching.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_NEW, 0, "New", (int)BUTTON_NEW ) );

_popupMenu.items().push_back( Gtk::Menu_Helpers::SeparatorElem() );

_watchingNonTop.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_RAISE, GTK_STOCK_GO_UP, "Up", (int)BUTTON_UP ) );

_watchingNonBottom.push_back( &_addPopupItem( targetDesktop, SP_VERB_LAYER_LOWER, GTK_STOCK_GO_DOWN, "Down", (int)BUTTON_DOWN ) );

_popupMenu.show_all_children();

}

// -------------------------------------------------------

for ( std::vector<Gtk::Widget*>::iterator it = _watching.begin(); it != _watching.end(); ++it ) {

(*it)->set_sensitive( false );

}

for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonTop.begin(); it != _watchingNonTop.end(); ++it ) {

(*it)->set_sensitive( false );

}

for ( std::vector<Gtk::Widget*>::iterator it = _watchingNonBottom.begin(); it != _watchingNonBottom.end(); ++it ) {

(*it)->set_sensitive( false );

}

g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK( layers_panel_activated ), this );

setDesktop( targetDesktop );

show_all_children();

restorePanelPrefs();

}

LayersPanel::~LayersPanel()

{

if ( _model )

{

delete _model;

}

}

void LayersPanel::setDesktop( SPDesktop* desktop )

{

if ( desktop != _desktop ) {

_layerChangedConnection.disconnect();

_layerUpdatedConnection.disconnect();

_changedConnection.disconnect();

if ( _mgr ) {

_mgr = 0;

}

if ( _desktop ) {

_desktop = 0;

}

_desktop = SP_ACTIVE_DESKTOP;

if ( _desktop ) {

setLabel( _desktop->doc()->name );

_mgr = _desktop->layer_manager;

if ( _mgr ) {

_layerChangedConnection = _mgr->connectCurrentLayerChanged( sigc::mem_fun(*this, &LayersPanel::_selectLayer) );

_layerUpdatedConnection = _mgr->connectLayerDetailsChanged( sigc::mem_fun(*this, &LayersPanel::_updateLayer) );

_changedConnection = _mgr->connectChanged( sigc::mem_fun(*this, &LayersPanel::_layersChanged) );

}

_layersChanged();

}

}

}

} //namespace Dialogs

} //namespace UI

} //namespace Inkscape