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