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