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

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file layerparamtreestore.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007, 2008 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "layerparamtreestore.h"
  34 #include "iconcontroller.h"
  35 #include <gtkmm/button.h>
  36 #include <synfig/paramdesc.h>
  37 #include "layertree.h"
  38 #include <synfigapp/action_system.h>
  39 #include <synfigapp/instance.h>
  40 #include "app.h"
  41 #include <ETL/clock>
  42
  43 #include "general.h"
  44
  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 class Profiler : private etl::clock
  57 {
  58         const std::string name;
  59 public:
  60         Profiler(const std::string& name):name(name) { reset(); }
  61         ~Profiler() { float time(operator()()); synfig::info("%s: took %f msec",name.c_str(),time*1000); }
  62 };
  63
  64 /* === G L O B A L S ======================================================= */
  65
  66 /* === P R O C E D U R E S ================================================= */
  67
  68 /* === M E T H O D S ======================================================= */
  69
  70 static LayerParamTreeStore::Model& ModelHack()
  71 {
  72         static LayerParamTreeStore::Model* model(0);
  73         if(!model)model=new LayerParamTreeStore::Model;
  74         return *model;
  75 }
  76
  77 LayerParamTreeStore::LayerParamTreeStore(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_,LayerTree* layer_tree):
  78         Gtk::TreeStore                  (ModelHack()),
  79         CanvasTreeStore                 (canvas_interface_),
  80         layer_tree                              (layer_tree)
  81 {
  82         queued=false;
  83         // Connect all the signals
  84         canvas_interface()->signal_value_node_changed().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_changed));
  85         canvas_interface()->signal_value_node_renamed().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_renamed));
  86         canvas_interface()->signal_value_node_added().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_added));
  87         canvas_interface()->signal_value_node_deleted().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_deleted));
  88         canvas_interface()->signal_value_node_replaced().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_replaced));
  89         canvas_interface()->signal_layer_param_changed().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_layer_param_changed));
  90
  91         canvas_interface()->signal_value_node_child_added().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_child_added));
  92         canvas_interface()->signal_value_node_child_removed().connect(sigc::mem_fun(*this,&studio::LayerParamTreeStore::on_value_node_child_removed));
  93
  94
  95         layer_tree->get_selection()->signal_changed().connect(sigc::mem_fun(*this,&LayerParamTreeStore::queue_rebuild));
  96
  97         signal_changed().connect(sigc::mem_fun(*this,&LayerParamTreeStore::queue_refresh));
  98         rebuild();
  99 }
 100
 101 LayerParamTreeStore::~LayerParamTreeStore()
 102 {
 103         while(!changed_connection_list.empty())
 104         {
 105                 changed_connection_list.back().disconnect();
 106                 changed_connection_list.pop_back();
 107         }
 108
 109         if (getenv("SYNFIG_DEBUG_DESTRUCTORS"))
 110                 synfig::info("LayerParamTreeStore::~LayerParamTreeStore(): Deleted");
 111 }
 112
 113 Glib::RefPtr<LayerParamTreeStore>
 114 LayerParamTreeStore::create(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_, LayerTree*layer_tree)
 115 {
 116         return Glib::RefPtr<LayerParamTreeStore>(new LayerParamTreeStore(canvas_interface_,layer_tree));
 117 }
 118
 119
 120
 121 void
 122 LayerParamTreeStore::get_value_vfunc (const Gtk::TreeModel::iterator& iter, int column, Glib::ValueBase& value)const
 123 {
 124         if(column<0)
 125         {
 126                 synfig::error("LayerParamTreeStore::get_value_vfunc(): Bad column!");
 127                 return;
 128         }
 129
 130 /*      if(column==model.label.index())
 131         {
 132                 synfig::Layer::Handle layer((*iter)[model.layer]);
 133
 134                 if(!layer)return;
 135
 136                 Glib::Value<Glib::ustring> x;
 137                 g_value_init(x.gobj(),x.value_type());
 138
 139                 x.set(layer->get_non_empty_description());
 140
 141                 g_value_init(value.gobj(),x.value_type());
 142                 g_value_copy(x.gobj(),value.gobj());
 143         }
 144         else
 145 */
 146         if(column==model.label.index())
 147         {
 148                 synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
 149                 Glib::ustring label;
 150
 151                 if(!(*iter)[model.is_toplevel])
 152                         return CanvasTreeStore::get_value_vfunc(iter,column,value);
 153                 synfig::ParamDesc param_desc((*iter)[model.param_desc]);
 154                 label=param_desc.get_local_name();
 155
 156                 if(!(*iter)[model.is_inconsistent])
 157                 if(value_desc.is_value_node() && value_desc.get_value_node()->is_exported())
 158                 {
 159                         label+=strprintf(" (%s)",value_desc.get_value_node()->get_id().c_str());
 160                 }
 161
 162                 Glib::Value<Glib::ustring> x;
 163                 g_value_init(x.gobj(),x.value_type());
 164
 165                 x.set(label);
 166
 167                 g_value_init(value.gobj(),x.value_type());
 168                 g_value_copy(x.gobj(),value.gobj());
 169         }
 170         else
 171         if(column==model.is_toplevel.index())
 172         {
 173                 Glib::Value<bool> x;
 174                 g_value_init(x.gobj(),x.value_type());
 175
 176                 TreeModel::Path path(get_path(iter));
 177
 178                 x.set(path.get_depth()<=1);
 179
 180                 g_value_init(value.gobj(),x.value_type());
 181                 g_value_copy(x.gobj(),value.gobj());
 182         }
 183         else
 184         if(column==model.is_inconsistent.index())
 185         {
 186                 if((*iter)[model.is_toplevel])
 187                 {
 188                         CanvasTreeStore::get_value_vfunc(iter,column,value);
 189                         return;
 190                 }
 191
 192                 Glib::Value<bool> x;
 193                 g_value_init(x.gobj(),x.value_type());
 194
 195                 x.set(false);
 196
 197                 g_value_init(value.gobj(),x.value_type());
 198                 g_value_copy(x.gobj(),value.gobj());
 199         }
 200         else
 201         CanvasTreeStore::get_value_vfunc(iter,column,value);
 202 }
 203
 204
 205
 206 void
 207 LayerParamTreeStore::set_value_impl(const Gtk::TreeModel::iterator& iter, int column, const Glib::ValueBase& value)
 208 {
 209         //if(!iterator_sane(row))
 210         //      return;
 211
 212         if(column>=get_n_columns_vfunc())
 213         {
 214                 g_warning("LayerTreeStore::set_value_impl: Bad column (%d)",column);
 215                 return;
 216         }
 217
 218         if(!g_value_type_compatible(G_VALUE_TYPE(value.gobj()),get_column_type_vfunc(column)))
 219         {
 220                 g_warning("LayerTreeStore::set_value_impl: Bad value type");
 221                 return;
 222         }
 223
 224         try
 225         {
 226                 if(column==model.value.index())
 227                 {
 228                         Glib::Value<synfig::ValueBase> x;
 229                         g_value_init(x.gobj(),model.value.type());
 230                         g_value_copy(value.gobj(),x.gobj());
 231
 232                         if((bool)(*iter)[model.is_toplevel])
 233                         {
 234                                 synfigapp::Action::PassiveGrouper group(canvas_interface()->get_instance().get(),_("Set Layer Params"));
 235
 236                                 synfig::ParamDesc param_desc((*iter)[model.param_desc]);
 237
 238                                 LayerList::iterator iter2(layer_list.begin());
 239
 240                                 for(;iter2!=layer_list.end();++iter2)
 241                                 {
 242                                         if(!canvas_interface()->change_value(synfigapp::ValueDesc(*iter2,param_desc.get_name()),x.get()))
 243                                         {
 244                                                 // ERROR!
 245                                                 group.cancel();
 246                                                 App::dialog_error_blocking(_("Error"),_("Unable to set all layer parameters."));
 247
 248                                                 return;
 249                                         }
 250                                 }
 251                         }
 252                         else
 253                         {
 254                                 canvas_interface()->change_value((*iter)[model.value_desc],x.get());
 255                         }
 256                         return;
 257                 }
 258                 else
 259 /*
 260                 if(column==model.active.index())
 261                 {
 262                         synfig::Layer::Handle layer((*iter)[model.layer]);
 263
 264                         if(!layer)return;
 265
 266                         Glib::Value<bool> x;
 267                         g_value_init(x.gobj(),model.active.type());
 268                         g_value_copy(value.gobj(),x.gobj());
 269
 270                         synfigapp::Action::Handle action(synfigapp::Action::create("layer_activate"));
 271
 272                         if(!action)
 273                                 return;
 274
 275                         action->set_param("canvas",canvas_interface()->get_canvas());
 276                         action->set_param("canvas_interface",canvas_interface());
 277                         action->set_param("layer",layer);
 278                         action->set_param("new_status",bool(x.get()));
 279
 280                         canvas_interface()->get_instance()->perform_action(action);
 281                         return;
 282                 }
 283                 else
 284 */
 285                 CanvasTreeStore::set_value_impl(iter,column, value);
 286         }
 287         catch(std::exception x)
 288         {
 289                 g_warning(x.what());
 290         }
 291 }
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302 void
 303 LayerParamTreeStore::rebuild()
 304 {
 305         // Profiler profiler("LayerParamTreeStore::rebuild()");
 306         if(queued)queued=false;
 307         clear();
 308         layer_list=layer_tree->get_selected_layers();
 309
 310         if(layer_list.size()<=0)
 311                 return;
 312
 313         // Get rid of all the connections,
 314         // and clear the connection map.
 315         //while(!connection_map.empty())connection_map.begin()->second.disconnect(),connection_map.erase(connection_map.begin());
 316         while(!changed_connection_list.empty())
 317         {
 318                 changed_connection_list.back().disconnect();
 319                 changed_connection_list.pop_back();
 320         }
 321
 322         struct REBUILD_HELPER
 323         {
 324                 ParamVocab vocab;
 325                 Layer::Handle layer_0;
 326
 327                 static ParamVocab::iterator find_param_desc(ParamVocab& vocab, const synfig::String& x)
 328                 {
 329                         ParamVocab::iterator iter;
 330
 331                         for(iter=vocab.begin();iter!=vocab.end();++iter)
 332                                 if(iter->get_name()==x)
 333                                         break;
 334                         return iter;
 335                 }
 336
 337                 void process_vocab(synfig::Layer::Handle layer_n)
 338                 {
 339                         ParamVocab x = layer_n->get_param_vocab();
 340                         ParamVocab::iterator iter;
 341
 342                         for(iter=vocab.begin();iter!=vocab.end();++iter)
 343                         {
 344                                 String name(iter->get_name());
 345                                 ParamVocab::iterator iter2(find_param_desc(x,name));
 346                                 if(iter2==x.end() ||
 347                                    layer_0->get_param(name).get_type() != layer_n->get_param(name).get_type())
 348                                 {
 349                                         // remove it and start over
 350                                         vocab.erase(iter);
 351                                         iter=vocab.begin();
 352                                         iter--;
 353                                         continue;
 354                                 }
 355                         }
 356                 }
 357
 358         } rebuild_helper;
 359
 360
 361         {
 362                 LayerList::iterator iter(layer_list.begin());
 363                 rebuild_helper.vocab=(*iter)->get_param_vocab();
 364                 rebuild_helper.layer_0=*iter;
 365
 366                 for(++iter;iter!=layer_list.end();++iter)
 367                 {
 368                         rebuild_helper.process_vocab(*iter);
 369                         changed_connection_list.push_back(
 370                                 (*iter)->signal_changed().connect(
 371                                         sigc::mem_fun(
 372                                                 *this,
 373                                                 &LayerParamTreeStore::changed
 374                                         )
 375                                 )
 376                         );
 377                 }
 378         }
 379
 380         ParamVocab::iterator iter;
 381         for(iter=rebuild_helper.vocab.begin();iter!=rebuild_helper.vocab.end();++iter)
 382         {
 383                 if(iter->get_hidden())
 384                         continue;
 385
 386                 /*
 387                 if(iter->get_animation_only())
 388                 {
 389                         int length(layer_list.front()->get_canvas()->rend_desc().get_frame_end()-layer_list.front()->get_canvas()->rend_desc().get_frame_start());
 390                         if(!length)
 391                                 continue;
 392                 }
 393                 */
 394                 Gtk::TreeRow row(*(append()));
 395                 synfigapp::ValueDesc value_desc(layer_list.front(),iter->get_name());
 396                 CanvasTreeStore::set_row(row,value_desc);
 397                 if(value_desc.is_value_node())
 398                 {
 399                         changed_connection_list.push_back(
 400                                 value_desc.get_value_node()->signal_changed().connect(
 401                                         sigc::mem_fun(
 402                                                 this,
 403                                                 &LayerParamTreeStore::changed
 404                                         )
 405                                 )
 406                         );
 407                 }
 408                 if(value_desc.get_value_type()==ValueBase::TYPE_CANVAS)
 409                 {
 410                         Canvas::Handle canvas_handle = value_desc.get_value().get(Canvas::Handle());
 411                         if(canvas_handle) changed_connection_list.push_back(
 412                                 canvas_handle->signal_changed().connect(
 413                                         sigc::mem_fun(
 414                                                 this,
 415                                                 &LayerParamTreeStore::changed
 416                                         )
 417                                 )
 418                         );
 419                 }
 420                 //row[model.label] = iter->get_local_name();
 421                 row[model.param_desc] = *iter;
 422                 row[model.canvas] = layer_list.front()->get_canvas();
 423                 row[model.is_inconsistent] = false;
 424                 //row[model.is_toplevel] = true;
 425
 426
 427                 LayerList::iterator iter2(layer_list.begin());
 428                 ValueBase value((*iter2)->get_param(iter->get_name()));
 429                 for(++iter2;iter2!=layer_list.end();++iter2)
 430                 {
 431                         if(value!=((*iter2)->get_param(iter->get_name())))
 432                         {
 433                                 row[model.is_inconsistent] = true;
 434                                 while(!row.children().empty() && erase(row.children().begin()))
 435                                         ;
 436                                 break;
 437                         }
 438                 }
 439         }
 440 }
 441
 442 void
 443 LayerParamTreeStore::queue_refresh()
 444 {
 445         if(queued)
 446                 return;
 447         queued=1;
 448         queue_connection.disconnect();
 449         queue_connection=Glib::signal_timeout().connect(
 450                 sigc::bind_return(
 451                         sigc::mem_fun(*this,&LayerParamTreeStore::refresh),
 452                         false
 453                 )
 454         ,150);
 455
 456 }
 457
 458 void
 459 LayerParamTreeStore::queue_rebuild()
 460 {
 461         if(queued==2)
 462                 return;
 463         queued=2;
 464         queue_connection.disconnect();
 465         queue_connection=Glib::signal_timeout().connect(
 466                 sigc::bind_return(
 467                         sigc::mem_fun(*this,&LayerParamTreeStore::rebuild),
 468                         false
 469                 )
 470         ,150);
 471
 472 }
 473
 474 void
 475 LayerParamTreeStore::refresh()
 476 {
 477         if(queued)queued=false;
 478
 479         Gtk::TreeModel::Children children_(children());
 480
 481         Gtk::TreeModel::Children::iterator iter;
 482
 483         if(!children_.empty())
 484                 for(iter = children_.begin(); iter && iter != children_.end(); ++iter)
 485                 {
 486                         Gtk::TreeRow row=*iter;
 487                         refresh_row(row);
 488                 }
 489 }
 490
 491 void
 492 LayerParamTreeStore::refresh_row(Gtk::TreeModel::Row &row)
 493 {
 494         if(row[model.is_toplevel])
 495         {
 496                 row[model.is_inconsistent] = false;
 497                 ParamDesc param_desc(row[model.param_desc]);
 498
 499                 LayerList::iterator iter2(layer_list.begin());
 500                 ValueBase value((*iter2)->get_param(param_desc.get_name()));
 501                 for(++iter2;iter2!=layer_list.end();++iter2)
 502                 {
 503                         if(value!=((*iter2)->get_param(param_desc.get_name())))
 504                         {
 505                                 row[model.is_inconsistent] = true;
 506                                 while(!row.children().empty() && erase(row.children().begin()))
 507                                         ;
 508                                 return;
 509                         }
 510                 }
 511         }
 512
 513         //handle<ValueNode> value_node=row[model.value_node];
 514         //if(value_node)
 515         {
 516                 CanvasTreeStore::refresh_row(row);
 517                 return;
 518         }
 519 }
 520
 521 void
 522 LayerParamTreeStore::set_row(Gtk::TreeRow row,synfigapp::ValueDesc value_desc)
 523 {
 524         Gtk::TreeModel::Children children = row.children();
 525         while(!children.empty() && erase(children.begin()))
 526                 ;
 527
 528         CanvasTreeStore::set_row(row,value_desc);
 529 }
 530
 531 void
 532 LayerParamTreeStore::on_value_node_added(synfig::ValueNode::Handle /*value_node*/)
 533 {
 534 //      queue_refresh();
 535 }
 536
 537 void
 538 LayerParamTreeStore::on_value_node_deleted(synfig::ValueNode::Handle /*value_node*/)
 539 {
 540 //      queue_refresh();
 541 }
 542
 543 void
 544 LayerParamTreeStore::on_value_node_child_added(synfig::ValueNode::Handle /*value_node*/,synfig::ValueNode::Handle /*child*/)
 545 {
 546         queue_rebuild();
 547 }
 548
 549 void
 550 LayerParamTreeStore::on_value_node_child_removed(synfig::ValueNode::Handle /*value_node*/,synfig::ValueNode::Handle /*child*/)
 551 {
 552         rebuild();
 553 }
 554
 555 void
 556 LayerParamTreeStore::on_value_node_changed(synfig::ValueNode::Handle /*value_node*/)
 557 {
 558         queue_refresh();
 559 }
 560
 561 void
 562 LayerParamTreeStore::on_value_node_renamed(synfig::ValueNode::Handle /*value_node*/)
 563 {
 564         rebuild();
 565 }
 566
 567 void
 568 LayerParamTreeStore::on_value_node_replaced(synfig::ValueNode::Handle /*replaced_value_node*/,synfig::ValueNode::Handle /*new_value_node*/)
 569 {
 570         queue_rebuild();
 571 }
 572
 573 void
 574 LayerParamTreeStore::on_layer_param_changed(synfig::Layer::Handle /*handle*/,synfig::String /*param_name*/)
 575 {
 576         queue_refresh();
 577 }