synfig-core/trunk/src/synfig/valuenode.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file valuenode.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 #define SYNFIG_NO_ANGLE
  26
  27 //#define HAS_HASH_MAP 1
  28
  29 #ifdef USING_PCH
  30 #       include "pch.h"
  31 #else
  32 #ifdef HAVE_CONFIG_H
  33 #       include <config.h>
  34 #endif
  35
  36 #include "valuenode.h"
  37 #include "general.h"
  38 #include "canvas.h"
  39
  40 #include "valuenode_const.h"
  41 #include "valuenode_linear.h"
  42 #include "valuenode_composite.h"
  43 #include "valuenode_reference.h"
  44 #include "valuenode_scale.h"
  45 #include "valuenode_segcalctangent.h"
  46 #include "valuenode_segcalcvertex.h"
  47 #include "valuenode_repeat_gradient.h"
  48 #include "valuenode_stripes.h"
  49 #include "valuenode_add.h"
  50 #include "valuenode_subtract.h"
  51 #include "valuenode_timedswap.h"
  52 #include "valuenode_twotone.h"
  53 #include "valuenode_bline.h"
  54 #include "valuenode_dynamiclist.h"
  55 #include "valuenode_radialcomposite.h"
  56 #include "valuenode_gradientrotate.h"
  57 #include "valuenode_sine.h"
  58 #include "valuenode_exp.h"
  59
  60 #include "layer.h"
  61
  62 #endif
  63
  64 /* === U S I N G =========================================================== */
  65
  66 using namespace std;
  67 using namespace etl;
  68 using namespace synfig;
  69
  70 /* === M A C R O S ========================================================= */
  71
  72 /* === G L O B A L S ======================================================= */
  73
  74 static int value_node_count(0);
  75
  76 static LinkableValueNode::Book *book_;
  77
  78
  79 ValueNode::LooseHandle
  80 synfig::find_value_node(const GUID& guid)
  81 {
  82         return guid_cast<ValueNode>(guid);
  83 }
  84
  85 /* === P R O C E D U R E S ================================================= */
  86
  87 /* === M E T H O D S ======================================================= */
  88
  89 bool
  90 ValueNode::subsys_init()
  91 {
  92         book_=new LinkableValueNode::Book();
  93
  94 #define ADD_VALUENODE(class,name,local)                                                                                                                 \
  95         (*book_)[name].factory=reinterpret_cast<LinkableValueNode::Factory>(&class::create);            \
  96         (*book_)[name].check_type=&class::check_type;                                                                                           \
  97         (*book_)[name].local_name=local
  98
  99 #define ADD_VALUENODE2(class,name,local)                                                                                                                \
 100         (*book_)[name].factory=reinterpret_cast<LinkableValueNode::Factory>(&class::create_from);       \
 101         (*book_)[name].check_type=&class::check_type;                                                                                           \
 102         (*book_)[name].local_name=local
 103
 104         ADD_VALUENODE(ValueNode_Linear,                 "linear",                       _("Linear")                             );
 105         ADD_VALUENODE(ValueNode_Composite,              "composite",            _("Composite")                  );
 106         ADD_VALUENODE(ValueNode_RadialComposite,"radial_composite",     _("Radial Composite")   );
 107         ADD_VALUENODE(ValueNode_Reference,              "reference",            _("Reference")                  );
 108         ADD_VALUENODE(ValueNode_Repeat_Gradient,"repeat_gradient",      _("Repeat Gradient")    );
 109         ADD_VALUENODE(ValueNode_Scale,                  "scale",                        _("Scale")                              );
 110         ADD_VALUENODE(ValueNode_SegCalcTangent, "segcalctangent",       _("Segment Tangent")    );
 111         ADD_VALUENODE(ValueNode_SegCalcVertex,  "segcalcvertex",        _("Segment Vertex")             );
 112         ADD_VALUENODE(ValueNode_Stripes,                "stripes",                      _("Stripes")                    );
 113         ADD_VALUENODE(ValueNode_Subtract,               "add",                          _("Add")                                );
 114         ADD_VALUENODE(ValueNode_Subtract,               "subtract",                     _("Subtract")                   );
 115         ADD_VALUENODE(ValueNode_TimedSwap,              "timed_swap",           _("Timed Swap")                 );
 116         ADD_VALUENODE(ValueNode_TwoTone,                "twotone",                      _("Two-Tone")                   );
 117         ADD_VALUENODE(ValueNode_BLine,                  "bline",                        _("BLine")                              );
 118         ADD_VALUENODE2(ValueNode_DynamicList,   "dynamic_list",         _("Dynamic List")               );
 119         ADD_VALUENODE(ValueNode_GradientRotate, "gradient_rotate",      _("Gradient Rotate")    );
 120         ADD_VALUENODE(ValueNode_Sine,                   "sine",                         _("Sine")                               );
 121         ADD_VALUENODE(ValueNode_Exp,                    "exp",                          _("Exponential")                );
 122
 123 #undef ADD_VALUENODE
 124 #undef ADD_VALUENODE2
 125
 126         return true;
 127 }
 128
 129 bool
 130 ValueNode::subsys_stop()
 131 {
 132         delete book_;
 133 /*      if(global_value_node_map.size() || value_node_count)
 134         {
 135                 if(value_node_count)
 136                         synfig::error("%d ValueNodes haven't been destroyed yet!",value_node_count);
 137
 138                 if(global_value_node_map.size()!=value_node_count)
 139                         synfig::error("value node count mismatch! map.size()!=value_node_count (%d!=%d)",global_value_node_map.size(),value_node_count);
 140
 141                 GlobalValueNodeMap::iterator iter;
 142                 for(iter=global_value_node_map.begin();iter!=global_value_node_map.end();++iter)
 143                 {
 144                         if(!iter->second->is_exported())
 145                                 synfig::info("%s: count:%d name:%s type:%s",
 146                                         iter->first.get_string().c_str(),
 147                                         iter->second->count(),
 148                                         iter->second->get_name().c_str(),
 149                                         ValueBase::type_name(iter->second->get_type()).c_str()
 150                                 );
 151                         else
 152                                 synfig::info("%s: id:%s count:%d name:%s type:%s",
 153                                         iter->first.get_string().c_str(),
 154                                         iter->second->get_id().c_str(),
 155                                         iter->second->count(),
 156                                         iter->second->get_name().c_str(),
 157                                         ValueBase::type_name(iter->second->get_type()).c_str()
 158                                 );
 159                 }
 160         }
 161 */
 162         return true;
 163 }
 164
 165 ValueNode::ValueNode(ValueBase::Type type):type(type)
 166 {
 167         value_node_count++;
 168 }
 169
 170 LinkableValueNode::Book&
 171 LinkableValueNode::book()
 172 {
 173         return *book_;
 174 }
 175
 176 LinkableValueNode::Handle
 177 LinkableValueNode::create(const String &name, const ValueBase& x)
 178 {
 179         if(!book().count(name))
 180                 return 0;
 181         return book()[name].factory(x);
 182 }
 183
 184 bool
 185 LinkableValueNode::check_type(const String &name, ValueBase::Type x)
 186 {
 187         if(!book().count(name) || !book()[name].check_type)
 188                 return false;
 189         return book()[name].check_type(x);
 190 }
 191
 192 bool
 193 LinkableValueNode::set_link(int i,ValueNode::Handle x)
 194 {
 195         ValueNode::Handle previous(get_link(i));
 196
 197         if(set_link_vfunc(i,x))
 198         {
 199                 if(previous)
 200                         remove_child(previous.get());
 201                 add_child(x.get());
 202
 203                 if(!x->is_exported() && get_parent_canvas())
 204                 {
 205                         x->set_parent_canvas(get_parent_canvas());
 206                 }
 207                 changed();
 208                 return true;
 209         }
 210         return false;
 211 }
 212
 213 ValueNode::LooseHandle
 214 LinkableValueNode::get_link(int i)const
 215 {
 216         return get_link_vfunc(i);
 217 }
 218
 219 void
 220 LinkableValueNode::unlink_all()
 221 {
 222         for(int i=0;i<link_count();i++)
 223         {
 224                 ValueNode::LooseHandle value_node(get_link(i));
 225                 if(value_node)
 226                         value_node->parent_set.erase(this);
 227         }
 228 }
 229
 230 ValueNode::~ValueNode()
 231 {
 232         value_node_count--;
 233
 234         begin_delete();
 235
 236         //DEBUGPOINT();
 237 }
 238
 239 void
 240 ValueNode::on_changed()
 241 {
 242         etl::loose_handle<Canvas> parent_canvas = get_parent_canvas();
 243         if(parent_canvas)
 244                 do                                              // signal to all the ancestor canvases
 245                         parent_canvas->signal_value_node_changed()(this);
 246                 while (parent_canvas = parent_canvas->parent());
 247         else if(get_root_canvas())
 248                 get_root_canvas()->signal_value_node_changed()(this);
 249
 250         Node::on_changed();
 251 }
 252
 253 int
 254 ValueNode::replace(etl::handle<ValueNode> x)
 255 {
 256         if(x.get()==this)
 257                 return 0;
 258
 259         while(parent_set.size())
 260         {
 261                 (*parent_set.begin())->add_child(x.get());
 262                 (*parent_set.begin())->remove_child(this);
 263                 //x->parent_set.insert(*parent_set.begin());
 264                 //parent_set.erase(parent_set.begin());
 265         }
 266         int r(RHandle(this).replace(x));
 267         x->changed();
 268         return r;
 269 }
 270
 271 void
 272 ValueNode::set_id(const String &x)
 273 {
 274         if(name!=x)
 275         {
 276                 name=x;
 277                 signal_id_changed_();
 278         }
 279 }
 280
 281 ValueNodeList::ValueNodeList():
 282         placeholder_count_(0)
 283 {
 284 }
 285
 286 bool
 287 ValueNodeList::count(const String &id)const
 288 {
 289         const_iterator iter;
 290
 291         if(id.empty())
 292                 return false;
 293
 294         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter);
 295
 296         if(iter==end())
 297                 return false;
 298
 299         return true;
 300 }
 301
 302 ValueNode::Handle
 303 ValueNodeList::find(const String &id)
 304 {
 305         iterator iter;
 306
 307         if(id.empty())
 308                 throw Exception::IDNotFound("Empty ID");
 309
 310         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter);
 311
 312         if(iter==end())
 313                 throw Exception::IDNotFound("ValueNode in ValueNodeList: "+id);
 314
 315         return *iter;
 316 }
 317
 318 ValueNode::ConstHandle
 319 ValueNodeList::find(const String &id)const
 320 {
 321         const_iterator iter;
 322
 323         if(id.empty())
 324                 throw Exception::IDNotFound("Empty ID");
 325
 326         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter);
 327
 328         if(iter==end())
 329                 throw Exception::IDNotFound("ValueNode in ValueNodeList: "+id);
 330
 331         return *iter;
 332 }
 333
 334 ValueNode::Handle
 335 ValueNodeList::surefind(const String &id)
 336 {
 337         if(id.empty())
 338                 throw Exception::IDNotFound("Empty ID");
 339
 340         ValueNode::Handle value_node;
 341
 342         try
 343         {
 344                 value_node=find(id);
 345         }
 346         catch(Exception::IDNotFound)
 347         {
 348                 value_node=PlaceholderValueNode::create();
 349                 value_node->set_id(id);
 350                 push_back(value_node);
 351                 placeholder_count_++;
 352         }
 353
 354         return value_node;
 355 }
 356
 357 bool
 358 ValueNodeList::erase(ValueNode::Handle value_node)
 359 {
 360         assert(value_node);
 361
 362         iterator iter;
 363
 364         for(iter=begin();iter!=end();++iter)
 365                 if(value_node.get()==iter->get())
 366                 {
 367                         std::list<ValueNode::RHandle>::erase(iter);
 368                         if(PlaceholderValueNode::Handle::cast_dynamic(value_node))
 369                                 placeholder_count_--;
 370                         return true;
 371                 }
 372         return false;
 373 }
 374
 375 bool
 376 ValueNodeList::add(ValueNode::Handle value_node)
 377 {
 378         if(!value_node)
 379                 return false;
 380         if(value_node->get_id().empty())
 381                 return false;
 382
 383         try
 384         {
 385                 ValueNode::RHandle other_value_node=find(value_node->get_id());
 386                 if(PlaceholderValueNode::Handle::cast_dynamic(other_value_node))
 387                 {
 388                         other_value_node->replace(value_node);
 389                         placeholder_count_--;
 390                         return true;
 391                 }
 392
 393                 return false;
 394         }
 395         catch(Exception::IDNotFound)
 396         {
 397                 push_back(value_node);
 398                 return true;
 399         }
 400
 401         return false;
 402 }
 403
 404 void
 405 ValueNodeList::audit()
 406 {
 407         iterator iter,next;
 408
 409         for(next=begin(),iter=next++;iter!=end();iter=next++)
 410                 if(iter->count()==1)
 411                         std::list<ValueNode::RHandle>::erase(iter);
 412 }
 413
 414
 415 String
 416 PlaceholderValueNode::get_name()const
 417 {
 418         return "placeholder";
 419 }
 420
 421 String
 422 PlaceholderValueNode::get_local_name()const
 423 {
 424         return _("Placeholder");
 425 }
 426
 427 ValueNode*
 428 PlaceholderValueNode::clone(const GUID& deriv_guid)const
 429 {
 430         ValueNode* ret(new PlaceholderValueNode());
 431         ret->set_guid(get_guid()^deriv_guid);
 432         return ret;
 433 }
 434
 435 PlaceholderValueNode::Handle
 436 PlaceholderValueNode::create(ValueBase::Type type)
 437 {
 438         return new PlaceholderValueNode(type);
 439 }
 440
 441 ValueBase
 442 PlaceholderValueNode::operator()(Time /*t*/)const
 443 {
 444         assert(0);
 445         return ValueBase();
 446 }
 447
 448 PlaceholderValueNode::PlaceholderValueNode(ValueBase::Type type):
 449         ValueNode(type)
 450 {
 451 }
 452
 453 ValueNode*
 454 LinkableValueNode::clone(const GUID& deriv_guid)const
 455 {
 456         { ValueNode* x(find_value_node(get_guid()^deriv_guid).get()); if(x)return x; }
 457
 458         int i;
 459         LinkableValueNode *ret=create_new();
 460         ret->set_guid(get_guid()^deriv_guid);
 461
 462         for(i=0;i<link_count();i++)
 463         {
 464                 ValueNode::Handle link=get_link_vfunc(i);
 465                 if(!link->is_exported())
 466                 {
 467                         ValueNode::LooseHandle value_node(find_value_node(link->get_guid()^deriv_guid));
 468                         if(!value_node)
 469                                 value_node=link->clone(deriv_guid);
 470                         ret->set_link(i,value_node);
 471                 }
 472                 else
 473                         ret->set_link(i,link);
 474         }
 475
 476         return ret;
 477 }
 478
 479 String
 480 ValueNode::get_relative_id(etl::loose_handle<const Canvas> x)const
 481 {
 482         assert(is_exported());
 483         assert(canvas_);
 484
 485         if(x.get()==canvas_.get())
 486                 return get_id();
 487
 488         return canvas_->_get_relative_id(x)+':'+get_id();
 489 }
 490
 491 void
 492 ValueNode::set_parent_canvas(etl::loose_handle<Canvas> x)
 493 {
 494         canvas_=x; if(x) root_canvas_=x->get_root();
 495 }
 496
 497 void
 498 ValueNode::set_root_canvas(etl::loose_handle<Canvas> x)
 499 {
 500         root_canvas_=x->get_root();
 501 }
 502
 503 void LinkableValueNode::get_times_vfunc(Node::time_set &set) const
 504 {
 505         ValueNode::LooseHandle  h;
 506
 507         int size = link_count();
 508
 509         //just add it to the set...
 510         for(int i=0; i < size; ++i)
 511         {
 512                 h = get_link(i);
 513
 514                 if(h)
 515                 {
 516                         const Node::time_set &tset = h->get_times();
 517                         set.insert(tset.begin(),tset.end());
 518                 }
 519         }
 520 }