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

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