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

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