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