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

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file layertreestore.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2008 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "layertreestore.h"
  34 #include "iconcontroller.h"
  35 #include <gtkmm/button.h>
  36 #include <synfig/paramdesc.h>
  37 #include <synfigapp/action.h>
  38 #include <synfigapp/instance.h>
  39 #include "app.h"
  40 #include "instance.h"
  41 #include <synfig/layer_pastecanvas.h>
  42 #include <synfigapp/action_system.h>
  43
  44 #include <gtk/gtkversion.h>
  45 #include <ETL/clock>
  46 #include "general.h"
  47
  48 #endif
  49
  50 /* === U S I N G =========================================================== */
  51
  52 using namespace std;
  53 using namespace etl;
  54 using namespace synfig;
  55 using namespace studio;
  56
  57 /* === M A C R O S ========================================================= */
  58
  59 /* === G L O B A L S ======================================================= */
  60
  61 /* === P R O C E D U R E S ================================================= */
  62
  63 /* === M E T H O D S ======================================================= */
  64
  65 static LayerTreeStore::Model& ModelHack()
  66 {
  67         static LayerTreeStore::Model* model(0);
  68         if(!model)model=new LayerTreeStore::Model;
  69         return *model;
  70 }
  71
  72 LayerTreeStore::LayerTreeStore(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_):
  73         Gtk::TreeStore                  (ModelHack()),
  74         queued                                  (false),
  75         canvas_interface_               (canvas_interface_)
  76 {
  77         layer_icon=Gtk::Button().render_icon(Gtk::StockID("synfig-layer"),Gtk::ICON_SIZE_SMALL_TOOLBAR);
  78
  79         // Connect Signals to Terminals
  80         canvas_interface()->signal_layer_status_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_status_changed));
  81         canvas_interface()->signal_layer_lowered().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_lowered));
  82         canvas_interface()->signal_layer_raised().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_raised));
  83         canvas_interface()->signal_layer_removed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_removed));
  84         canvas_interface()->signal_layer_inserted().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_inserted));
  85         canvas_interface()->signal_layer_moved().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_moved));
  86         //canvas_interface()->signal_layer_param_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_param_changed));
  87         canvas_interface()->signal_layer_new_description().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_new_description));
  88
  89         canvas_interface()->signal_time_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::refresh));
  90
  91         //canvas_interface()->signal_value_node_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_changed));
  92         //canvas_interface()->signal_value_node_added().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_added));
  93         //canvas_interface()->signal_value_node_deleted().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_deleted));
  94         //canvas_interface()->signal_value_node_replaced().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_replaced));
  95
  96         set_default_sort_func(sigc::ptr_fun(index_sorter));
  97
  98 //      rebuild();
  99 }
 100
 101 LayerTreeStore::~LayerTreeStore()
 102 {
 103         if (getenv("SYNFIG_DEBUG_DESTRUCTORS"))
 104                 synfig::info("LayerTreeStore::~LayerTreeStore(): Deleted");
 105 }
 106
 107 int
 108 LayerTreeStore::z_sorter(const Gtk::TreeModel::iterator &rhs,const Gtk::TreeModel::iterator &lhs)
 109 {
 110         const Model model;
 111
 112         float diff((float)(*rhs)[model.z_depth]-(float)(*lhs)[model.z_depth]);
 113
 114         if(diff<0)
 115                 return -1;
 116         if(diff>0)
 117                 return 1;
 118         return 0;
 119 }
 120
 121 int
 122 LayerTreeStore::index_sorter(const Gtk::TreeModel::iterator &rhs,const Gtk::TreeModel::iterator &lhs)
 123 {
 124         const Model model;
 125
 126         return ((int)(*rhs)[model.index]-(int)(*lhs)[model.index]);
 127 }
 128
 129 bool
 130 LayerTreeStore::search_func(const Glib::RefPtr<TreeModel>&,int,const Glib::ustring& x,const TreeModel::iterator& iter)
 131 {
 132         const Model model;
 133
 134         Glib::ustring substr(x.uppercase());
 135         Glib::ustring label((*iter)[model.label]);
 136         label=label.uppercase();
 137
 138         return label.find(substr)==Glib::ustring::npos;
 139 }
 140
 141
 142 Glib::RefPtr<LayerTreeStore>
 143 LayerTreeStore::create(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_)
 144 {
 145         return Glib::RefPtr<LayerTreeStore>(new LayerTreeStore(canvas_interface_));
 146 }
 147
 148 void
 149 LayerTreeStore::get_value_vfunc (const Gtk::TreeModel::iterator& iter, int column, Glib::ValueBase& value)const
 150 {
 151         if(column==model.index.index())
 152         {
 153                 synfig::Layer::Handle layer((*iter)[model.layer]);
 154
 155                 if(!layer)return;
 156
 157                 Glib::Value<int> x;
 158                 g_value_init(x.gobj(),x.value_type());
 159
 160                 x.set(layer->get_depth());
 161
 162                 g_value_init(value.gobj(),x.value_type());
 163                 g_value_copy(x.gobj(),value.gobj());
 164         }
 165         else if(column==model.z_depth.index())
 166         {
 167                 synfig::Layer::Handle layer((*iter)[model.layer]);
 168
 169                 if(!layer)return;
 170
 171                 Glib::Value<float> x;
 172                 g_value_init(x.gobj(),x.value_type());
 173
 174                 x.set(layer->get_z_depth(canvas_interface()->get_time())*1.0001+layer->get_depth());
 175
 176                 g_value_init(value.gobj(),x.value_type());
 177                 g_value_copy(x.gobj(),value.gobj());
 178         }
 179         else if(column==model.children_lock.index())
 180         {
 181                 synfig::Layer::Handle layer((*iter)[model.layer]);
 182
 183                 if(!layer)return;
 184
 185                 Glib::Value<bool> x;
 186                 g_value_init(x.gobj(),x.value_type());
 187                 x.set(false);
 188
 189                 ValueBase v(layer->get_param("children_lock"));
 190                 if(v.same_type_as(bool()))
 191                         x.set(v.get(bool()));
 192
 193                 g_value_init(value.gobj(),x.value_type());
 194                 g_value_copy(x.gobj(),value.gobj());
 195         }
 196         else if(column==model.label.index())
 197         {
 198                 synfig::Layer::Handle layer((*iter)[model.layer]);
 199
 200                 if(!layer)return;
 201
 202                 Glib::Value<Glib::ustring> x;
 203                 g_value_init(x.gobj(),x.value_type());
 204
 205                 x.set(layer->get_non_empty_description());
 206
 207                 g_value_init(value.gobj(),x.value_type());
 208                 //g_value_copy(x.gobj(),value.gobj());
 209                 value=x;
 210         }
 211         else if(column==model.tooltip.index())
 212         {
 213                 synfig::Layer::Handle layer((*iter)[model.layer]);
 214
 215                 if(!layer)return;
 216
 217                 Glib::Value<Glib::ustring> x;
 218                 g_value_init(x.gobj(),x.value_type());
 219
 220
 221                 x.set(layer->get_local_name());
 222
 223                 g_value_init(value.gobj(),x.value_type());
 224                 //g_value_copy(x.gobj(),value.gobj());
 225                 value=x;
 226         }
 227         else if(column==model.canvas.index())
 228         {
 229                 synfig::Layer::Handle layer((*iter)[model.layer]);
 230
 231                 if(!layer)return;
 232
 233                 Glib::Value<Canvas::Handle> x;
 234                 g_value_init(x.gobj(),x.value_type());
 235
 236
 237                 x.set(layer->get_canvas());
 238
 239                 g_value_init(value.gobj(),x.value_type());
 240                 //g_value_copy(x.gobj(),value.gobj());
 241                 value=x;
 242         }
 243         else if(column==model.active.index())
 244         {
 245                 synfig::Layer::Handle layer((*iter)[model.layer]);
 246
 247                 if(!layer)return;
 248
 249                 Glib::Value<bool> x;
 250                 g_value_init(x.gobj(),x.value_type());
 251
 252                 x.set(layer->active());
 253
 254                 g_value_init(value.gobj(),x.value_type());
 255                 g_value_copy(x.gobj(),value.gobj());
 256         }
 257         else if(column==model.icon.index())
 258         {
 259                 synfig::Layer::Handle layer((*iter)[model.layer]);
 260                 if(!layer)return;
 261
 262                 Glib::Value<Glib::RefPtr<Gdk::Pixbuf> > x;
 263                 g_value_init(x.gobj(),x.value_type());
 264
 265                 //x.set(layer_icon);
 266                 x.set(get_tree_pixbuf_layer(layer->get_name()));
 267
 268                 g_value_init(value.gobj(),x.value_type());
 269                 g_value_copy(x.gobj(),value.gobj());
 270         }
 271         else
 272                 Gtk::TreeStore::get_value_vfunc(iter,column,value);
 273 }
 274
 275 void
 276 LayerTreeStore::set_value_impl(const Gtk::TreeModel::iterator& iter, int column, const Glib::ValueBase& value)
 277 {
 278         //if(!iterator_sane(row))
 279         //      return;
 280
 281         if(column>=get_n_columns_vfunc())
 282         {
 283                 g_warning("LayerTreeStore::set_value_impl: Bad column (%d)",column);
 284                 return;
 285         }
 286
 287         if(!g_value_type_compatible(G_VALUE_TYPE(value.gobj()),get_column_type_vfunc(column)))
 288         {
 289                 g_warning("LayerTreeStore::set_value_impl: Bad value type");
 290                 return;
 291         }
 292
 293         try
 294         {
 295                 if(column==model.label.index())
 296                 {
 297                         Glib::Value<Glib::ustring> x;
 298                         g_value_init(x.gobj(),model.label.type());
 299                         g_value_copy(value.gobj(),x.gobj());
 300
 301                         synfig::Layer::Handle layer((*iter)[model.layer]);
 302                         if(!layer)
 303                                 return;
 304                         synfig::String new_desc(x.get());
 305
 306                         if(new_desc==layer->get_local_name())
 307                                 new_desc=synfig::String();
 308
 309                         if(new_desc==layer->get_description())
 310                                 return;
 311
 312                         synfigapp::Action::Handle action(synfigapp::Action::create("layer_set_desc"));
 313
 314                         if(!action)
 315                                 return;
 316
 317                         action->set_param("canvas",canvas_interface()->get_canvas());
 318                         action->set_param("canvas_interface",canvas_interface());
 319                         action->set_param("layer",layer);
 320                         action->set_param("new_description",synfig::String(x.get()));
 321
 322                         canvas_interface()->get_instance()->perform_action(action);
 323                         return;
 324                 }
 325                 else if(column==model.active.index())
 326                 {
 327                         synfig::Layer::Handle layer((*iter)[model.layer]);
 328
 329                         if(!layer)return;
 330
 331                         Glib::Value<bool> x;
 332                         g_value_init(x.gobj(),model.active.type());
 333                         g_value_copy(value.gobj(),x.gobj());
 334
 335                         synfigapp::Action::Handle action(synfigapp::Action::create("layer_activate"));
 336
 337                         if(!action)
 338                                 return;
 339
 340                         action->set_param("canvas",canvas_interface()->get_canvas());
 341                         action->set_param("canvas_interface",canvas_interface());
 342                         action->set_param("layer",layer);
 343                         action->set_param("new_status",bool(x.get()));
 344
 345                         canvas_interface()->get_instance()->perform_action(action);
 346                         return;
 347                 }
 348                 else
 349                         Gtk::TreeStore::set_value_impl(iter,column, value);
 350
 351         }
 352         catch(std::exception x)
 353         {
 354                 g_warning("%s", x.what());
 355         }
 356 }
 357
 358
 359
 360
 361 bool
 362 LayerTreeStore::row_draggable_vfunc (const TreeModel::Path& /*path*/)const
 363 {
 364         //if(!get_iter(path)) return false;
 365 //      Gtk::TreeModel::Row row(*get_iter(path));
 366
 367         return true;
 368 //      return (bool)true;
 369 }
 370
 371 bool
 372 LayerTreeStore::drag_data_get_vfunc (const TreeModel::Path& path, Gtk::SelectionData& selection_data)const
 373 {
 374         if(!const_cast<LayerTreeStore*>(this)->get_iter(path)) return false;
 375         //synfig::info("Dragged data of type \"%s\"",selection_data.get_data_type());
 376         //synfig::info("Dragged data of target \"%s\"",gdk_atom_name(selection_data->target));
 377         //synfig::info("Dragged selection=\"%s\"",gdk_atom_name(selection_data->selection));
 378
 379         Gtk::TreeModel::Row row(*const_cast<LayerTreeStore*>(this)->get_iter(path));
 380
 381         if((bool)true)
 382         {
 383                 Layer* layer(((Layer::Handle)row[model.layer]).get());
 384                 assert(layer);
 385                 bool included(false);
 386
 387                 //gtk_selection_data_set (selection_data, gdk_atom_intern("LAYER",false), 8, reinterpret_cast<const guchar*>(&layer), sizeof(layer));
 388
 389                 std::vector<Layer*> layers;
 390                 // The following is a hack for multiple row DND
 391                 {
 392                         synfigapp::SelectionManager::LayerList bleh(get_canvas_interface()->get_selection_manager()->get_selected_layers());
 393                         if(bleh.empty())
 394                         {
 395                                 selection_data.set("LAYER", 8, reinterpret_cast<const guchar*>(&layer), sizeof(layer));
 396                                 return true;
 397                         }
 398                         while(!bleh.empty())
 399                         {
 400                                 if(bleh.back().get()==layer)
 401                                         included=true;
 402                                 layers.push_back(bleh.back().get());
 403                                 bleh.pop_back();
 404                         }
 405                 }
 406                 if(!included)
 407                         layers.push_back(layer);
 408                 selection_data.set("LAYER", 8, reinterpret_cast<const guchar*>(&layers.front()), sizeof(void*)*layers.size());
 409
 410                 return true;
 411         }
 412         return false;
 413 }
 414
 415 bool
 416 LayerTreeStore::drag_data_delete_vfunc (const TreeModel::Path& /*path*/)
 417 {
 418         return true;
 419 }
 420
 421 bool
 422 LayerTreeStore::row_drop_possible_vfunc (const TreeModel::Path& dest, const Gtk::SelectionData& selection_data)const
 423 {
 424         //if(!const_cast<LayerTreeStore*>(this)->get_iter(dest)) return false;
 425
 426         //synfig::info("possible_drop -- data of type \"%s\"",selection_data.get_data_type());
 427         //synfig::info("possible_drop -- data of target \"%s\"",gdk_atom_name(selection_data->target));
 428         //synfig::info("possible_drop -- selection=\"%s\"",gdk_atom_name(selection_data->selection));
 429
 430         //Gtk::TreeModel::Row row(*get_iter(dest));
 431
 432         if(synfig::String(selection_data.get_data_type())=="LAYER" && (bool)true)
 433         {
 434                 //Layer::Handle src(reinterpret_cast<Layer**>(const_cast<guint8*>(selection_data.get_data()))[i]);
 435                 //assert(src);
 436
 437                 //return true;
 438                 TreeModel::Path dest_parent(dest);
 439                 if(!dest_parent.up() || dest.get_depth()==1)
 440                 {
 441                         //row=(*get_iter(dest));
 442                         //dest_canvas=(Canvas::Handle)(row[model.canvas]);
 443                         return true;
 444                 }
 445                 else if((bool)const_cast<LayerTreeStore*>(this)->get_iter(dest_parent))
 446                         return (bool)(Canvas::Handle)(*const_cast<LayerTreeStore*>(this)->get_iter(dest_parent))[model.contained_canvas];
 447         }
 448         return false;
 449 }
 450
 451 bool
 452 LayerTreeStore::drag_data_received_vfunc (const TreeModel::Path& dest, const Gtk::SelectionData& selection_data)
 453 {
 454
 455         //if(!dest_parent.up() || !get_iter(dest)) return false;
 456
 457         bool ret=false;
 458         int i(0);
 459
 460
 461         //synfig::info("Dropped data of type \"%s\"",selection_data.get_data_type());
 462         //synfig::info("Dropped data of target \"%s\"",gdk_atom_name(selection_data->target));
 463         //synfig::info("Dropped selection=\"%s\"",gdk_atom_name(selection_data->selection));
 464         synfigapp::Action::PassiveGrouper passive_grouper(canvas_interface()->get_instance().get(),_("Move Layers"));
 465
 466         // Save the selection data
 467         synfigapp::SelectionManager::LayerList selected_layer_list=canvas_interface()->get_selection_manager()->get_selected_layers();
 468
 469         if ((selection_data.get_length() >= 0) && (selection_data.get_format() == 8))
 470         {
 471                 Gtk::TreeModel::Row row;
 472                 Canvas::Handle dest_canvas;
 473
 474                 int dest_layer_depth=dest.back();
 475
 476                 TreeModel::Path dest_parent(dest);
 477                 if(!dest_parent.up() || !get_iter(dest_parent))
 478                 {
 479                         TreeModel::Path dest_(dest);
 480                         if(!get_iter(dest_))
 481                                 dest_.prev();
 482
 483                         if(!get_iter(dest_))
 484                                 return false;
 485
 486                         {
 487                                 row=(*get_iter(dest_));
 488                                 dest_canvas=(Canvas::Handle)(row[model.canvas]);
 489                         }
 490                 }
 491                 else
 492                 {
 493                         row=(*get_iter(dest_parent));
 494                         dest_canvas=row[model.contained_canvas];
 495                 }
 496
 497                 assert(dest_canvas);
 498
 499                 Layer::Handle dest_layer(row[model.layer]);
 500
 501                 if(synfig::String(selection_data.get_data_type())=="LAYER")for(unsigned int i=0;i<selection_data.get_length()/sizeof(void*);i++)
 502                 {
 503                         //synfig::info("dest_layer_depth=%d",dest_layer_depth);
 504
 505                         Layer::Handle src(reinterpret_cast<Layer**>(const_cast<guint8*>(selection_data.get_data()))[i]);
 506                         assert(src);
 507                         if(dest_layer==src)
 508                                 continue;
 509
 510                         if(dest_canvas==src->get_canvas() && src->get_depth()<dest_layer_depth)
 511                                 dest_layer_depth--;
 512
 513                         // In this case, we are just moving.
 514 //                      if(dest_canvas==src->get_canvas())
 515                         {
 516                                 //if(dest_canvas==src->get_canvas() && dest_layer_depth && dest_layer_depth>src->get_depth())
 517                                 //      dest_layer_depth--;
 518                                 if(dest_canvas==src->get_canvas() && dest_layer_depth==src->get_depth())
 519                                         continue;
 520
 521                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_move"));
 522                                 action->set_param("canvas",dest_canvas);
 523                                 action->set_param("canvas_interface",canvas_interface());
 524                                 action->set_param("layer",src);
 525                                 action->set_param("new_index",dest_layer_depth);
 526                                 action->set_param("dest_canvas",dest_canvas);
 527                                 if(canvas_interface()->get_instance()->perform_action(action))
 528                                         ret=true;
 529                                 else
 530                                 {
 531                                         passive_grouper.cancel();
 532                                         return false;
 533                                 }
 534                                 continue;
 535                         }
 536                         /*else // In this case we need to remove and then add
 537                         {
 538
 539                                 synfigapp::Action::Handle action;
 540                                 action=synfigapp::Action::create("layer_remove");
 541                                 action->set_param("canvas",Canvas::Handle(src->get_canvas()));
 542                                 if(!action->set_param("canvas_interface",App::get_instance(src->get_canvas())->find_canvas_interface(src->get_canvas())))
 543                                         action->set_param("canvas_interface",canvas_interface());
 544                                 action->set_param("layer",src);
 545                                 if(!canvas_interface()->get_instance()->perform_action(action))
 546                                 {
 547                                         passive_grouper.cancel();
 548                                         ret=false;
 549                                         return false;
 550                                 }
 551
 552                                 action=synfigapp::Action::create("layer_add");
 553                                 action->set_param("canvas",dest_canvas);
 554                                 action->set_param("canvas_interface",canvas_interface());
 555                                 action->set_param("new",src);
 556                                 if(!canvas_interface()->get_instance()->perform_action(action))
 557                                 {
 558                                         passive_grouper.cancel();
 559                                         ret=false;
 560                                         return false;
 561                                 }
 562
 563                                 if(dest_layer_depth!=0)
 564                                 {
 565                                         action=synfigapp::Action::create("layer_move");
 566                                         action->set_param("canvas",dest_canvas);
 567                                         action->set_param("canvas_interface",canvas_interface());
 568                                         action->set_param("layer",src);
 569                                         action->set_param("new_index",dest_layer_depth);
 570                                         if(!canvas_interface()->get_instance()->perform_action(action))
 571                                         {
 572                                                 passive_grouper.cancel();
 573                                                 ret=false;
 574                                                 return false;
 575                                         }
 576                                 }
 577                                 ret=true;
 578                         }
 579                         */
 580                 }
 581         }
 582         synfig::info("I supposedly moved %d layers",i);
 583
 584         // Reselect the previously selected layers
 585         canvas_interface()->get_selection_manager()->set_selected_layers(selected_layer_list);
 586
 587         return ret;
 588 }
 589
 590 void
 591 LayerTreeStore::queue_rebuild()
 592 {
 593         if (queued) return;
 594         queued = false;
 595         queue_connection.disconnect();
 596         queue_connection=Glib::signal_timeout().connect(
 597                 sigc::bind_return(
 598                         sigc::mem_fun(*this,&LayerTreeStore::rebuild),
 599                         false
 600                 )
 601         ,150);
 602 }
 603
 604 void
 605 LayerTreeStore::rebuild()
 606 {
 607         if (queued) queued = false;
 608
 609         // disconnect any subcanvas_changed connections
 610         std::map<synfig::Layer::Handle, sigc::connection>::iterator iter;
 611         for (iter = subcanvas_changed_connections.begin(); iter != subcanvas_changed_connections.end(); iter++)
 612                 iter->second.disconnect();
 613         subcanvas_changed_connections.clear();
 614
 615         //etl::clock timer;timer.reset();
 616
 617         //synfig::warning("---------rebuilding layer table---------");
 618         // Save the selection data
 619         synfigapp::SelectionManager::LayerList layer_list=canvas_interface()->get_selection_manager()->get_selected_layers();
 620
 621         // Clear out the current list
 622         clear();
 623
 624         // Go ahead and and add all the layers
 625         std::for_each(
 626                 canvas_interface()->get_canvas()->rbegin(), canvas_interface()->get_canvas()->rend(),
 627                 sigc::mem_fun(*this, &studio::LayerTreeStore::on_layer_added)
 628         );
 629
 630         // Reselect the previously selected layers
 631         if(!layer_list.empty())
 632                 canvas_interface()->get_selection_manager()->set_selected_layers(layer_list);
 633
 634         //synfig::info("LayerTreeStore::rebuild() took %f seconds",float(timer()));
 635 }
 636
 637 void
 638 LayerTreeStore::refresh()
 639 {
 640         etl::clock timer;timer.reset();
 641
 642         Gtk::TreeModel::Children children_(children());
 643
 644         Gtk::TreeModel::Children::iterator iter;
 645
 646         if(!children_.empty())
 647                 for(iter = children_.begin(); iter && iter != children_.end(); ++iter)
 648                 {
 649                         Gtk::TreeRow row=*iter;
 650                         refresh_row(row);
 651                 }
 652         //synfig::info("LayerTreeStore::refresh() took %f seconds",float(timer()));
 653 }
 654
 655 void
 656 LayerTreeStore::refresh_row(Gtk::TreeModel::Row &row)
 657 {
 658         Layer::Handle layer=row[model.layer];
 659         /*
 660         {
 661                 row[model.name] = layer->get_local_name();
 662                 if(layer->get_description().empty())
 663                 {
 664                         row[model.label] = layer->get_local_name();
 665                         row[model.tooltip] = Glib::ustring("Layer");
 666                 }
 667                 else
 668                 {
 669                         row[model.label] = layer->get_description();
 670                         row[model.tooltip] = layer->get_local_name();
 671                 }
 672         }
 673         */
 674
 675         if(layer->dynamic_param_list().count("z_depth"))
 676                 row[model.z_depth]=Time::begin();
 677         //      row_changed(get_path(row),row);
 678
 679         Gtk::TreeModel::Children children = row.children();
 680         Gtk::TreeModel::Children::iterator iter;
 681
 682         if(!children.empty())
 683                 for(iter = children.begin(); iter && iter != children.end(); ++iter)
 684                 {
 685                         Gtk::TreeRow row=*iter;
 686                         refresh_row(row);
 687                 }
 688 }
 689
 690
 691 void
 692 LayerTreeStore::set_row_layer(Gtk::TreeRow &row,synfig::Layer::Handle &handle)
 693 {
 694         //row[model.id] = handle->get_name();
 695         //row[model.name] = handle->get_local_name();
 696         /*if(handle->get_description().empty())
 697         {
 698                 //row[model.label] = handle->get_local_name();
 699                 row[model.tooltip] = Glib::ustring("Layer");
 700         }
 701         else
 702         {
 703                 //row[model.label] = handle->get_description();
 704                 row[model.tooltip] = handle->get_local_name();
 705         }*/
 706
 707         //row[model.active] = handle->active();
 708         row[model.layer] = handle;
 709         //row[model.canvas] = handle->get_canvas();
 710         //row[model.icon] = layer_icon;
 711
 712         synfig::Layer::ParamList paramlist=handle->get_param_list();
 713
 714         synfig::Layer::Vocab vocab=handle->get_param_vocab();
 715         synfig::Layer::Vocab::iterator iter;
 716
 717         for(iter=vocab.begin();iter!=vocab.end();++iter)
 718         {
 719                 if(iter->get_hidden())
 720                         continue;
 721                 if(handle->get_param(iter->get_name()).get_type()!=ValueBase::TYPE_CANVAS)
 722                         continue;
 723
 724                 {
 725                         Canvas::Handle canvas;
 726                         canvas=handle->get_param(iter->get_name()).get(canvas);
 727                         if(!canvas)
 728                                 continue;
 729
 730                         Canvas::reverse_iterator iter;
 731                         row[model.contained_canvas]=canvas;
 732
 733                         for(iter=canvas->rbegin();iter!=canvas->rend();++iter)
 734                         {
 735                                 Gtk::TreeRow row_(*(prepend(row.children())));
 736                                 set_row_layer(row_,*iter);
 737                         }
 738                         continue;
 739                 }
 740
 741                 /*
 742                 etl::handle<ValueNode> value_node;
 743                 if(handle.constant()->dynamic_param_list().count(iter->get_name()))
 744                         value_node=handle->dynamic_param_list()[iter->get_name()];
 745
 746                 Gtk::TreeRow child_row = *(append(row.children()));
 747                 set_row_param(
 748                         child_row,
 749                         handle,
 750                         iter->get_name(),
 751                         iter->get_local_name(),
 752                         paramlist[iter->get_name()],
 753                         value_node,
 754                         &*iter
 755                 );
 756                 */
 757         }
 758 }
 759
 760 void
 761 LayerTreeStore::on_layer_added(synfig::Layer::Handle layer)
 762 {
 763         if (etl::handle<Layer_PasteCanvas>::cast_dynamic(layer))
 764                 subcanvas_changed_connections[layer] =
 765                         (etl::handle<Layer_PasteCanvas>::cast_dynamic(layer))->signal_subcanvas_changed().connect(
 766                                 sigc::mem_fun(*this,&studio::LayerTreeStore::queue_rebuild)
 767                         );
 768
 769         assert(layer);
 770         Gtk::TreeRow row;
 771         if(canvas_interface()->get_canvas()==layer->get_canvas())
 772         {
 773                 row=*(prepend());
 774         }
 775         else
 776         {
 777                 Gtk::TreeModel::Children::iterator iter;
 778                 if(!find_canvas_row(layer->get_canvas(),iter))
 779                 {
 780                         rebuild();
 781                         return;
 782                 }
 783                 row=*(prepend(iter->children()));
 784         }
 785         set_row_layer(row,layer);
 786 }
 787
 788 void
 789 LayerTreeStore::on_layer_removed(synfig::Layer::Handle handle)
 790 {
 791         if (etl::handle<Layer_PasteCanvas>::cast_dynamic(handle))
 792         {
 793                 subcanvas_changed_connections[handle].disconnect();
 794                 subcanvas_changed_connections.erase(handle);
 795         }
 796         Gtk::TreeModel::Children::iterator iter;
 797         if(find_layer_row(handle,iter))
 798                 erase(iter);
 799         else
 800         {
 801                 synfig::error("LayerTreeStore::on_layer_removed():Unable to find layer to be removed, forced to rebuild...");
 802                 rebuild();
 803         }
 804 }
 805
 806 void
 807 LayerTreeStore::on_layer_inserted(synfig::Layer::Handle handle,int depth)
 808 {
 809         if(depth==0)
 810         {
 811                 on_layer_added(handle);
 812                 return;
 813         }
 814
 815         Gtk::TreeModel::Children children_(children());
 816         if(canvas_interface()->get_canvas()!=handle->get_canvas())
 817         {
 818                 Gtk::TreeModel::Children::iterator iter;
 819                 if(!find_canvas_row(handle->get_canvas(),iter))
 820                 {
 821                         synfig::error("LayerTreeStore::on_layer_inserted():Unable to find canvas row, forced to rebuild...");
 822                         rebuild();
 823                         return;
 824                 }
 825                 children_=iter->children();
 826         }
 827
 828         Gtk::TreeModel::Children::iterator iter(children_.begin());
 829         while(depth-- && iter)
 830         {
 831                 ++iter;
 832                 if(!iter || iter==children_.end())
 833                 {
 834                         synfig::error("LayerTreeStore::on_layer_inserted():Unable to achieve desired depth, forced to rebuild...");
 835                         rebuild();
 836                         return;
 837                 }
 838         }
 839
 840         Gtk::TreeModel::Row row(*insert(iter));
 841         set_row_layer(row,handle);
 842 }
 843
 844 void
 845 LayerTreeStore::on_layer_status_changed(synfig::Layer::Handle handle,bool /*x*/)
 846 {
 847         Gtk::TreeModel::Children::iterator iter;
 848         if(find_layer_row(handle,iter))
 849                 (*iter)[model.layer]=handle;
 850         else
 851         {
 852                 synfig::warning("Couldn't find layer to be activated in layer list. Rebuilding index...");
 853                 rebuild();
 854         }
 855 }
 856
 857 void
 858 LayerTreeStore::on_layer_lowered(synfig::Layer::Handle layer)
 859 {
 860         Gtk::TreeModel::Children::iterator iter, iter2;
 861         if(find_layer_row(layer,iter))
 862         {
 863                 // Save the selection data
 864                 //synfigapp::SelectionManager::LayerList layer_list=canvas_interface()->get_selection_manager()->get_selected_layers();
 865                 iter2=iter;
 866                 iter2++;
 867                 if(!iter2)
 868                 {
 869                         rebuild();
 870                         return;
 871                 }
 872
 873                 //Gtk::TreeModel::Row row(*iter);
 874                 Gtk::TreeModel::Row row2 = *iter2;
 875                 synfig::Layer::Handle layer2=row2[model.layer];
 876
 877                 erase(iter2);
 878                 row2=*insert(iter);
 879                 set_row_layer(row2,layer2);
 880
 881         }
 882         else
 883                 rebuild();
 884 }
 885
 886 void
 887 LayerTreeStore::on_layer_raised(synfig::Layer::Handle layer)
 888 {
 889         Gtk::TreeModel::Children::iterator iter, iter2;
 890
 891         Gtk::TreeModel::Children children_(children());
 892
 893         if(find_layer_row_(layer, canvas_interface()->get_canvas(), children_, iter,iter2))
 894         {
 895                 if(iter!=iter2)
 896                 {
 897                         //Gtk::TreeModel::Row row = *iter;
 898                         Gtk::TreeModel::Row row2 = *iter2;
 899                         synfig::Layer::Handle layer2=row2[model.layer];
 900
 901                         erase(iter2);
 902                         iter++;
 903                         row2=*insert(iter);
 904                         set_row_layer(row2,layer2);
 905
 906                         return;
 907                 }
 908         }
 909
 910         rebuild();
 911 }
 912
 913 void
 914 LayerTreeStore::on_layer_moved(synfig::Layer::Handle layer,int depth, synfig::Canvas::Handle /*canvas*/)
 915 {
 916         on_layer_removed(layer);
 917         on_layer_inserted(layer,depth);
 918 }
 919
 920 void
 921 LayerTreeStore::on_layer_param_changed(synfig::Layer::Handle handle,synfig::String param_name)
 922 {
 923         if(param_name=="z_depth")
 924         {
 925                 Gtk::TreeModel::Children::iterator iter;
 926                 if(find_layer_row(handle,iter))
 927                 {
 928                         (*iter)[model.z_depth]=Time::begin();
 929                 }
 930         }
 931
 932         /*
 933         Gtk::TreeModel::Children::iterator iter;
 934         if(find_layer_row(handle,iter))
 935         {
 936                 Gtk::TreeModel::Children children(iter->children());
 937
 938                 for(iter = children.begin(); iter && iter != children.end(); ++iter)
 939                 {
 940                         if((Glib::ustring)(*iter)[model.param_name]==param_name)
 941                         {
 942                                 Gtk::TreeRow row=*iter;
 943                                 refresh_row(row);
 944                                 return;
 945                         }
 946                 }
 947         }
 948         rebuild();
 949         */
 950 }
 951
 952 void
 953 LayerTreeStore::on_layer_new_description(synfig::Layer::Handle handle,synfig::String desc)
 954 {
 955         Gtk::TreeModel::Children::iterator iter;
 956         if(find_layer_row(handle,iter))
 957         {
 958                 Gtk::TreeRow row(*iter);
 959
 960                 Layer::Handle layer(row[model.layer]);
 961
 962                 if(desc.empty())
 963                 {
 964                         //row[model.label]=layer->get_local_name();
 965                         row[model.tooltip]=Glib::ustring(_("Layer"));
 966                 }
 967                 else
 968                         //row[model.label]=layer->get_description();
 969                         row[model.tooltip]=layer->get_local_name();
 970         }
 971         else
 972         {
 973                 rebuild();
 974         }
 975 }
 976
 977 bool
 978 LayerTreeStore::find_canvas_row_(synfig::Canvas::Handle canvas, synfig::Canvas::Handle parent, Gtk::TreeModel::Children layers, Gtk::TreeModel::Children::iterator &iter)
 979 {
 980         if(canvas==parent)
 981                 return false;
 982
 983         {
 984                 for(iter=layers.begin(); iter && iter != layers.end(); ++iter)
 985                 {
 986                         Gtk::TreeModel::Row row = *iter;
 987                         if(canvas==(synfig::Canvas::Handle)row[model.contained_canvas])
 988                                 return true;
 989                 }
 990
 991                 iter=children().end();
 992                 //return false;
 993         }
 994
 995         Gtk::TreeModel::Children::iterator iter2;
 996         //Gtk::TreeModel::Children::iterator iter3;
 997
 998         for(iter2 = layers.begin(); iter2 && iter2 != layers.end(); ++iter2)
 999         {
1000                 Gtk::TreeModel::Row row = *iter2;
1001                 assert((bool)true);
1002
1003                 if(row.children().empty())
1004                         continue;
1005
1006                 Canvas::Handle sub_canvas((*row.children().begin())[model.canvas]);
1007                 if(!sub_canvas)
1008                         continue;
1009
1010                 if(find_canvas_row_(canvas,sub_canvas,iter2->children(),iter))
1011                         return true;
1012         }
1013
1014         iter=children().end();
1015         return false;
1016 }
1017
1018 bool
1019 LayerTreeStore::find_canvas_row(synfig::Canvas::Handle canvas, Gtk::TreeModel::Children::iterator &iter)
1020 {
1021         return find_canvas_row_(canvas,canvas_interface()->get_canvas(),children(),iter);
1022 }
1023
1024
1025 bool
1026 LayerTreeStore::find_layer_row_(const synfig::Layer::Handle &layer, synfig::Canvas::Handle /*canvas*/, Gtk::TreeModel::Children layers, Gtk::TreeModel::Children::iterator &iter, Gtk::TreeModel::Children::iterator &prev)
1027 {
1028         assert(layer);
1029
1030         //if(layer->get_canvas()==canvas)
1031         {
1032                 for(iter=prev=layers.begin(); iter && iter != layers.end(); prev=iter++)
1033                 {
1034                         Gtk::TreeModel::Row row = *iter;
1035                         if(layer==(synfig::Layer::Handle)row[model.layer])
1036                                 return true;
1037                 }
1038
1039                 iter=children().end();
1040                 //return false;
1041         }
1042
1043         Gtk::TreeModel::Children::iterator iter2;
1044
1045         for(iter2 = layers.begin(); iter2 && iter2 != layers.end(); ++iter2)
1046         {
1047                 Gtk::TreeModel::Row row = *iter2;
1048                 assert((bool)true);
1049
1050                 if(row.children().empty())
1051                         continue;
1052
1053                 Canvas::Handle canvas((*row.children().begin())[model.canvas]);
1054                 if(!canvas)
1055                         continue;
1056
1057                 if(find_layer_row_(layer,canvas,iter2->children(),iter,prev))
1058                         return true;
1059         }
1060
1061         iter=children().end();
1062         return false;
1063 }
1064
1065 bool
1066 LayerTreeStore::find_layer_row(const synfig::Layer::Handle &layer, Gtk::TreeModel::Children::iterator &iter)
1067 {
1068         Gtk::TreeModel::Children::iterator prev;
1069         return find_layer_row_(layer,canvas_interface()->get_canvas(),children(),iter,prev);
1070 }
1071
1072 bool
1073 LayerTreeStore::find_prev_layer_row(const synfig::Layer::Handle &layer, Gtk::TreeModel::Children::iterator &prev)
1074 {
1075         Gtk::TreeModel::Children::iterator iter;
1076         if(!find_layer_row_(layer,canvas_interface()->get_canvas(),children(),iter,prev))
1077                 return false;
1078         if(iter==children().begin())
1079                 return false;
1080         return true;
1081 }