synfig-studio/trunk/src/gtkmm/layertree.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file layertree.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **
  10 **      This package is free software; you can redistribute it and/or
  11 **      modify it under the terms of the GNU General Public License as
  12 **      published by the Free Software Foundation; either version 2 of
  13 **      the License, or (at your option) any later version.
  14 **
  15 **      This package is distributed in the hope that it will be useful,
  16 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18 **      General Public License for more details.
  19 **      \endlegal
  20 */
  21 /* ========================================================================= */
  22
  23 /* === H E A D E R S ======================================================= */
  24
  25 #ifdef USING_PCH
  26 #       include "pch.h"
  27 #else
  28 #ifdef HAVE_CONFIG_H
  29 #       include <config.h>
  30 #endif
  31
  32 #include "layertree.h"
  33 #include "layerparamtreestore.h"
  34 #include "cellrenderer_value.h"
  35 #include "cellrenderer_timetrack.h"
  36 #include <synfigapp/action.h>
  37 #include <synfigapp/instance.h>
  38 #include <gtkmm/scrolledwindow.h>
  39 #include <gtkmm/paned.h>
  40 #include "app.h"
  41 #include "instance.h"
  42 #include <gtkmm/treemodelsort.h>
  43
  44 #endif
  45
  46 /* === U S I N G =========================================================== */
  47
  48 using namespace std;
  49 using namespace etl;
  50 using namespace synfig;
  51 using namespace studio;
  52
  53 /* === M A C R O S ========================================================= */
  54
  55 #ifndef SMALL_BUTTON
  56 #define SMALL_BUTTON(button,stockid,tooltip)    \
  57         button = manage(new class Gtk::Button());       \
  58         icon=manage(new Gtk::Image(Gtk::StockID(stockid),iconsize));    \
  59         button->add(*icon);     \
  60         tooltips_.set_tip(*button,tooltip);     \
  61         icon->set_padding(0,0);\
  62         icon->show();   \
  63         button->set_relief(Gtk::RELIEF_NONE); \
  64         button->show()
  65 #endif
  66
  67 #ifndef NORMAL_BUTTON
  68 #define NORMAL_BUTTON(button,stockid,tooltip)   \
  69         button = manage(new class Gtk::Button());       \
  70         icon=manage(new Gtk::Image(Gtk::StockID(stockid),Gtk::ICON_SIZE_BUTTON));       \
  71         button->add(*icon);     \
  72         tooltips_.set_tip(*button,tooltip);     \
  73         icon->set_padding(0,0);\
  74         icon->show();   \
  75         /*button->set_relief(Gtk::RELIEF_NONE);*/ \
  76         button->show()
  77 #endif
  78
  79 #define NEW_SMALL_BUTTON(x,y,z) Gtk::Button *SMALL_BUTTON(x,y,z)
  80
  81 #define NOT_IMPLEMENTED_SLOT sigc::mem_fun(*reinterpret_cast<studio::CanvasViewUIInterface*>(get_ui_interface().get()),&studio::CanvasViewUIInterface::not_implemented)
  82
  83 /* === G L O B A L S ======================================================= */
  84
  85 /* === P R O C E D U R E S ================================================= */
  86
  87 /* === M E T H O D S ======================================================= */
  88
  89 LayerTree::LayerTree():
  90         layer_amount_adjustment_(1,0,1,0.01,0.01,0)
  91 {
  92         param_tree_view_=new Gtk::TreeView;
  93         layer_tree_view_=new Gtk::TreeView;
  94
  95         //Gtk::HPaned* hpaned(manage(new Gtk::HPaned()));
  96         //hpaned->show();
  97         //attach(*hpaned, 0, 3, 0, 1, Gtk::EXPAND|Gtk::FILL,Gtk::EXPAND|Gtk::FILL, 0, 0);
  98         //attach(*create_layer_tree(), 0, 3, 0, 1, Gtk::EXPAND|Gtk::FILL,Gtk::EXPAND|Gtk::FILL, 0, 0);
  99
 100         create_layer_tree();
 101         create_param_tree();
 102
 103         //hpaned->pack1(*create_layer_tree(),false,false);
 104         //hpaned->pack2(*create_param_tree(),true,false);
 105         //hpaned->set_position(200);
 106         hbox=manage(new Gtk::HBox());
 107
 108         attach(*hbox, 0, 1, 1, 2, Gtk::FILL|Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 109         attach(blend_method_widget, 2, 3, 1, 2,Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 110
 111         layer_amount_hscale=manage(new Gtk::HScale(layer_amount_adjustment_));
 112         layer_amount_hscale->set_digits(2);
 113         layer_amount_hscale->set_value_pos(Gtk::POS_LEFT);
 114         layer_amount_hscale->set_sensitive(false);
 115         layer_amount_hscale->set_update_policy( Gtk::UPDATE_DISCONTINUOUS);
 116         attach(*layer_amount_hscale, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 1, 1);
 117         layer_amount_adjustment_.signal_value_changed().connect(sigc::mem_fun(*this, &studio::LayerTree::on_amount_value_changed));
 118
 119         Gtk::Image *icon;
 120         //Gtk::IconSize iconsize(Gtk::IconSize::from_name("synfig-small_icon"));
 121         Gtk::IconSize iconsize(Gtk::ICON_SIZE_SMALL_TOOLBAR);
 122
 123         SMALL_BUTTON(button_raise,"gtk-go-up","Raise");
 124         SMALL_BUTTON(button_lower,"gtk-go-down","Lower");
 125         SMALL_BUTTON(button_duplicate,"synfig-duplicate","Duplicate");
 126         SMALL_BUTTON(button_delete,"gtk-delete","Delete");
 127
 128         hbox->pack_start(*button_raise,Gtk::PACK_SHRINK);
 129         hbox->pack_start(*button_lower,Gtk::PACK_SHRINK);
 130         hbox->pack_start(*button_duplicate,Gtk::PACK_SHRINK);
 131         hbox->pack_start(*button_delete,Gtk::PACK_SHRINK);
 132
 133         button_raise->signal_clicked().connect(sigc::mem_fun(*this, &studio::LayerTree::on_raise_pressed));
 134         button_lower->signal_clicked().connect(sigc::mem_fun(*this, &studio::LayerTree::on_lower_pressed));
 135         button_duplicate->signal_clicked().connect(sigc::mem_fun(*this, &studio::LayerTree::on_duplicate_pressed));
 136         button_delete->signal_clicked().connect(sigc::mem_fun(*this, &studio::LayerTree::on_delete_pressed));
 137
 138         button_raise->set_sensitive(false);
 139         button_lower->set_sensitive(false);
 140         button_duplicate->set_sensitive(false);
 141         button_delete->set_sensitive(false);
 142
 143         get_selection()->signal_changed().connect(sigc::mem_fun(*this, &studio::LayerTree::on_selection_changed));
 144
 145         get_layer_tree_view().set_reorderable(true);
 146         get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
 147         //get_param_tree_view().get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
 148         get_layer_tree_view().show();
 149         get_param_tree_view().show();
 150
 151         hbox->show();
 152         layer_amount_hscale->show();
 153         blend_method_widget.show();
 154
 155         tooltips_.enable();
 156         disable_amount_changed_signal=false;
 157
 158         blend_method_widget.set_param_desc(ParamDesc(Color::BlendMethod(),"blend_method"));
 159
 160         blend_method_widget.set_value((int)Color::BLEND_COMPOSITE);
 161         blend_method_widget.set_size_request(150,-1);
 162         blend_method_widget.set_sensitive(false);
 163         blend_method_widget.signal_activate().connect(sigc::mem_fun(*this, &studio::LayerTree::on_blend_method_changed));
 164 }
 165
 166 LayerTree::~LayerTree()
 167 {
 168         synfig::info("LayerTree::~LayerTree(): Deleted");
 169 }
 170
 171 Gtk::Widget*
 172 LayerTree::create_layer_tree()
 173 {
 174         const LayerTreeStore::Model model;
 175
 176         {       // --- O N / O F F ----------------------------------------------------
 177                 //int index;
 178                 //index=get_layer_tree_view().append_column_editable(_(" "),layer_model.active);
 179                 //Gtk::TreeView::Column* column = get_layer_tree_view().get_column(index-1);
 180
 181                 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_(" ")) );
 182
 183                 // Set up the icon cell-renderer
 184                 Gtk::CellRendererToggle* cellrenderer = Gtk::manage( new Gtk::CellRendererToggle() );
 185                 cellrenderer->signal_toggled().connect(sigc::mem_fun(*this, &studio::LayerTree::on_layer_toggle));
 186
 187                 column->pack_start(*cellrenderer,false);
 188                 column->add_attribute(cellrenderer->property_active(), layer_model.active);
 189                 get_layer_tree_view().append_column(*column);
 190         }
 191
 192         {       // --- I C O N --------------------------------------------------------
 193                 int index;
 194                 index=get_layer_tree_view().append_column(_("Z"),layer_model.icon);
 195                 Gtk::TreeView::Column* column = get_layer_tree_view().get_column(index-1);
 196                 get_layer_tree_view().set_expander_column(*column);
 197
 198                 column->set_sort_column_id(layer_model.z_depth);
 199                 //column->set_reorderable();
 200                 //column->set_resizable();
 201                 //column->set_clickable();
 202
 203                 //Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
 204                 //column->pack_start(*icon_cellrenderer,false);
 205                 //column->add_attribute(icon_cellrenderer->property_pixbuf(), layer_model.icon);
 206         }
 207         //get_layer_tree_view().append_column(_("Z"),layer_model.z_depth);
 208         {       // --- N A M E --------------------------------------------------------
 209                 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Layer")) );
 210
 211                 // Set up the icon cell-renderer
 212                 Gtk::CellRendererText* cellrenderer = Gtk::manage( new Gtk::CellRendererText() );
 213                 cellrenderer->signal_edited().connect(sigc::mem_fun(*this, &studio::LayerTree::on_layer_renamed));
 214                 cellrenderer->property_editable()=true;
 215
 216                 column->pack_start(*cellrenderer,false);
 217                 column->add_attribute(cellrenderer->property_text(), layer_model.label);
 218                 get_layer_tree_view().append_column(*column);
 219
 220                 //              int index;
 221 //              index=get_layer_tree_view().append_column_editable(_("Layer"),layer_model.label);
 222                 //Gtk::TreeView::Column* column = get_layer_tree_view().get_column(index-1);
 223
 224                 //column->set_sort_column_id(layer_model.index);
 225
 226                 //get_layer_tree_view().set_expander_column(*column);
 227                 //column->set_reorderable();
 228                 //column->set_resizable();
 229                 //column->set_clickable(false);
 230
 231                 //Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
 232                 //column->pack_start(*icon_cellrenderer,false);
 233                 //column->add_attribute(icon_cellrenderer->property_pixbuf(), layer_model.icon);
 234         }
 235         {       // --- Z D E P T H ----------------------------------------------------
 236                 int index;
 237                 index=get_layer_tree_view().append_column(_("Z"),layer_model.z_depth);
 238                 column_z_depth=get_layer_tree_view().get_column(index-1);
 239
 240                 column_z_depth->set_reorderable();
 241                 column_z_depth->set_resizable();
 242                 column_z_depth->set_clickable();
 243
 244                 column_z_depth->set_sort_column_id(layer_model.z_depth);
 245         }
 246
 247         get_layer_tree_view().set_enable_search(true);
 248         get_layer_tree_view().set_search_column(layer_model.label);
 249         get_layer_tree_view().set_search_equal_func(sigc::ptr_fun(&studio::LayerTreeStore::search_func));
 250
 251         std::list<Gtk::TargetEntry> listTargets;
 252         listTargets.push_back( Gtk::TargetEntry("LAYER") );
 253         get_layer_tree_view().drag_dest_set(listTargets);
 254
 255         // This makes things easier to read.
 256         get_layer_tree_view().set_rules_hint();
 257
 258         // Make us more sensitive to several events
 259         //get_layer_tree_view().add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::BUTTON1_MOTION_MASK | Gdk::BUTTON2_MOTION_MASK|Gdk::POINTER_MOTION_MASK);
 260
 261         get_layer_tree_view().signal_event().connect(sigc::mem_fun(*this, &studio::LayerTree::on_layer_tree_event));
 262         get_layer_tree_view().show();
 263
 264         Gtk::ScrolledWindow *scroll = manage(new class Gtk::ScrolledWindow());
 265         scroll->set_flags(Gtk::CAN_FOCUS);
 266         scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 267         //scroll->add(get_layer_tree_view());
 268         scroll->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
 269         scroll->show();
 270
 271         return scroll;
 272 }
 273
 274 Gtk::Widget*
 275 LayerTree::create_param_tree()
 276 {
 277         Pango::AttrList attr_list;
 278         {
 279                 Pango::AttrInt pango_size(Pango::Attribute::create_attr_size(Pango::SCALE*8));
 280                 pango_size.set_start_index(0);
 281                 pango_size.set_end_index(64);
 282                 attr_list.change(pango_size);
 283         }
 284
 285         Gtk::IconSize icon_size(Gtk::ICON_SIZE_SMALL_TOOLBAR);
 286
 287         {       // --- N A M E --------------------------------------------------------
 288                 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Name")) );
 289
 290                 // Set up the icon cell-renderer
 291                 Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
 292                 column->pack_start(*icon_cellrenderer,false);
 293                 column->add_attribute(icon_cellrenderer->property_pixbuf(), param_model.icon);
 294
 295                 // Pack the label into the column
 296                 //column->pack_start(layer_model.label,true);
 297                 Gtk::CellRendererText* text_cellrenderer = Gtk::manage( new Gtk::CellRendererText() );
 298                 column->pack_start(*text_cellrenderer,false);
 299                 column->add_attribute(text_cellrenderer->property_text(), param_model.label);
 300                 text_cellrenderer->property_attributes()=attr_list;
 301
 302                 text_cellrenderer->property_foreground()=Glib::ustring("#7f7f7f");
 303                 column->add_attribute(text_cellrenderer->property_foreground_set(),param_model.is_inconsistent);
 304
 305                 // Pack the label into the column
 306                 //column->pack_start(param_model.label,true);
 307
 308                 // Set up the value-node icon cell-renderer to be on the far right
 309                 Gtk::CellRendererPixbuf* valuenode_icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
 310                 column->pack_end(*valuenode_icon_cellrenderer,false);
 311                 valuenode_icon_cellrenderer->property_pixbuf()=Gtk::Button().render_icon(Gtk::StockID("synfig-value_node"),icon_size);
 312                 column->add_attribute(valuenode_icon_cellrenderer->property_visible(), param_model.is_shared);
 313
 314                 // Finish setting up the column
 315                 column->set_reorderable();
 316                 column->set_resizable();
 317                 column->set_clickable();
 318
 319                 get_param_tree_view().append_column(*column);
 320         }
 321         {       // --- V A L U E  -----------------------------------------------------
 322                 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Value")) );
 323
 324                 // Set up the value cell-renderer
 325                 cellrenderer_value=LayerParamTreeStore::add_cell_renderer_value(column);
 326                 cellrenderer_value->signal_edited().connect(sigc::mem_fun(*this, &studio::LayerTree::on_edited_value));
 327                 cellrenderer_value->property_value()=synfig::ValueBase();
 328                 column->add_attribute(cellrenderer_value->property_param_desc(), param_model.param_desc);
 329                 column->add_attribute(cellrenderer_value->property_inconsistent(),param_model.is_inconsistent);
 330                 //cellrenderer_value->property_canvas()=canvas_interface->get_canvas(); // Is this line necessary?
 331                 cellrenderer_value->property_attributes()=attr_list;
 332
 333                 // Finish setting up the column
 334                 get_param_tree_view().append_column(*column);
 335                 column->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 336                 column->set_clickable();
 337                 column->set_min_width(120);
 338                 column->set_reorderable();
 339                 column->set_resizable();
 340         }
 341         {       // --- T Y P E --------------------------------------------------------
 342                 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Type")) );
 343                 Gtk::CellRendererText* text_cellrenderer = Gtk::manage( new Gtk::CellRendererText() );
 344                 column->pack_start(*text_cellrenderer,false);
 345                 column->add_attribute(text_cellrenderer->property_text(), param_model.type);
 346                 text_cellrenderer->property_attributes()=attr_list;
 347                 get_param_tree_view().append_column(*column);
 348                 column->set_reorderable();
 349                 column->set_resizable();
 350                 column->set_clickable();
 351                 column->set_sort_column_id(param_model.type);
 352         }
 353         /*{     // --- T I M E   T R A C K --------------------------------------------
 354                 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Time Track")) );
 355                 column_time_track=column;
 356
 357                 // Set up the value-node cell-renderer
 358                 cellrenderer_time_track=LayerParamTreeStore::add_cell_renderer_value_node(column);
 359                 cellrenderer_time_track->property_mode()=Gtk::CELL_RENDERER_MODE_ACTIVATABLE;
 360                 cellrenderer_time_track->signal_waypoint_clicked().connect(sigc::mem_fun(*this, &studio::LayerTree::on_waypoint_clicked) );
 361                 cellrenderer_time_track->signal_waypoint_changed().connect(sigc::mem_fun(*this, &studio::LayerTree::on_waypoint_changed) );
 362                 column->add_attribute(cellrenderer_time_track->property_value_desc(), param_model.value_desc);
 363                 column->add_attribute(cellrenderer_time_track->property_canvas(), param_model.canvas);
 364                 //column->add_attribute(cellrenderer_time_track->property_visible(), model.is_value_node);
 365
 366                 //column->pack_start(*cellrenderer_time_track);
 367
 368                 // Finish setting up the column
 369                 column->set_reorderable();
 370                 column->set_resizable();
 371                 column->set_min_width(200);
 372                 //get_param_tree_view().append_column(*column);
 373         }*/
 374
 375         // This makes things easier to read.
 376         get_param_tree_view().set_rules_hint();
 377
 378         // Make us more sensitive to several events
 379         get_param_tree_view().add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::BUTTON1_MOTION_MASK | Gdk::BUTTON2_MOTION_MASK|Gdk::POINTER_MOTION_MASK);
 380
 381         get_param_tree_view().signal_event().connect(sigc::mem_fun(*this, &studio::LayerTree::on_param_tree_event));
 382         get_param_tree_view().show();
 383
 384         Gtk::ScrolledWindow *scroll = manage(new class Gtk::ScrolledWindow());
 385         scroll->set_flags(Gtk::CAN_FOCUS);
 386         scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 387         //scroll->add(get_param_tree_view());
 388         scroll->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
 389         scroll->show();
 390
 391         //column_time_track->set_visible(false);
 392
 393         return scroll;
 394 }
 395
 396 void
 397 LayerTree::on_waypoint_changed( synfig::Waypoint waypoint , synfig::ValueNode::Handle value_node)
 398 {
 399         synfigapp::Action::ParamList param_list;
 400         param_list.add("canvas",layer_tree_store_->canvas_interface()->get_canvas());
 401         param_list.add("canvas_interface",layer_tree_store_->canvas_interface());
 402         param_list.add("value_node",value_node);
 403         param_list.add("waypoint",waypoint);
 404 //      param_list.add("time",canvas_interface()->get_time());
 405
 406         etl::handle<studio::Instance>::cast_static(layer_tree_store_->canvas_interface()->get_instance())->process_action("waypoint_set_smart", param_list);
 407 }
 408
 409 void
 410 LayerTree::select_layer(Layer::Handle layer)
 411 {
 412         Gtk::TreeModel::Children::iterator iter;
 413         if(layer_tree_store_->find_layer_row(layer,iter))
 414         {
 415                 if(sorted_layer_tree_store_)
 416                         iter=sorted_layer_tree_store_->convert_child_iter_to_iter(iter);
 417
 418                 Gtk::TreePath path(iter);
 419                 for(int i=path.get_depth();i;i--)
 420                 {
 421                         int j;
 422                         path=Gtk::TreePath(iter);
 423                         for(j=i;j;j--)
 424                                 path.up();
 425                         get_layer_tree_view().expand_row(path,false);
 426                 }
 427                 get_layer_tree_view().scroll_to_row(Gtk::TreePath(iter));
 428                 get_layer_tree_view().get_selection()->select(iter);
 429         }
 430 }
 431
 432 void
 433 LayerTree::select_all_children(Gtk::TreeModel::Children::iterator iter)
 434 {
 435         get_layer_tree_view().get_selection()->select(iter);
 436         if((bool)(*iter)[layer_model.children_lock])
 437                 return;
 438         get_layer_tree_view().expand_row(layer_tree_store_->get_path(iter),false);
 439         Gtk::TreeModel::Children children(iter->children());
 440         for(iter=children.begin();iter!=children.end();++iter)
 441                 select_all_children(iter);
 442 }
 443
 444 void
 445 LayerTree::select_all_children_layers(synfig::Layer::Handle layer)
 446 {
 447         Gtk::TreeModel::Children::iterator iter;
 448         if(layer_tree_store_->find_layer_row(layer,iter))
 449                 select_all_children(iter);
 450 }
 451
 452 void
 453 LayerTree::select_layers(const LayerList &layer_list)
 454 {
 455         LayerList::const_iterator iter;
 456         for(iter = layer_list.begin(); iter != layer_list.end(); ++iter)
 457                 select_layer(*iter);
 458 }
 459
 460 static inline void __layer_grabber(const Gtk::TreeModel::iterator& iter, LayerTree::LayerList* ret)
 461 {
 462         const LayerTreeStore::Model layer_tree_model;
 463         ret->push_back((Layer::Handle)(*iter)[layer_tree_model.layer]);
 464 }
 465
 466 LayerTree::LayerList
 467 LayerTree::get_selected_layers()const
 468 {
 469         Glib::RefPtr<Gtk::TreeSelection> selection=const_cast<Gtk::TreeView&>(get_layer_tree_view()).get_selection();
 470
 471         if(!selection)
 472                 return LayerList();
 473
 474         LayerList ret;
 475
 476         selection->selected_foreach_iter(
 477                 sigc::bind(
 478                         sigc::ptr_fun(
 479                                 &__layer_grabber
 480                         ),
 481                         &ret
 482                 )
 483         );
 484
 485         return ret;
 486 }
 487
 488 synfig::Layer::Handle
 489 LayerTree::get_selected_layer()const
 490 {
 491         LayerList layers(get_selected_layers());
 492
 493         if(layers.empty())
 494                 return 0;
 495
 496         return *layers.begin();
 497 }
 498
 499 void
 500 LayerTree::clear_selected_layers()
 501 {
 502         get_layer_tree_view().get_selection()->unselect_all();
 503 }
 504
 505 void
 506 LayerTree::set_show_timetrack(bool x)
 507 {
 508         //column_time_track->set_visible(x);
 509 //      column_time_track->set_visible(false);
 510         column_z_depth->set_visible(x);
 511 }
 512
 513 void
 514 LayerTree::set_model(Glib::RefPtr<LayerTreeStore> layer_tree_store)
 515 {
 516         layer_tree_store_=layer_tree_store;
 517
 518         if(false)
 519         {
 520                 sorted_layer_tree_store_=Gtk::TreeModelSort::create(layer_tree_store);
 521
 522                 sorted_layer_tree_store_->set_default_sort_func(sigc::ptr_fun(&studio::LayerTreeStore::z_sorter));
 523
 524                 //sorted_store->set_sort_func(model.time.index(),sigc::mem_fun(&studio::KeyframeTreeStore::time_sorter));
 525                 //sorted_store->set_sort_column_id(model.time.index(), Gtk::SORT_ASCENDING);
 526
 527                 get_layer_tree_view().set_model(sorted_layer_tree_store_);
 528         }
 529         else
 530                 get_layer_tree_view().set_model(layer_tree_store_);
 531
 532         layer_tree_store_->canvas_interface()->signal_dirty_preview().connect(sigc::mem_fun(*this,&studio::LayerTree::on_dirty_preview));
 533
 534         //layer_tree_store_->canvas_interface()->signal_dirty_preview().connect(sigc::mem_fun(*this,&studio::LayerTree::on_dirty_preview));
 535
 536         layer_tree_store_->canvas_interface()->signal_time_changed().connect(
 537                 sigc::mem_fun(
 538                         &get_param_tree_view(),
 539                         &Gtk::Widget::queue_draw
 540                 )
 541         );
 542         if(!param_tree_store_)
 543         {
 544                 param_tree_store_=LayerParamTreeStore::create(layer_tree_store_->canvas_interface(), this);
 545                 get_param_tree_view().set_model(param_tree_store_);
 546         }
 547
 548 /*      if(cellrenderer_time_track && layer_tree_store_ && layer_tree_store_->canvas_interface())
 549         {
 550                 cellrenderer_time_track->set_canvas_interface(layer_tree_store_->canvas_interface());
 551         }
 552 */
 553 }
 554
 555 void
 556 LayerTree::set_time_adjustment(Gtk::Adjustment &adjustment)
 557 {
 558         //cellrenderer_time_track->set_adjustment(adjustment);
 559         adjustment.signal_value_changed().connect(sigc::mem_fun(get_param_tree_view(),&Gtk::TreeView::queue_draw));
 560         adjustment.signal_changed().connect(sigc::mem_fun(get_param_tree_view(),&Gtk::TreeView::queue_draw));
 561 }
 562
 563 void
 564 LayerTree::on_dirty_preview()
 565 {
 566 /*
 567         if(quick_layer && !disable_amount_changed_signal)
 568         {
 569                 layer_amount_hscale->set_sensitive(true);
 570                 disable_amount_changed_signal=true;
 571                 layer_amount_adjustment_.set_value(quick_layer->get_param("amount").get(Real()));
 572                 disable_amount_changed_signal=false;
 573                 if(quick_layer->get_param("blend_method").is_valid())
 574                 {
 575                         blend_method_widget.set_sensitive(true);
 576                         disable_amount_changed_signal=true;
 577                         blend_method_widget.set_value(quick_layer->get_param("blend_method"));
 578                         disable_amount_changed_signal=false;
 579                 }
 580         }
 581 */
 582 }
 583
 584 void
 585 LayerTree::on_selection_changed()
 586 {
 587         synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
 588
 589         Gtk::TreeIter iter;
 590         if(last_top_selected_layer && !layer_tree_store_->find_layer_row(last_top_selected_layer,iter))
 591         {
 592                 if(layer_list.empty())
 593                 {
 594                         last_top_selected_layer=0;
 595                         layer_tree_view_->get_selection()->select(last_top_selected_path);
 596                         return;
 597                 }
 598         }
 599
 600         {
 601                 if(!layer_list.empty())
 602                 {
 603                         last_top_selected_layer=layer_list.front();
 604                         last_top_selected_path=*layer_tree_view_->get_selection()->get_selected_rows().begin();
 605                 }
 606                 else
 607                 {
 608                         last_top_selected_layer=0;
 609                 }
 610         }
 611
 612         if(layer_list.empty())
 613         {
 614                 button_raise->set_sensitive(false);
 615                 button_lower->set_sensitive(false);
 616                 button_duplicate->set_sensitive(false);
 617                 button_delete->set_sensitive(false);
 618                 layer_amount_hscale->set_sensitive(false);
 619                 blend_method_widget.set_sensitive(false);
 620                 return;
 621         }
 622
 623         button_raise->set_sensitive(true);
 624         button_lower->set_sensitive(true);
 625         button_duplicate->set_sensitive(true);
 626         button_delete->set_sensitive(true);
 627
 628         if(layer_list.size()==1 && (*layer_list.begin())->get_param("amount").is_valid()&& (*layer_list.begin())->get_param("amount").same_type_as(Real()))
 629         {
 630                 quick_layer=*layer_list.begin();
 631         }
 632         else
 633                 quick_layer=0;
 634
 635         if(quick_layer)
 636         {
 637                 layer_amount_hscale->set_sensitive(true);
 638                 disable_amount_changed_signal=true;
 639                 layer_amount_adjustment_.set_value(quick_layer->get_param("amount").get(Real()));
 640                 disable_amount_changed_signal=false;
 641                 if(quick_layer->get_param("blend_method").is_valid())
 642                 {
 643                         blend_method_widget.set_sensitive(true);
 644                         disable_amount_changed_signal=true;
 645                         blend_method_widget.set_value(quick_layer->get_param("blend_method"));
 646                         disable_amount_changed_signal=false;
 647                 }
 648                 else
 649                         blend_method_widget.set_sensitive(false);
 650         }
 651         else
 652         {
 653                 layer_amount_hscale->set_sensitive(false);
 654                 blend_method_widget.set_sensitive(false);
 655         }
 656 }
 657
 658 void
 659 LayerTree::on_blend_method_changed()
 660 {
 661         if(disable_amount_changed_signal)
 662                 return;
 663         if(!quick_layer)
 664                 return;
 665
 666         if(quick_layer->get_param("blend_method").is_valid())
 667         {
 668                 disable_amount_changed_signal=true;
 669                 signal_edited_value()(synfigapp::ValueDesc(quick_layer,"blend_method"),blend_method_widget.get_value());
 670                 disable_amount_changed_signal=false;
 671         }
 672 }
 673
 674 void
 675 LayerTree::on_amount_value_changed()
 676 {
 677         if(disable_amount_changed_signal)
 678                 return;
 679         if(!quick_layer)
 680                 return;
 681
 682         disable_amount_changed_signal=true;
 683         signal_edited_value()(synfigapp::ValueDesc(quick_layer,"amount"),synfig::ValueBase(layer_amount_adjustment_.get_value()));
 684         disable_amount_changed_signal=false;
 685 }
 686
 687 void
 688 LayerTree::on_edited_value(const Glib::ustring&path_string,synfig::ValueBase value)
 689 {
 690         Gtk::TreePath path(path_string);
 691
 692         const Gtk::TreeRow row = *(get_param_tree_view().get_model()->get_iter(path));
 693         if(!row)
 694                 return;
 695         row[param_model.value]=value;
 696         //signal_edited_value()(row[param_model.value_desc],value);
 697 }
 698
 699 void
 700 LayerTree::on_layer_renamed(const Glib::ustring&path_string,const Glib::ustring& value)
 701 {
 702         Gtk::TreePath path(path_string);
 703
 704         const Gtk::TreeRow row = *(get_layer_tree_view().get_model()->get_iter(path));
 705         if(!row)
 706                 return;
 707         row[layer_model.label]=value;
 708 }
 709
 710 void
 711 LayerTree::on_layer_toggle(const Glib::ustring& path_string)
 712 {
 713         Gtk::TreePath path(path_string);
 714
 715         const Gtk::TreeRow row = *(get_layer_tree_view().get_model()->get_iter(path));
 716         bool active=static_cast<bool>(row[layer_model.active]);
 717         row[layer_model.active]=!active;
 718 }
 719
 720 void
 721 LayerTree::on_waypoint_clicked(const Glib::ustring &path_string, synfig::Waypoint waypoint,int button)
 722 {
 723         Gtk::TreePath path(path_string);
 724
 725         const Gtk::TreeRow row = *(get_param_tree_view().get_model()->get_iter(path));
 726         if(!row)
 727                 return;
 728
 729         signal_waypoint_clicked()(static_cast<synfigapp::ValueDesc>(row[param_model.value_desc]),waypoint,button);
 730 }
 731
 732 bool
 733 LayerTree::on_layer_tree_event(GdkEvent *event)
 734 {
 735     switch(event->type)
 736     {
 737         case GDK_BUTTON_PRESS:
 738                 {
 739                         Gtk::TreeModel::Path path;
 740                         Gtk::TreeViewColumn *column;
 741                         int cell_x, cell_y;
 742                         if(!get_layer_tree_view().get_path_at_pos(
 743                                 int(event->button.x),int(event->button.y),      // x, y
 744                                 path, // TreeModel::Path&
 745                                 column, //TreeViewColumn*&
 746                                 cell_x,cell_y //int&cell_x,int&cell_y
 747                                 )
 748                         ) break;
 749                         const Gtk::TreeRow row = *(get_layer_tree_view().get_model()->get_iter(path));
 750
 751                         //if(column->get_first_cell_renderer()==cellrenderer_time_track)
 752                         //      return signal_layer_user_click()(event->button.button,row,COLUMNID_TIME_TRACK);
 753                         //else
 754                                 if(column->get_first_cell_renderer()==cellrenderer_value)
 755                                 return signal_layer_user_click()(event->button.button,row,COLUMNID_VALUE);
 756                         else
 757                                 return signal_layer_user_click()(event->button.button,row,COLUMNID_NAME);
 758
 759                 }
 760                 break;
 761
 762         case GDK_MOTION_NOTIFY:
 763                 {
 764                         Gtk::TreeModel::Path path;
 765                         Gtk::TreeViewColumn *column;
 766                         int cell_x, cell_y;
 767                         if(!get_layer_tree_view().get_path_at_pos(
 768                                 (int)event->button.x,(int)event->button.y,      // x, y
 769                                 path, // TreeModel::Path&
 770                                 column, //TreeViewColumn*&
 771                                 cell_x,cell_y //int&cell_x,int&cell_y
 772                                 )
 773                         ) break;
 774
 775                         if(!get_layer_tree_view().get_model()->get_iter(path))
 776                                 break;
 777
 778                         Gtk::TreeRow row = *(get_layer_tree_view().get_model()->get_iter(path));
 779
 780                         /*
 781                         if(cellrenderer_time_track==column->get_first_cell_renderer())
 782                         {
 783                                 // Movement on TimeLine
 784                                 return true;
 785                         }
 786                         else
 787                                 */
 788                         if(last_tooltip_path.get_depth()<=0 || path!=last_tooltip_path)
 789                         {
 790                                 tooltips_.unset_tip(*this);
 791                                 Glib::ustring tooltips_string(row[layer_model.tooltip]);
 792                                 last_tooltip_path=path;
 793                                 if(!tooltips_string.empty())
 794                                 {
 795                                         tooltips_.set_tip(*this,tooltips_string);
 796                                         tooltips_.force_window();
 797                                 }
 798                         }
 799                 }
 800                 break;
 801         case GDK_BUTTON_RELEASE:
 802                 break;
 803         default:
 804                 break;
 805         }
 806         return false;
 807 }
 808
 809 bool
 810 LayerTree::on_param_tree_event(GdkEvent *event)
 811 {
 812     switch(event->type)
 813     {
 814         case GDK_BUTTON_PRESS:
 815                 {
 816                         Gtk::TreeModel::Path path;
 817                         Gtk::TreeViewColumn *column;
 818                         int cell_x, cell_y;
 819                         if(!get_param_tree_view().get_path_at_pos(
 820                                 int(event->button.x),int(event->button.y),      // x, y
 821                                 path, // TreeModel::Path&
 822                                 column, //TreeViewColumn*&
 823                                 cell_x,cell_y //int&cell_x,int&cell_y
 824                                 )
 825                         ) break;
 826                         const Gtk::TreeRow row = *(get_param_tree_view().get_model()->get_iter(path));
 827
 828 /*                      if(column && column->get_first_cell_renderer()==cellrenderer_time_track)
 829                         {
 830                                 Gdk::Rectangle rect;
 831                                 get_param_tree_view().get_cell_area(path,*column,rect);
 832                                 cellrenderer_time_track->property_value_desc()=row[param_model.value_desc];
 833                                 cellrenderer_time_track->property_canvas()=row[param_model.canvas];
 834                                 cellrenderer_time_track->activate(event,*this,path.to_string(),rect,rect,Gtk::CellRendererState());
 835                                 get_param_tree_view().queue_draw_area(rect.get_x(),rect.get_y(),rect.get_width(),rect.get_height());
 836                                 return true;
 837                                 //return signal_param_user_click()(event->button.button,row,COLUMNID_TIME_TRACK);
 838                         }
 839                         else
 840 */                      {
 841                                 if(event->button.button==3)
 842                                 {
 843                                         LayerList layer_list(get_selected_layers());
 844                                         if(layer_list.size()<=1)
 845                                         {
 846                                                 synfigapp::ValueDesc value_desc(row[param_model.value_desc]);
 847                                                 Gtk::Menu* menu(manage(new Gtk::Menu()));
 848                                                 menu->signal_hide().connect(sigc::bind(sigc::ptr_fun(&delete_widget), menu));
 849                                                 App::get_instance(param_tree_store_->canvas_interface()->get_canvas())->make_param_menu(menu,param_tree_store_->canvas_interface()->get_canvas(),value_desc,0.5f);
 850                                                 menu->popup(event->button.button,gtk_get_current_event_time());
 851                                                 return true;
 852                                         }
 853                                         Gtk::Menu* menu(manage(new Gtk::Menu()));
 854                                         menu->signal_hide().connect(sigc::bind(sigc::ptr_fun(&delete_widget), menu));
 855                                         std::list<synfigapp::ValueDesc> value_desc_list;
 856                                         ParamDesc param_desc(row[param_model.param_desc]);
 857                                         for(;!layer_list.empty();layer_list.pop_back())
 858                                                 value_desc_list.push_back(synfigapp::ValueDesc(layer_list.back(),param_desc.get_name()));
 859                                         App::get_instance(param_tree_store_->canvas_interface()->get_canvas())->make_param_menu(menu,param_tree_store_->canvas_interface()->get_canvas(),value_desc_list);
 860                                         menu->popup(event->button.button,gtk_get_current_event_time());
 861                                         return true;
 862                                 }
 863                                 else
 864                                 {
 865                                         if(column->get_first_cell_renderer()==cellrenderer_value)
 866                                                 return signal_param_user_click()(event->button.button,row,COLUMNID_VALUE);
 867                                         else
 868                                                 return signal_param_user_click()(event->button.button,row,COLUMNID_NAME);
 869                                 }
 870                         }
 871                 }
 872                 break;
 873
 874         case GDK_MOTION_NOTIFY:
 875                 {
 876                         Gtk::TreeModel::Path path;
 877                         Gtk::TreeViewColumn *column;
 878                         int cell_x, cell_y;
 879                         if(!get_param_tree_view().get_path_at_pos(
 880                                 (int)event->motion.x,(int)event->motion.y,      // x, y
 881                                 path, // TreeModel::Path&
 882                                 column, //TreeViewColumn*&
 883                                 cell_x,cell_y //int&cell_x,int&cell_y
 884                                 )
 885                         ) break;
 886
 887                         if(!get_param_tree_view().get_model()->get_iter(path))
 888                                 break;
 889
 890                         Gtk::TreeRow row = *(get_param_tree_view().get_model()->get_iter(path));
 891
 892 /*                      if((event->motion.state&GDK_BUTTON1_MASK ||event->motion.state&GDK_BUTTON3_MASK) && column && cellrenderer_time_track==column->get_first_cell_renderer())
 893                         {
 894                                 Gdk::Rectangle rect;
 895                                 get_param_tree_view().get_cell_area(path,*column,rect);
 896                                 cellrenderer_time_track->property_value_desc()=row[param_model.value_desc];
 897                                 cellrenderer_time_track->property_canvas()=row[param_model.canvas];
 898                                 cellrenderer_time_track->activate(event,*this,path.to_string(),rect,rect,Gtk::CellRendererState());
 899                                 get_param_tree_view().queue_draw();
 900                                 //get_param_tree_view().queue_draw_area(rect.get_x(),rect.get_y(),rect.get_width(),rect.get_height());
 901                                 return true;
 902                         }
 903                         else
 904 */                      if(last_tooltip_path.get_depth()<=0 || path!=last_tooltip_path)
 905                         {
 906                                 tooltips_.unset_tip(*this);
 907                                 Glib::ustring tooltips_string(row[layer_model.tooltip]);
 908                                 last_tooltip_path=path;
 909                                 if(!tooltips_string.empty())
 910                                 {
 911                                         tooltips_.set_tip(*this,tooltips_string);
 912                                         tooltips_.force_window();
 913                                 }
 914                         }
 915                 }
 916                 break;
 917         case GDK_BUTTON_RELEASE:
 918                 {
 919                         Gtk::TreeModel::Path path;
 920                         Gtk::TreeViewColumn *column;
 921                         int cell_x, cell_y;
 922                         if(!get_param_tree_view().get_path_at_pos(
 923                                 (int)event->button.x,(int)event->button.y,      // x, y
 924                                 path, // TreeModel::Path&
 925                                 column, //TreeViewColumn*&
 926                                 cell_x,cell_y //int&cell_x,int&cell_y
 927                                 )
 928                         ) break;
 929
 930                         if(!get_param_tree_view().get_model()->get_iter(path))
 931                                 break;
 932
 933                         Gtk::TreeRow row = *(get_param_tree_view().get_model()->get_iter(path));
 934
 935 /*                      if(column && cellrenderer_time_track==column->get_first_cell_renderer())
 936                         {
 937                                 Gdk::Rectangle rect;
 938                                 get_param_tree_view().get_cell_area(path,*column,rect);
 939                                 cellrenderer_time_track->property_value_desc()=row[param_model.value_desc];
 940                                 cellrenderer_time_track->property_canvas()=row[param_model.canvas];
 941                                 cellrenderer_time_track->activate(event,*this,path.to_string(),rect,rect,Gtk::CellRendererState());
 942                                 get_param_tree_view().queue_draw();
 943                                 get_param_tree_view().queue_draw_area(rect.get_x(),rect.get_y(),rect.get_width(),rect.get_height());
 944                                 return true;
 945
 946                         }
 947 */
 948                 }
 949                 break;
 950         default:
 951                 break;
 952         }
 953         return false;
 954 }
 955
 956 void
 957 LayerTree::on_raise_pressed()
 958 {
 959         synfigapp::Action::ParamList param_list;
 960         param_list.add("time",layer_tree_store_->canvas_interface()->get_time());
 961         param_list.add("canvas",layer_tree_store_->canvas_interface()->get_canvas());
 962         param_list.add("canvas_interface",layer_tree_store_->canvas_interface());
 963
 964         {
 965                 synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
 966                 synfigapp::SelectionManager::LayerList::iterator iter;
 967
 968                 for(iter=layer_list.begin();iter!=layer_list.end();++iter)
 969                         param_list.add("layer",Layer::Handle(*iter));
 970         }
 971         synfigapp::Action::Handle action(synfigapp::Action::create("layer_raise"));
 972         action->set_param_list(param_list);
 973         layer_tree_store_->canvas_interface()->get_instance()->perform_action(action);
 974 }
 975
 976 void
 977 LayerTree::on_lower_pressed()
 978 {
 979         synfigapp::Action::ParamList param_list;
 980         param_list.add("time",layer_tree_store_->canvas_interface()->get_time());
 981         param_list.add("canvas",layer_tree_store_->canvas_interface()->get_canvas());
 982         param_list.add("canvas_interface",layer_tree_store_->canvas_interface());
 983
 984         {
 985                 synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
 986                 synfigapp::SelectionManager::LayerList::iterator iter;
 987
 988                 for(iter=layer_list.begin();iter!=layer_list.end();++iter)
 989                         param_list.add("layer",Layer::Handle(*iter));
 990         }
 991
 992         synfigapp::Action::Handle action(synfigapp::Action::create("layer_lower"));
 993         action->set_param_list(param_list);
 994         layer_tree_store_->canvas_interface()->get_instance()->perform_action(action);
 995 }
 996
 997 void
 998 LayerTree::on_duplicate_pressed()
 999 {
1000         synfigapp::Action::ParamList param_list;
1001         param_list.add("time",layer_tree_store_->canvas_interface()->get_time());
1002         param_list.add("canvas",layer_tree_store_->canvas_interface()->get_canvas());
1003         param_list.add("canvas_interface",layer_tree_store_->canvas_interface());
1004
1005         {
1006                 synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
1007                 synfigapp::SelectionManager::LayerList::iterator iter;
1008
1009                 for(iter=layer_list.begin();iter!=layer_list.end();++iter)
1010                         param_list.add("layer",Layer::Handle(*iter));
1011         }
1012
1013         synfigapp::Action::Handle action(synfigapp::Action::create("layer_duplicate"));
1014         action->set_param_list(param_list);
1015         layer_tree_store_->canvas_interface()->get_instance()->perform_action(action);
1016 }
1017
1018 void
1019 LayerTree::on_delete_pressed()
1020 {
1021         synfigapp::Action::ParamList param_list;
1022         param_list.add("time",layer_tree_store_->canvas_interface()->get_time());
1023         param_list.add("canvas",layer_tree_store_->canvas_interface()->get_canvas());
1024         param_list.add("canvas_interface",layer_tree_store_->canvas_interface());
1025
1026         {
1027                 synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
1028                 synfigapp::SelectionManager::LayerList::iterator iter;
1029
1030                 for(iter=layer_list.begin();iter!=layer_list.end();++iter)
1031                         param_list.add("layer",Layer::Handle(*iter));
1032         }
1033
1034         synfigapp::Action::Handle action(synfigapp::Action::create("layer_remove"));
1035         action->set_param_list(param_list);
1036         layer_tree_store_->canvas_interface()->get_instance()->perform_action(action);
1037 }
1038
1039 /*
1040 void
1041 LayerTree::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&context, Gtk::SelectionData& selection_data, guint info, guint time)
1042 {
1043         synfig::info("Dragged data of type \"%s\"",selection_data.get_data_type());
1044         synfig::info("Dragged data of target \"%s\"",gdk_atom_name(selection_data->target));
1045         synfig::info("Dragged selection=\"%s\"",gdk_atom_name(selection_data->selection));
1046
1047         DEBUGPOINT();
1048
1049         Gtk::TreeModel::Path path;
1050         Gtk::TreeViewColumn *column;
1051         int cell_x, cell_y;
1052         if(get_selection()
1053         Gtk::TreeRow row = *(get_selection()->get_selected());
1054         DEBUGPOINT();
1055
1056         if(synfig::String(gdk_atom_name(selection_data->target))=="LAYER" && (bool)row[model.is_layer])
1057         {
1058                 DEBUGPOINT();
1059                 Layer* layer(((Layer::Handle)row[model.layer]).get());
1060                 assert(layer);
1061                 selection_data.set(8, reinterpret_cast<const guchar*>(&layer), sizeof(layer));
1062                 return;
1063         }
1064         DEBUGPOINT();
1065 }
1066
1067 void
1068 LayerTree::on_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, Gtk::SelectionData& selection_data, guint info, guint time)
1069 {
1070         synfig::info("Dropped data of type \"%s\"",selection_data.get_data_type());
1071         synfig::info("Dropped data of target \"%s\"",gdk_atom_name(selection_data->target));
1072         synfig::info("Dropped selection=\"%s\"",gdk_atom_name(selection_data->selection));
1073         synfig::info("Dropped x=%d, y=%d",x,y);
1074         bool success=false;
1075         bool dropped_on_specific_row=false;
1076
1077         Gtk::TreeModel::Path path;
1078         Gtk::TreeViewColumn *column;
1079         int cell_x, cell_y;
1080         if(!get_path_at_pos(
1081                 x,y,    // x, y
1082                 path, // TreeModel::Path&
1083                 column, //TreeViewColumn*&
1084                 cell_x,cell_y //int&cell_x,int&cell_y
1085                 )
1086         )
1087         {
1088                 dropped_on_specific_row=false;
1089         }
1090         else
1091                 dropped_on_specific_row=true;
1092
1093         Gtk::TreeRow row = *(get_model()->get_iter(path));
1094
1095         if ((selection_data.get_length() >= 0) && (selection_data.get_format() == 8))
1096         {
1097                 if(synfig::String(selection_data.get_data_type())=="LAYER")do
1098                 {
1099                         Layer::Handle src(*reinterpret_cast<Layer**>(selection_data.get_data()));
1100                         assert(src);
1101
1102                         Canvas::Handle dest_canvas;
1103                         Layer::Handle dest_layer;
1104
1105                         if(dropped_on_specific_row)
1106                         {
1107                                 dest_canvas=(Canvas::Handle)(row[model.canvas]);
1108                                 dest_layer=(Layer::Handle)(row[model.layer]);
1109                                 assert(dest_canvas);
1110                         }
1111                         else
1112                                 dest_canvas=layer_tree_store_->canvas_interface()->get_canvas();
1113
1114                         // In this case, we are just moving.
1115                         if(dest_canvas==src->get_canvas())
1116                         {
1117                                 if(!dest_layer || dest_layer==src)
1118                                         break;
1119
1120                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_move"));
1121                                 action->set_param("canvas",dest_canvas);
1122                                 action->set_param("canvas_interface",layer_tree_store_->canvas_interface());
1123                                 action->set_param("layer",src);
1124                                 action->set_param("new_index",dest_canvas->get_depth(dest_layer));
1125                                 if(layer_tree_store_->canvas_interface()->get_instance()->perform_action(action))
1126                                         success=true;
1127                                 else
1128                                         success=false;
1129                                 break;
1130                         }
1131                 }while(0);
1132         }
1133
1134         // Finish the drag
1135         context->drag_finish(success, false, time);
1136 }
1137 */
1138
1139 /*bool
1140 LayerTree::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context,int x, int    y, guint    time)
1141 {
1142         return get_layer_tree_view().on_drag_motion(context,x,y,time);
1143 }
1144
1145 void
1146 LayerTree::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, Gtk::SelectionData& selection_data, guint info, guint time)
1147 {
1148         get_layer_tree_view().on_drag_data_received(context,x,y,selection_data,info,time);
1149 */
1150 /*
1151         if(context->gobj()->source_window==context->gobj()->dest_window)
1152         {
1153                 Gtk::TreeView::on_drag_data_received(context,x,y,selection_data,info,time);
1154                 return;
1155         }
1156
1157         Gtk::TreeModel::Path path;
1158         Gtk::TreeViewColumn *column;
1159         int cell_x, cell_y;
1160         if(!get_path_at_pos(
1161                 x,y,    // x, y
1162                 path, // TreeModel::Path&
1163                 column, //TreeViewColumn*&
1164                 cell_x,cell_y //int&cell_x,int&cell_y
1165                 )
1166         )
1167         {
1168                 context->drag_finish(false, false, time);
1169         }
1170
1171         if(layer_tree_store_->row_drop_possible(path,selection_data))
1172         {
1173                 if(layer_tree_store_->drag_data_received(path,selection_data))
1174                         context->drag_finish(true, false, time);
1175         }
1176         context->drag_finish(false, false, time);
1177 }
1178 */