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