Delete svn tags. We don't need them in git
[synfig.git] / 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, 2008 Chris Moore
10 **  Copyright (c) 2008 Carlos López
11 **
12 **      This package is free software; you can redistribute it and/or
13 **      modify it under the terms of the GNU General Public License as
14 **      published by the Free Software Foundation; either version 2 of
15 **      the License, or (at your option) any later version.
16 **
17 **      This package is distributed in the hope that it will be useful,
18 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
19 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 **      General Public License for more details.
21 **      \endlegal
22 */
23 /* ========================================================================= */
24
25 /* === H E A D E R S ======================================================= */
26
27 #define SYNFIG_NO_ANGLE
28
29 //#define HAS_HASH_MAP 1
30
31 #ifdef USING_PCH
32 #       include "pch.h"
33 #else
34 #ifdef HAVE_CONFIG_H
35 #       include <config.h>
36 #endif
37
38 #include "valuenode.h"
39 #include "general.h"
40 #include "canvas.h"
41 #include "paramdesc.h"
42 #include "releases.h"
43
44 #include "valuenode_const.h"
45 #include "valuenode_linear.h"
46 #include "valuenode_composite.h"
47 #include "valuenode_reference.h"
48 #include "valuenode_greyed.h"
49 #include "valuenode_scale.h"
50 #include "valuenode_blinecalctangent.h"
51 #include "valuenode_blinecalcvertex.h"
52 #include "valuenode_blinecalcwidth.h"
53 #include "valuenode_blinereversetangent.h"
54 #include "valuenode_segcalctangent.h"
55 #include "valuenode_segcalcvertex.h"
56 #include "valuenode_repeat_gradient.h"
57 #include "valuenode_stripes.h"
58 #include "valuenode_range.h"
59 #include "valuenode_add.h"
60 #include "valuenode_subtract.h"
61 #include "valuenode_timedswap.h"
62 #include "valuenode_twotone.h"
63 #include "valuenode_bline.h"
64 #include "valuenode_dynamiclist.h"
65 #include "valuenode_radialcomposite.h"
66 #include "valuenode_gradientrotate.h"
67 #include "valuenode_sine.h"
68 #include "valuenode_cos.h"
69 #include "valuenode_atan2.h"
70 #include "valuenode_exp.h"
71 #include "valuenode_switch.h"
72 #include "valuenode_timeloop.h"
73 #include "valuenode_reciprocal.h"
74 #include "valuenode_duplicate.h"
75 #include "valuenode_integer.h"
76 #include "valuenode_step.h"
77 #include "valuenode_vectorangle.h"
78 #include "valuenode_vectorlength.h"
79 #include "valuenode_vectorx.h"
80 #include "valuenode_vectory.h"
81 #include "valuenode_gradientcolor.h"
82 #include "valuenode_dotproduct.h"
83 #include "valuenode_timestring.h"
84 #include "valuenode_realstring.h"
85 #include "valuenode_join.h"
86 #include "valuenode_anglestring.h"
87 #include "valuenode_intstring.h"
88 #include "valuenode_log.h"
89 #include "valuenode_pow.h"
90 #include "valuenode_compare.h"
91 #include "valuenode_not.h"
92 #include "valuenode_and.h"
93 #include "valuenode_or.h"
94
95 #include "layer.h"
96
97 #endif
98
99 /* === U S I N G =========================================================== */
100
101 using namespace std;
102 using namespace etl;
103 using namespace synfig;
104
105 /* === M A C R O S ========================================================= */
106
107 /* === G L O B A L S ======================================================= */
108
109 static int value_node_count(0);
110
111 static LinkableValueNode::Book *book_;
112
113
114 ValueNode::LooseHandle
115 synfig::find_value_node(const GUID& guid)
116 {
117         return guid_cast<ValueNode>(guid);
118 }
119
120 /* === P R O C E D U R E S ================================================= */
121
122 /* === M E T H O D S ======================================================= */
123
124 bool
125 ValueNode::subsys_init()
126 {
127         book_=new LinkableValueNode::Book();
128
129 #define ADD_VALUENODE(class,name,local,version)                                                                                                 \
130         (*book_)[name].factory=reinterpret_cast<LinkableValueNode::Factory>(&class::create);            \
131         (*book_)[name].check_type=&class::check_type;                                                                                           \
132         (*book_)[name].local_name=local;                                                                                                                        \
133         (*book_)[name].release_version=version
134
135 #define ADD_VALUENODE2(class,name,local,version)                                                                                                \
136         (*book_)[name].factory=reinterpret_cast<LinkableValueNode::Factory>(&class::create_from);       \
137         (*book_)[name].check_type=&class::check_type;                                                                                           \
138         (*book_)[name].local_name=local;                                                                                                                        \
139         (*book_)[name].release_version=version
140
141         ADD_VALUENODE(ValueNode_Linear,                   "linear",                       _("Linear"),                   RELEASE_VERSION_0_61_06);
142         ADD_VALUENODE(ValueNode_Composite,                "composite",            _("Composite"),                RELEASE_VERSION_0_61_06);
143         ADD_VALUENODE(ValueNode_RadialComposite,  "radial_composite", _("Radial Composite"), RELEASE_VERSION_0_61_06);
144         ADD_VALUENODE(ValueNode_Reference,                "reference",            _("Reference"),                RELEASE_VERSION_0_61_06);
145         ADD_VALUENODE(ValueNode_Scale,                    "scale",                        _("Scale"),                    RELEASE_VERSION_0_61_06);
146         ADD_VALUENODE(ValueNode_SegCalcTangent,   "segcalctangent",       _("Segment Tangent"),  RELEASE_VERSION_0_61_06);
147         ADD_VALUENODE(ValueNode_SegCalcVertex,    "segcalcvertex",        _("Segment Vertex"),   RELEASE_VERSION_0_61_06);
148         ADD_VALUENODE(ValueNode_Stripes,                  "stripes",              _("Stripes"),                  RELEASE_VERSION_0_61_06);
149         ADD_VALUENODE(ValueNode_Subtract,                 "subtract",             _("Subtract"),                 RELEASE_VERSION_0_61_06);
150         ADD_VALUENODE(ValueNode_TwoTone,                  "twotone",              _("Two-Tone"),                 RELEASE_VERSION_0_61_06);
151         ADD_VALUENODE(ValueNode_BLine,                    "bline",                        _("BLine"),                    RELEASE_VERSION_0_61_06);
152         ADD_VALUENODE2(ValueNode_DynamicList,     "dynamic_list",         _("Dynamic List"),     RELEASE_VERSION_0_61_06);
153         ADD_VALUENODE(ValueNode_GradientRotate,   "gradient_rotate",  _("Gradient Rotate"),      RELEASE_VERSION_0_61_06);
154         ADD_VALUENODE(ValueNode_Sine,                     "sine",                         _("Sine"),                     RELEASE_VERSION_0_61_06);
155
156         ADD_VALUENODE(ValueNode_TimedSwap,                "timed_swap",           _("Timed Swap"),               RELEASE_VERSION_0_61_07); // SVN r610
157         ADD_VALUENODE(ValueNode_Repeat_Gradient,  "repeat_gradient",  _("Repeat Gradient"),      RELEASE_VERSION_0_61_07); // SVN r666
158         ADD_VALUENODE(ValueNode_Exp,                      "exp",                          _("Exponential"),              RELEASE_VERSION_0_61_07); // SVN r739
159         ADD_VALUENODE(ValueNode_Add,                      "add",                          _("Add"),                              RELEASE_VERSION_0_61_07); // SVN r742
160         ADD_VALUENODE(ValueNode_BLineCalcTangent, "blinecalctangent", _("BLine Tangent"),        RELEASE_VERSION_0_61_07); // SVN r744
161         ADD_VALUENODE(ValueNode_BLineCalcVertex,  "blinecalcvertex",  _("BLine Vertex"),         RELEASE_VERSION_0_61_07); // SVN r744
162         ADD_VALUENODE(ValueNode_Range,                    "range",                        _("Range"),                    RELEASE_VERSION_0_61_07); // SVN r776
163
164         ADD_VALUENODE(ValueNode_Switch,                   "switch",                       _("Switch"),                   RELEASE_VERSION_0_61_08); // SVN r923
165         ADD_VALUENODE(ValueNode_Cos,                      "cos",                          _("Cos"),                              RELEASE_VERSION_0_61_08); // SVN r1111
166         ADD_VALUENODE(ValueNode_Atan2,                    "atan2",                        _("aTan2"),                    RELEASE_VERSION_0_61_08); // SVN r1132
167         ADD_VALUENODE(ValueNode_BLineRevTangent,  "blinerevtangent",  _("Reverse Tangent"),      RELEASE_VERSION_0_61_08); // SVN r1162
168         ADD_VALUENODE(ValueNode_TimeLoop,                 "timeloop",             _("Time Loop"),                RELEASE_VERSION_0_61_08); // SVN r1226
169         ADD_VALUENODE(ValueNode_Reciprocal,               "reciprocal",           _("Reciprocal"),               RELEASE_VERSION_0_61_08); // SVN r1238
170         ADD_VALUENODE(ValueNode_Duplicate,                "duplicate",            _("Duplicate"),                RELEASE_VERSION_0_61_08); // SVN r1267
171         ADD_VALUENODE(ValueNode_Integer,                  "fromint",              _("From Integer"),     RELEASE_VERSION_0_61_08); // SVN r1267
172         ADD_VALUENODE(ValueNode_Step,                     "step",                         _("Step"),                     RELEASE_VERSION_0_61_08); // SVN r1691
173         ADD_VALUENODE(ValueNode_BLineCalcWidth,   "blinecalcwidth",       _("BLine Width"),              RELEASE_VERSION_0_61_08); // SVN r1694
174
175         ADD_VALUENODE(ValueNode_VectorAngle,      "vectorangle",          _("Vector Angle"),     RELEASE_VERSION_0_61_09); // SVN r1880
176         ADD_VALUENODE(ValueNode_VectorLength,     "vectorlength",         _("Vector Length"),    RELEASE_VERSION_0_61_09); // SVN r1881
177         ADD_VALUENODE(ValueNode_VectorX,                  "vectorx",              _("Vector X"),                 RELEASE_VERSION_0_61_09); // SVN r1882
178         ADD_VALUENODE(ValueNode_VectorY,                  "vectory",              _("Vector Y"),                 RELEASE_VERSION_0_61_09); // SVN r1882
179         ADD_VALUENODE(ValueNode_GradientColor,    "gradientcolor",        _("Gradient Color"),   RELEASE_VERSION_0_61_09); // SVN r1885
180         ADD_VALUENODE(ValueNode_DotProduct,               "dotproduct",           _("Dot Product"),              RELEASE_VERSION_0_61_09); // SVN r1891
181         ADD_VALUENODE(ValueNode_TimeString,               "timestring",           _("Time String"),              RELEASE_VERSION_0_61_09); // SVN r2000
182         ADD_VALUENODE(ValueNode_RealString,               "realstring",           _("Real String"),              RELEASE_VERSION_0_61_09); // SVN r2003
183         ADD_VALUENODE(ValueNode_Join,                     "join",                         _("Joined List"),              RELEASE_VERSION_0_61_09); // SVN r2007
184         ADD_VALUENODE(ValueNode_AngleString,      "anglestring",          _("Angle String"),     RELEASE_VERSION_0_61_09); // SVN r2010
185         ADD_VALUENODE(ValueNode_IntString,                "intstring",            _("Int String"),               RELEASE_VERSION_0_61_09); // SVN r2010
186         ADD_VALUENODE(ValueNode_Logarithm,                "logarithm",            _("Logarithm"),                RELEASE_VERSION_0_61_09); // SVN r2034
187
188         ADD_VALUENODE(ValueNode_Greyed,                   "greyed",                       _("Greyed"),                   RELEASE_VERSION_0_61_10); // SVN r2305
189         ADD_VALUENODE(ValueNode_Pow,                  "power",                _("Power"),                    RELEASE_VERSION_0_61_10); // SVN r2362
190         ADD_VALUENODE(ValueNode_Compare,                  "compare",              _("Compare"),                  RELEASE_VERSION_0_61_10); // SVN r2364
191         ADD_VALUENODE(ValueNode_Not,                  "not",                      _("Not"),                              RELEASE_VERSION_0_61_10); // SVN r2364
192         ADD_VALUENODE(ValueNode_And,                  "and",                      _("And"),                              RELEASE_VERSION_0_61_10); // SVN r2364
193         ADD_VALUENODE(ValueNode_Or,                       "or",                   _("Or"),                                       RELEASE_VERSION_0_61_10); // SVN r2364
194
195 #undef ADD_VALUENODE
196 #undef ADD_VALUENODE2
197
198         return true;
199 }
200
201 bool
202 ValueNode::subsys_stop()
203 {
204         delete book_;
205 /*      if(global_value_node_map.size() || value_node_count)
206         {
207                 if(value_node_count)
208                         synfig::error("%d ValueNodes haven't been destroyed yet!",value_node_count);
209
210                 if(global_value_node_map.size()!=value_node_count)
211                         synfig::error("value node count mismatch! map.size()!=value_node_count (%d!=%d)",global_value_node_map.size(),value_node_count);
212
213                 GlobalValueNodeMap::iterator iter;
214                 for(iter=global_value_node_map.begin();iter!=global_value_node_map.end();++iter)
215                 {
216                         if(!iter->second->is_exported())
217                                 synfig::info(_("%s: count:%d name:%s type:%s"),
218                                         iter->first.get_string().c_str(),
219                                         iter->second->count(),
220                                         iter->second->get_name().c_str(),
221                                         ValueBase::type_local_name(iter->second->get_type()).c_str()
222                                 );
223                         else
224                                 synfig::info(_("%s: id:%s count:%d name:%s type:%s"),
225                                         iter->first.get_string().c_str(),
226                                         iter->second->get_id().c_str(),
227                                         iter->second->count(),
228                                         iter->second->get_name().c_str(),
229                                         ValueBase::type_local_name(iter->second->get_type()).c_str()
230                                 );
231                 }
232         }
233 */
234         return true;
235 }
236
237 ValueNode::ValueNode(ValueBase::Type type):type(type)
238 {
239         value_node_count++;
240 }
241
242 LinkableValueNode::Book&
243 LinkableValueNode::book()
244 {
245         return *book_;
246 }
247
248 LinkableValueNode::Handle
249 LinkableValueNode::create(const String &name, const ValueBase& x)
250 {
251         if(!book().count(name))
252                 return 0;
253
254         if (!check_type(name, x.get_type()) &&
255                 // the Duplicate ValueNode is an exception - we don't want the
256                 // user creating it for themselves, so check_type() fails for
257                 // it even when it is valid
258                 !(name == "duplicate" && x.get_type() == ValueBase::TYPE_REAL))
259         {
260                 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());
261                 return 0;
262         }
263
264         return book()[name].factory(x);
265 }
266
267 bool
268 LinkableValueNode::check_type(const String &name, ValueBase::Type x)
269 {
270         if(!book().count(name) || !book()[name].check_type)
271                 return false;
272         return book()[name].check_type(x);
273 }
274
275 bool
276 LinkableValueNode::set_link(int i,ValueNode::Handle x)
277 {
278         ValueNode::Handle previous(get_link(i));
279
280         if(set_link_vfunc(i,x))
281         {
282                 // Fix 2412072: remove the previous link from the parent_set unless one of the other links is also
283                 // using it when we convert a value to 'switch', both 'on' and 'off' are linked to the same valuenode
284                 // if we then disconnect one of the two, the one we disconnect is set to be a new valuenode_const
285                 // and the previously shared value is removed from the parent set even though the other is still
286                 // using it
287                 if(previous)
288                 {
289                         int size = link_count(), index;
290                         for (index=0; index < size; ++index)
291                         {
292                                 if (i == index) continue;
293                                 if (get_link(index) == previous)
294                                         break;
295                         }
296                         if (index == size)
297                                 remove_child(previous.get());
298                 }
299                 add_child(x.get());
300
301                 if(!x->is_exported() && get_parent_canvas())
302                 {
303                         x->set_parent_canvas(get_parent_canvas());
304                 }
305                 changed();
306                 return true;
307         }
308         return false;
309 }
310
311 ValueNode::LooseHandle
312 LinkableValueNode::get_link(int i)const
313 {
314         return get_link_vfunc(i);
315 }
316
317 void
318 LinkableValueNode::unlink_all()
319 {
320         for(int i=0;i<link_count();i++)
321         {
322                 ValueNode::LooseHandle value_node(get_link(i));
323                 if(value_node)
324                         value_node->parent_set.erase(this);
325         }
326 }
327
328 ValueNode::~ValueNode()
329 {
330         value_node_count--;
331
332         begin_delete();
333 }
334
335 void
336 ValueNode::on_changed()
337 {
338         etl::loose_handle<Canvas> parent_canvas = get_parent_canvas();
339         if(parent_canvas)
340                 do                                              // signal to all the ancestor canvases
341                         parent_canvas->signal_value_node_changed()(this);
342                 while (parent_canvas = parent_canvas->parent());
343         else if(get_root_canvas())
344                 get_root_canvas()->signal_value_node_changed()(this);
345
346         Node::on_changed();
347 }
348
349 int
350 ValueNode::replace(etl::handle<ValueNode> x)
351 {
352         if(x.get()==this)
353                 return 0;
354
355         while(parent_set.size())
356         {
357                 (*parent_set.begin())->add_child(x.get());
358                 (*parent_set.begin())->remove_child(this);
359                 //x->parent_set.insert(*parent_set.begin());
360                 //parent_set.erase(parent_set.begin());
361         }
362         int r(RHandle(this).replace(x));
363         x->changed();
364         return r;
365 }
366
367 void
368 ValueNode::set_id(const String &x)
369 {
370         if(name!=x)
371         {
372                 name=x;
373                 signal_id_changed_();
374         }
375 }
376
377 String
378 ValueNode::get_description(bool show_exported_name)const
379 {
380         String ret(_("ValueNode"));
381
382         if (dynamic_cast<const LinkableValueNode*>(this))
383                 return (dynamic_cast<const LinkableValueNode*>(this))->get_description(-1, show_exported_name);
384
385         if (show_exported_name && !is_exported())
386                 show_exported_name = false;
387
388         if (show_exported_name)
389                 ret += strprintf(" (%s)", get_id().c_str());
390
391         return ret;
392 }
393
394 ValueNodeList::ValueNodeList():
395         placeholder_count_(0)
396 {
397 }
398
399 bool
400 ValueNodeList::count(const String &id)const
401 {
402         const_iterator iter;
403
404         if(id.empty())
405                 return false;
406
407         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter)
408                 ;
409
410         if(iter==end())
411                 return false;
412
413         return true;
414 }
415
416 ValueNode::Handle
417 ValueNodeList::find(const String &id)
418 {
419         iterator iter;
420
421         if(id.empty())
422                 throw Exception::IDNotFound("Empty ID");
423
424         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter)
425                 ;
426
427         if(iter==end())
428                 throw Exception::IDNotFound("ValueNode in ValueNodeList: "+id);
429
430         return *iter;
431 }
432
433 ValueNode::ConstHandle
434 ValueNodeList::find(const String &id)const
435 {
436         const_iterator iter;
437
438         if(id.empty())
439                 throw Exception::IDNotFound("Empty ID");
440
441         for(iter=begin();iter!=end() && id!=(*iter)->get_id();++iter)
442                 ;
443
444         if(iter==end())
445                 throw Exception::IDNotFound("ValueNode in ValueNodeList: "+id);
446
447         return *iter;
448 }
449
450 ValueNode::Handle
451 ValueNodeList::surefind(const String &id)
452 {
453         if(id.empty())
454                 throw Exception::IDNotFound("Empty ID");
455
456         ValueNode::Handle value_node;
457
458         try
459         {
460                 value_node=find(id);
461         }
462         catch(Exception::IDNotFound)
463         {
464                 value_node=PlaceholderValueNode::create();
465                 value_node->set_id(id);
466                 push_back(value_node);
467                 placeholder_count_++;
468         }
469
470         return value_node;
471 }
472
473 bool
474 ValueNodeList::erase(ValueNode::Handle value_node)
475 {
476         assert(value_node);
477
478         iterator iter;
479
480         for(iter=begin();iter!=end();++iter)
481                 if(value_node.get()==iter->get())
482                 {
483                         std::list<ValueNode::RHandle>::erase(iter);
484                         if(PlaceholderValueNode::Handle::cast_dynamic(value_node))
485                                 placeholder_count_--;
486                         return true;
487                 }
488         return false;
489 }
490
491 bool
492 ValueNodeList::add(ValueNode::Handle value_node)
493 {
494         if(!value_node)
495                 return false;
496         if(value_node->get_id().empty())
497                 return false;
498
499         try
500         {
501                 ValueNode::RHandle other_value_node=find(value_node->get_id());
502                 if(PlaceholderValueNode::Handle::cast_dynamic(other_value_node))
503                 {
504                         other_value_node->replace(value_node);
505                         placeholder_count_--;
506                         return true;
507                 }
508
509                 return false;
510         }
511         catch(Exception::IDNotFound)
512         {
513                 push_back(value_node);
514                 return true;
515         }
516
517         return false;
518 }
519
520 void
521 ValueNodeList::audit()
522 {
523         iterator iter,next;
524
525         for(next=begin(),iter=next++;iter!=end();iter=next++)
526                 if(iter->count()==1)
527                         std::list<ValueNode::RHandle>::erase(iter);
528 }
529
530
531 String
532 PlaceholderValueNode::get_name()const
533 {
534         return "placeholder";
535 }
536
537 String
538 PlaceholderValueNode::get_local_name()const
539 {
540         return _("Placeholder");
541 }
542
543 ValueNode*
544 PlaceholderValueNode::clone(const GUID& deriv_guid)const
545 {
546         ValueNode* ret(new PlaceholderValueNode());
547         ret->set_guid(get_guid()^deriv_guid);
548         return ret;
549 }
550
551 PlaceholderValueNode::Handle
552 PlaceholderValueNode::create(ValueBase::Type type)
553 {
554         return new PlaceholderValueNode(type);
555 }
556
557 ValueBase
558 PlaceholderValueNode::operator()(Time /*t*/)const
559 {
560         assert(0);
561         return ValueBase();
562 }
563
564 PlaceholderValueNode::PlaceholderValueNode(ValueBase::Type type):
565         ValueNode(type)
566 {
567 }
568
569 ValueNode*
570 LinkableValueNode::clone(const GUID& deriv_guid)const
571 {
572         {
573                 ValueNode* x(find_value_node(get_guid()^deriv_guid).get());
574                 if(x)
575                         return x;
576         }
577
578         int i;
579         LinkableValueNode *ret=create_new();
580         ret->set_guid(get_guid()^deriv_guid);
581
582         for(i=0;i<link_count();i++)
583         {
584                 ValueNode::Handle link=get_link_vfunc(i);
585                 if(!link->is_exported())
586                 {
587                         ValueNode::LooseHandle value_node(find_value_node(link->get_guid()^deriv_guid));
588                         if(!value_node)
589                                 value_node=link->clone(deriv_guid);
590                         ret->set_link(i,value_node);
591                 }
592                 else
593                         ret->set_link(i,link);
594         }
595
596         return ret;
597 }
598
599 String
600 ValueNode::get_relative_id(etl::loose_handle<const Canvas> x)const
601 {
602         assert(is_exported());
603         assert(canvas_);
604
605         if(x.get()==canvas_.get())
606                 return get_id();
607
608         return canvas_->_get_relative_id(x)+':'+get_id();
609 }
610
611 void
612 ValueNode::set_parent_canvas(etl::loose_handle<Canvas> x)
613 {
614         canvas_=x; if(x) root_canvas_=x->get_root();
615 }
616
617 void
618 ValueNode::set_root_canvas(etl::loose_handle<Canvas> x)
619 {
620         root_canvas_=x->get_root();
621 }
622
623 void LinkableValueNode::get_times_vfunc(Node::time_set &set) const
624 {
625         ValueNode::LooseHandle  h;
626
627         int size = link_count();
628
629         //just add it to the set...
630         for(int i=0; i < size; ++i)
631         {
632                 h = get_link(i);
633
634                 if(h)
635                 {
636                         const Node::time_set &tset = h->get_times();
637                         set.insert(tset.begin(),tset.end());
638                 }
639         }
640 }
641
642 String
643 LinkableValueNode::get_description(int index, bool show_exported_name)const
644 {
645         String description;
646
647         if (index == -1)
648         {
649                 if (show_exported_name && is_exported())
650                         description += strprintf(" (%s)", get_id().c_str());
651         }
652         else
653         {
654                 description = String(":") + link_local_name(index);
655
656                 if (show_exported_name)
657                 {
658                         ValueNode::LooseHandle link(get_link(index));
659                         if (link->is_exported())
660                                 description += strprintf(" (%s)", link->get_id().c_str());
661                 }
662         }
663
664         const synfig::Node* node = this;
665         LinkableValueNode::ConstHandle parent_linkable_vn = 0;
666
667         // walk up through the valuenodes trying to find the layer at the top
668         while (!node->parent_set.empty() && !dynamic_cast<const Layer*>(node))
669         {
670                 LinkableValueNode::ConstHandle linkable_value_node(dynamic_cast<const LinkableValueNode*>(node));
671                 if (linkable_value_node)
672                 {
673                         String link;
674                         int cnt = linkable_value_node->link_count();
675                         for (int i = 0; i < cnt; i++)
676                                 if (linkable_value_node->get_link(i) == parent_linkable_vn)
677                                 {
678                                         link = String(":") + linkable_value_node->link_local_name(i);
679                                         break;
680                                 }
681
682                         description = linkable_value_node->get_local_name() + link + (parent_linkable_vn?">":"") + description;
683                 }
684                 node = *node->parent_set.begin();
685                 parent_linkable_vn = linkable_value_node;
686         }
687
688         Layer::ConstHandle parent_layer(dynamic_cast<const Layer*>(node));
689         if(parent_layer)
690         {
691                 String param;
692                 const Layer::DynamicParamList &dynamic_param_list(parent_layer->dynamic_param_list());
693                 // loop to find the parameter in the dynamic parameter list - this gives us its name
694                 for (Layer::DynamicParamList::const_iterator iter = dynamic_param_list.begin(); iter != dynamic_param_list.end(); iter++)
695                         if (iter->second == parent_linkable_vn)
696                                 param = String(":") + parent_layer->get_param_local_name(iter->first);
697                 description = strprintf("(%s)%s>%s",
698                                                                 parent_layer->get_non_empty_description().c_str(),
699                                                                 param.c_str(),
700                                                                 description.c_str());
701         }
702
703         return description;
704 }