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 "iconcontroller.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 <synfigapp/action_system.h>
  41
  42 #include <gtk/gtkversion.h>
  43 #include <ETL/clock>
  44 #include "general.h"
  45
  46 #endif
  47
  48 /* === U S I N G =========================================================== */
  49
  50 using namespace std;
  51 using namespace etl;
  52 using namespace synfig;
  53 using namespace studio;
  54
  55 /* === M A C R O S ========================================================= */
  56
  57 /* === G L O B A L S ======================================================= */
  58
  59 /* === P R O C E D U R E S ================================================= */
  60
  61 /* === M E T H O D S ======================================================= */
  62
  63 static LayerTreeStore::Model& ModelHack()
  64 {
  65         static LayerTreeStore::Model* model(0);
  66         if(!model)model=new LayerTreeStore::Model;
  67         return *model;
  68 }
  69
  70 LayerTreeStore::LayerTreeStore(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_):
  71         Gtk::TreeStore                  (ModelHack()),
  72         canvas_interface_               (canvas_interface_)
  73 {
  74         layer_icon=Gtk::Button().render_icon(Gtk::StockID("synfig-layer"),Gtk::ICON_SIZE_SMALL_TOOLBAR);
  75
  76         // Connect Signals to Terminals
  77         canvas_interface()->signal_layer_status_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_status_changed));
  78         canvas_interface()->signal_layer_lowered().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_lowered));
  79         canvas_interface()->signal_layer_raised().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_raised));
  80         canvas_interface()->signal_layer_removed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_removed));
  81         canvas_interface()->signal_layer_inserted().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_inserted));
  82         canvas_interface()->signal_layer_moved().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_moved));
  83         //canvas_interface()->signal_layer_param_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_param_changed));
  84         canvas_interface()->signal_layer_new_description().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_layer_new_description));
  85
  86         canvas_interface()->signal_time_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::refresh));
  87
  88         //canvas_interface()->signal_value_node_changed().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_changed));
  89         //canvas_interface()->signal_value_node_added().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_added));
  90         //canvas_interface()->signal_value_node_deleted().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_deleted));
  91         //canvas_interface()->signal_value_node_replaced().connect(sigc::mem_fun(*this,&studio::LayerTreeStore::on_value_node_replaced));
  92
  93         set_default_sort_func(sigc::ptr_fun(index_sorter));
  94
  95 //      rebuild();
  96 }
  97
  98 LayerTreeStore::~LayerTreeStore()
  99 {
 100         synfig::info("LayerTreeStore::~LayerTreeStore(): Deleted");
 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 if(column==model.z_depth.index())
 162         {
 163                 synfig::Layer::Handle layer((*iter)[model.layer]);
 164
 165                 if(!layer)return;
 166
 167                 Glib::Value<float> x;
 168                 g_value_init(x.gobj(),x.value_type());
 169
 170                 x.set(layer->get_z_depth(canvas_interface()->get_time())*1.0001+layer->get_depth());
 171
 172                 g_value_init(value.gobj(),x.value_type());
 173                 g_value_copy(x.gobj(),value.gobj());
 174         }
 175         else if(column==model.children_lock.index())
 176         {
 177                 synfig::Layer::Handle layer((*iter)[model.layer]);
 178
 179                 if(!layer)return;
 180
 181                 Glib::Value<bool> x;
 182                 g_value_init(x.gobj(),x.value_type());
 183                 x.set(false);
 184
 185                 ValueBase v(layer->get_param("children_lock"));
 186                 if(v.same_type_as(bool()))
 187                         x.set(v.get(bool()));
 188
 189                 g_value_init(value.gobj(),x.value_type());
 190                 g_value_copy(x.gobj(),value.gobj());
 191         }
 192         else if(column==model.label.index())
 193         {
 194                 synfig::Layer::Handle layer((*iter)[model.layer]);
 195
 196                 if(!layer)return;
 197
 198                 Glib::Value<Glib::ustring> x;
 199                 g_value_init(x.gobj(),x.value_type());
 200
 201
 202                 if(!layer->get_description().empty())
 203                         x.set(layer->get_description());
 204                 else
 205                         x.set(layer->get_local_name());
 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(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::rebuild()
 592 {
 593         //etl::clock timer;timer.reset();
 594
 595         //synfig::warning("---------rebuilding layer table---------");
 596         // Save the selection data
 597         synfigapp::SelectionManager::LayerList layer_list=canvas_interface()->get_selection_manager()->get_selected_layers();
 598
 599         // Clear out the current list
 600         clear();
 601
 602         // Go ahead and and add all the layers
 603         std::for_each(
 604                 canvas_interface()->get_canvas()->rbegin(), canvas_interface()->get_canvas()->rend(),
 605                 sigc::mem_fun(*this, &studio::LayerTreeStore::on_layer_added)
 606         );
 607
 608         // Reselect the previously selected layers
 609         if(!layer_list.empty())
 610                 canvas_interface()->get_selection_manager()->set_selected_layers(layer_list);
 611
 612         //synfig::info("LayerTreeStore::rebuild() took %f seconds",float(timer()));
 613 }
 614
 615 void
 616 LayerTreeStore::refresh()
 617 {
 618         etl::clock timer;timer.reset();
 619
 620         Gtk::TreeModel::Children children_(children());
 621
 622         Gtk::TreeModel::Children::iterator iter;
 623
 624         if(!children_.empty())
 625                 for(iter = children_.begin(); iter && iter != children_.end(); ++iter)
 626                 {
 627                         Gtk::TreeRow row=*iter;
 628                         refresh_row(row);
 629                 }
 630         //synfig::info("LayerTreeStore::refresh() took %f seconds",float(timer()));
 631 }
 632
 633 void
 634 LayerTreeStore::refresh_row(Gtk::TreeModel::Row &row)
 635 {
 636         Layer::Handle layer=row[model.layer];
 637         /*
 638         {
 639                 row[model.name] = layer->get_local_name();
 640                 if(layer->get_description().empty())
 641                 {
 642                         row[model.label] = layer->get_local_name();
 643                         row[model.tooltip] = Glib::ustring("Layer");
 644                 }
 645                 else
 646                 {
 647                         row[model.label] = layer->get_description();
 648                         row[model.tooltip] = layer->get_local_name();
 649                 }
 650         }
 651         */
 652
 653         if(layer->dynamic_param_list().count("z_depth"))
 654                 row[model.z_depth]=Time::begin();
 655         //      row_changed(get_path(row),row);
 656
 657         Gtk::TreeModel::Children children = row.children();
 658         Gtk::TreeModel::Children::iterator iter;
 659
 660         if(!children.empty())
 661                 for(iter = children.begin(); iter && iter != children.end(); ++iter)
 662                 {
 663                         Gtk::TreeRow row=*iter;
 664                         refresh_row(row);
 665                 }
 666 }
 667
 668
 669 void
 670 LayerTreeStore::set_row_layer(Gtk::TreeRow &row,synfig::Layer::Handle &handle)
 671 {
 672         //row[model.id] = handle->get_name();
 673         //row[model.name] = handle->get_local_name();
 674         /*if(handle->get_description().empty())
 675         {
 676                 //row[model.label] = handle->get_local_name();
 677                 row[model.tooltip] = Glib::ustring("Layer");
 678         }
 679         else
 680         {
 681                 //row[model.label] = handle->get_description();
 682                 row[model.tooltip] = handle->get_local_name();
 683         }*/
 684
 685         //row[model.active] = handle->active();
 686         row[model.layer] = handle;
 687         //row[model.canvas] = handle->get_canvas();
 688         //row[model.icon] = layer_icon;
 689
 690         synfig::Layer::ParamList paramlist=handle->get_param_list();
 691
 692         synfig::Layer::Vocab vocab=handle->get_param_vocab();
 693         synfig::Layer::Vocab::iterator iter;
 694
 695         for(iter=vocab.begin();iter!=vocab.end();++iter)
 696         {
 697                 if(iter->get_hidden())
 698                         continue;
 699                 if(handle->get_param(iter->get_name()).get_type()!=ValueBase::TYPE_CANVAS)
 700                         continue;
 701
 702                 {
 703                         Canvas::Handle canvas;
 704                         canvas=handle->get_param(iter->get_name()).get(canvas);
 705                         if(!canvas)
 706                                 continue;
 707
 708                         Canvas::reverse_iterator iter;
 709                         row[model.contained_canvas]=canvas;
 710
 711                         for(iter=canvas->rbegin();iter!=canvas->rend();++iter)
 712                         {
 713                                 Gtk::TreeRow row_(*(prepend(row.children())));
 714                                 set_row_layer(row_,*iter);
 715                         }
 716                         continue;
 717                 }
 718
 719                 /*
 720                 etl::handle<ValueNode> value_node;
 721                 if(handle.constant()->dynamic_param_list().count(iter->get_name()))
 722                         value_node=handle->dynamic_param_list()[iter->get_name()];
 723
 724                 Gtk::TreeRow child_row = *(append(row.children()));
 725                 set_row_param(
 726                         child_row,
 727                         handle,
 728                         iter->get_name(),
 729                         iter->get_local_name(),
 730                         paramlist[iter->get_name()],
 731                         value_node,
 732                         &*iter
 733                 );
 734                 */
 735         }
 736 }
 737
 738 void
 739 LayerTreeStore::on_layer_added(synfig::Layer::Handle layer)
 740 {
 741         assert(layer);
 742         Gtk::TreeRow row;
 743         if(canvas_interface()->get_canvas()==layer->get_canvas())
 744         {
 745                 row=*(prepend());
 746         }
 747         else
 748         {
 749                 Gtk::TreeModel::Children::iterator iter;
 750                 if(!find_canvas_row(layer->get_canvas(),iter))
 751                 {
 752                         rebuild();
 753                         return;
 754                 }
 755                 row=*(prepend(iter->children()));
 756         }
 757         set_row_layer(row,layer);
 758 }
 759
 760 void
 761 LayerTreeStore::on_layer_removed(synfig::Layer::Handle handle)
 762 {
 763         Gtk::TreeModel::Children::iterator iter;
 764         if(find_layer_row(handle,iter))
 765                 erase(iter);
 766         else
 767         {
 768                 synfig::error("LayerTreeStore::on_layer_removed():Unable to find layer to be removed, forced to rebuild...");
 769                 rebuild();
 770         }
 771 }
 772
 773 void
 774 LayerTreeStore::on_layer_inserted(synfig::Layer::Handle handle,int depth)
 775 {
 776         if(depth==0)
 777         {
 778                 on_layer_added(handle);
 779                 return;
 780         }
 781
 782         Gtk::TreeModel::Children children_(children());
 783         if(canvas_interface()->get_canvas()!=handle->get_canvas())
 784         {
 785                 Gtk::TreeModel::Children::iterator iter;
 786                 if(!find_canvas_row(handle->get_canvas(),iter))
 787                 {
 788                         synfig::error("LayerTreeStore::on_layer_inserted():Unable to find canvas row, forced to rebuild...");
 789                         rebuild();
 790                         return;
 791                 }
 792                 children_=iter->children();
 793         }
 794
 795         Gtk::TreeModel::Children::iterator iter(children_.begin());
 796         while(depth-- && iter)
 797         {
 798                 ++iter;
 799                 if(!iter || iter==children_.end())
 800                 {
 801                         synfig::error("LayerTreeStore::on_layer_inserted():Unable to achieve desired depth, forced to rebuild...");
 802                         rebuild();
 803                         return;
 804                 }
 805         }
 806
 807         Gtk::TreeModel::Row row(*insert(iter));
 808         set_row_layer(row,handle);
 809 }
 810
 811 void
 812 LayerTreeStore::on_layer_status_changed(synfig::Layer::Handle handle,bool /*x*/)
 813 {
 814         Gtk::TreeModel::Children::iterator iter;
 815         if(find_layer_row(handle,iter))
 816                 (*iter)[model.layer]=handle;
 817         else
 818         {
 819                 synfig::warning("Couldn't find layer to be activated in layer list. Rebuilding index...");
 820                 rebuild();
 821         }
 822 }
 823
 824 void
 825 LayerTreeStore::on_layer_lowered(synfig::Layer::Handle layer)
 826 {
 827         Gtk::TreeModel::Children::iterator iter, iter2;
 828         if(find_layer_row(layer,iter))
 829         {
 830                 // Save the selection data
 831                 //synfigapp::SelectionManager::LayerList layer_list=canvas_interface()->get_selection_manager()->get_selected_layers();
 832                 iter2=iter;
 833                 iter2++;
 834                 if(!iter2)
 835                 {
 836                         rebuild();
 837                         return;
 838                 }
 839
 840                 //Gtk::TreeModel::Row row(*iter);
 841                 Gtk::TreeModel::Row row2 = *iter2;
 842                 synfig::Layer::Handle layer2=row2[model.layer];
 843
 844                 erase(iter2);
 845                 row2=*insert(iter);
 846                 set_row_layer(row2,layer2);
 847
 848         }
 849         else
 850                 rebuild();
 851 }
 852
 853 void
 854 LayerTreeStore::on_layer_raised(synfig::Layer::Handle layer)
 855 {
 856         Gtk::TreeModel::Children::iterator iter, iter2;
 857
 858         Gtk::TreeModel::Children children_(children());
 859
 860         if(find_layer_row_(layer, canvas_interface()->get_canvas(), children_, iter,iter2))
 861         {
 862                 if(iter!=iter2)
 863                 {
 864                         //Gtk::TreeModel::Row row = *iter;
 865                         Gtk::TreeModel::Row row2 = *iter2;
 866                         synfig::Layer::Handle layer2=row2[model.layer];
 867
 868                         erase(iter2);
 869                         iter++;
 870                         row2=*insert(iter);
 871                         set_row_layer(row2,layer2);
 872
 873                         return;
 874                 }
 875         }
 876
 877         rebuild();
 878 }
 879
 880 void
 881 LayerTreeStore::on_layer_moved(synfig::Layer::Handle layer,int depth, synfig::Canvas::Handle /*canvas*/)
 882 {
 883         on_layer_removed(layer);
 884         on_layer_inserted(layer,depth);
 885 }
 886
 887 void
 888 LayerTreeStore::on_layer_param_changed(synfig::Layer::Handle handle,synfig::String param_name)
 889 {
 890         if(param_name=="z_depth")
 891         {
 892                 Gtk::TreeModel::Children::iterator iter;
 893                 if(find_layer_row(handle,iter))
 894                 {
 895                         (*iter)[model.z_depth]=Time::begin();
 896                 }
 897         }
 898
 899         /*
 900         //DEBUGPOINT();
 901         Gtk::TreeModel::Children::iterator iter;
 902         if(find_layer_row(handle,iter))
 903         {
 904                 //DEBUGPOINT();
 905                 Gtk::TreeModel::Children children(iter->children());
 906
 907                 for(iter = children.begin(); iter && iter != children.end(); ++iter)
 908                 {
 909                         if((Glib::ustring)(*iter)[model.param_name]==param_name)
 910                         {
 911                                 //DEBUGPOINT();
 912                                 Gtk::TreeRow row=*iter;
 913                                 refresh_row(row);
 914                                 return;
 915                         }
 916                 }
 917         }
 918         //DEBUGPOINT();
 919         rebuild();
 920         */
 921 }
 922
 923 void
 924 LayerTreeStore::on_layer_new_description(synfig::Layer::Handle handle,synfig::String desc)
 925 {
 926         Gtk::TreeModel::Children::iterator iter;
 927         if(find_layer_row(handle,iter))
 928         {
 929                 Gtk::TreeRow row(*iter);
 930
 931                 Layer::Handle layer(row[model.layer]);
 932
 933                 if(desc.empty())
 934                 {
 935                         //row[model.label]=layer->get_local_name();
 936                         row[model.tooltip]=Glib::ustring(_("Layer"));
 937                 }
 938                 else
 939                         //row[model.label]=layer->get_description();
 940                         row[model.tooltip]=layer->get_local_name();
 941         }
 942         else
 943         {
 944                 rebuild();
 945         }
 946 }
 947
 948 bool
 949 LayerTreeStore::find_canvas_row_(synfig::Canvas::Handle canvas, synfig::Canvas::Handle parent, Gtk::TreeModel::Children layers, Gtk::TreeModel::Children::iterator &iter)
 950 {
 951         if(canvas==parent)
 952                 return false;
 953
 954         {
 955                 for(iter=layers.begin(); iter && iter != layers.end(); ++iter)
 956                 {
 957                         Gtk::TreeModel::Row row = *iter;
 958                         if(canvas==(synfig::Canvas::Handle)row[model.contained_canvas])
 959                                 return true;
 960                 }
 961
 962                 iter=children().end();
 963                 //return false;
 964         }
 965
 966         Gtk::TreeModel::Children::iterator iter2;
 967         //Gtk::TreeModel::Children::iterator iter3;
 968
 969         for(iter2 = layers.begin(); iter2 && iter2 != layers.end(); ++iter2)
 970         {
 971                 Gtk::TreeModel::Row row = *iter2;
 972                 assert((bool)true);
 973
 974                 if(row.children().empty())
 975                         continue;
 976
 977                 Canvas::Handle sub_canvas((*row.children().begin())[model.canvas]);
 978                 if(!sub_canvas)
 979                         continue;
 980
 981                 if(find_canvas_row_(canvas,sub_canvas,iter2->children(),iter))
 982                         return true;
 983         }
 984
 985         iter=children().end();
 986         return false;
 987 }
 988
 989 bool
 990 LayerTreeStore::find_canvas_row(synfig::Canvas::Handle canvas, Gtk::TreeModel::Children::iterator &iter)
 991 {
 992         return find_canvas_row_(canvas,canvas_interface()->get_canvas(),children(),iter);
 993 }
 994
 995
 996 bool
 997 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)
 998 {
 999         assert(layer);
1000
1001         //if(layer->get_canvas()==canvas)
1002         {
1003                 for(iter=prev=layers.begin(); iter && iter != layers.end(); prev=iter++)
1004                 {
1005                         Gtk::TreeModel::Row row = *iter;
1006                         if(layer==(synfig::Layer::Handle)row[model.layer])
1007                                 return true;
1008                 }
1009
1010                 iter=children().end();
1011                 //DEBUGPOINT();
1012                 //return false;
1013         }
1014
1015         Gtk::TreeModel::Children::iterator iter2;
1016
1017         for(iter2 = layers.begin(); iter2 && iter2 != layers.end(); ++iter2)
1018         {
1019                 Gtk::TreeModel::Row row = *iter2;
1020                 assert((bool)true);
1021
1022                 if(row.children().empty())
1023                         continue;
1024
1025                 Canvas::Handle canvas((*row.children().begin())[model.canvas]);
1026                 if(!canvas)
1027                         continue;
1028
1029                 if(find_layer_row_(layer,canvas,iter2->children(),iter,prev))
1030                         return true;
1031         }
1032
1033         iter=children().end();
1034         return false;
1035 }
1036
1037 bool
1038 LayerTreeStore::find_layer_row(const synfig::Layer::Handle &layer, Gtk::TreeModel::Children::iterator &iter)
1039 {
1040         Gtk::TreeModel::Children::iterator prev;
1041         return find_layer_row_(layer,canvas_interface()->get_canvas(),children(),iter,prev);
1042 }
1043
1044 bool
1045 LayerTreeStore::find_prev_layer_row(const synfig::Layer::Handle &layer, Gtk::TreeModel::Children::iterator &prev)
1046 {
1047         Gtk::TreeModel::Children::iterator iter;
1048         if(!find_layer_row_(layer,canvas_interface()->get_canvas(),children(),iter,prev))
1049                 return false;
1050         if(iter==children().begin())
1051                 return false;
1052         return true;
1053 }