synfig-core/src/synfig/valuenode_composite.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file valuenode_composite.cpp
   3 **      \brief Implementation of the "Composite" valuenode conversion.
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 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 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "valuenode_composite.h"
  34 #include "valuenode_const.h"
  35 #include <stdexcept>
  36 #include "general.h"
  37 #include "valuenode_radialcomposite.h"
  38 #include "vector.h"
  39 #include "color.h"
  40 #include "segment.h"
  41 #include "savecanvas.h"
  42
  43 #endif
  44
  45 /* === U S I N G =========================================================== */
  46
  47 using namespace std;
  48 using namespace etl;
  49 using namespace synfig;
  50
  51 /* === M A C R O S ========================================================= */
  52
  53 /* === G L O B A L S ======================================================= */
  54
  55 /* === P R O C E D U R E S ================================================= */
  56
  57 /* === M E T H O D S ======================================================= */
  58
  59 synfig::ValueNode_Composite::ValueNode_Composite(const ValueBase &value):
  60         LinkableValueNode(value.get_type())
  61 {
  62         switch(get_type())
  63         {
  64                 case ValueBase::TYPE_VECTOR:
  65                         set_link("x",ValueNode_Const::create(value.get(Vector())[0]));
  66                         set_link("y",ValueNode_Const::create(value.get(Vector())[1]));
  67                         break;
  68                 case ValueBase::TYPE_COLOR:
  69                         set_link("r",ValueNode_Const::create(value.get(Color()).get_r()));
  70                         set_link("g",ValueNode_Const::create(value.get(Color()).get_g()));
  71                         set_link("b",ValueNode_Const::create(value.get(Color()).get_b()));
  72                         set_link("a",ValueNode_Const::create(value.get(Color()).get_a()));
  73                         break;
  74                 case ValueBase::TYPE_SEGMENT:
  75                         set_link("p1",ValueNode_Const::create(value.get(Segment()).p1));
  76                         set_link("t1",ValueNode_Const::create(value.get(Segment()).t1));
  77                         set_link("p2",ValueNode_Const::create(value.get(Segment()).p2));
  78                         set_link("t2",ValueNode_Const::create(value.get(Segment()).t2));
  79                         break;
  80                 case ValueBase::TYPE_BLINEPOINT:
  81                 {
  82                         BLinePoint bline_point(value);
  83                         set_link(0,ValueNode_Const::create(bline_point.get_vertex()));
  84                         set_link(1,ValueNode_Const::create(bline_point.get_width()));
  85                         set_link(2,ValueNode_Const::create(bline_point.get_origin()));
  86                         set_link(3,ValueNode_Const::create(bline_point.get_split_tangent_flag()));
  87                         set_link(4,ValueNode_RadialComposite::create(bline_point.get_tangent1()));
  88                         set_link(5,ValueNode_RadialComposite::create(bline_point.get_tangent2()));
  89                         break;
  90                 }
  91                 default:
  92                         assert(0);
  93                         throw Exception::BadType(ValueBase::type_local_name(get_type()));
  94         }
  95 }
  96
  97 ValueNode_Composite::~ValueNode_Composite()
  98 {
  99         unlink_all();
 100 }
 101
 102 ValueNode_Composite*
 103 ValueNode_Composite::create(const ValueBase &value)
 104 {
 105         return new ValueNode_Composite(value);
 106 }
 107
 108 LinkableValueNode*
 109 ValueNode_Composite::create_new()const
 110 {
 111         return new ValueNode_Composite(ValueBase(get_type()));
 112 }
 113
 114 ValueBase
 115 synfig::ValueNode_Composite::operator()(Time t)const
 116 {
 117         if (getenv("SYNFIG_DEBUG_VALUENODE_OPERATORS"))
 118                 printf("%s:%d operator()\n", __FILE__, __LINE__);
 119
 120         switch(get_type())
 121         {
 122                 case ValueBase::TYPE_VECTOR:
 123                 {
 124                         Vector vect;
 125                         assert(components[0] && components[1]);
 126                         vect[0]=(*components[0])(t).get(Vector::value_type());
 127                         vect[1]=(*components[1])(t).get(Vector::value_type());
 128                         return vect;
 129                 }
 130                 case ValueBase::TYPE_COLOR:
 131                 {
 132                         Color color;
 133                         assert(components[0] && components[1] && components[2] && components[3]);
 134                         color.set_r((*components[0])(t).get(Vector::value_type()));
 135                         color.set_g((*components[1])(t).get(Vector::value_type()));
 136                         color.set_b((*components[2])(t).get(Vector::value_type()));
 137                         color.set_a((*components[3])(t).get(Vector::value_type()));
 138                         return color;
 139                 }
 140                 case ValueBase::TYPE_SEGMENT:
 141                 {
 142                         Segment seg;
 143                         assert(components[0] && components[1] && components[2] && components[3]);
 144                         seg.p1=(*components[0])(t).get(Point());
 145                         seg.t1=(*components[1])(t).get(Vector());
 146                         seg.p2=(*components[2])(t).get(Point());
 147                         seg.t2=(*components[3])(t).get(Vector());
 148                         return seg;
 149                 }
 150                 case ValueBase::TYPE_BLINEPOINT:
 151                 {
 152                         BLinePoint ret;
 153                         assert(components[0] && components[1] && components[2] && components[3] && components[4] && components[5]);
 154                         ret.set_vertex((*components[0])(t).get(Point()));
 155                         ret.set_width((*components[1])(t).get(Real()));
 156                         ret.set_origin((*components[2])(t).get(Real()));
 157                         ret.set_split_tangent_flag((*components[3])(t).get(bool()));
 158                         ret.set_tangent1((*components[4])(t).get(Vector()));
 159                         if(ret.get_split_tangent_flag())
 160                                 ret.set_tangent2((*components[5])(t).get(Vector()));
 161                         return ret;
 162                 }
 163                 default:
 164                         synfig::error(string("ValueNode_Composite::operator():")+_("Bad type for composite"));
 165                         assert(components[0]);
 166                         return (*components[0])(t);
 167         }
 168 }
 169
 170 int
 171 ValueNode_Composite::link_count()const
 172 {
 173         switch(get_type())
 174         {
 175         case ValueBase::TYPE_VECTOR:
 176                 return 2;
 177         case ValueBase::TYPE_COLOR:
 178                 return 4;
 179         case ValueBase::TYPE_SEGMENT:
 180                 return 4;
 181         case ValueBase::TYPE_BLINEPOINT:
 182                 return 6;
 183         default:
 184                 synfig::warning(string("ValueNode_Composite::component_count():")+_("Bad type for composite"));
 185                 return 1;
 186         }
 187 }
 188
 189 bool
 190 ValueNode_Composite::set_link_vfunc(int i,ValueNode::Handle x)
 191 {
 192         assert(i>=0 && i<link_count());
 193
 194         if(PlaceholderValueNode::Handle::cast_dynamic(x))
 195         {
 196                 components[i]=x;
 197                 return true;
 198         }
 199
 200         switch(get_type())
 201         {
 202                 case ValueBase::TYPE_VECTOR:
 203                         if(x->get_type()==ValueBase(Real()).get_type() || PlaceholderValueNode::Handle::cast_dynamic(x))
 204                         {
 205                                 components[i]=x;
 206                                 return true;
 207                         }
 208                         break;
 209
 210                 case ValueBase::TYPE_COLOR:
 211                         if(x->get_type()==ValueBase(Real()).get_type() || PlaceholderValueNode::Handle::cast_dynamic(x))
 212                         {
 213                                 components[i]=x;
 214                                 return true;
 215                         }
 216                         break;
 217
 218                 case ValueBase::TYPE_SEGMENT:
 219                         if(x->get_type()==ValueBase(Point()).get_type() || PlaceholderValueNode::Handle::cast_dynamic(x))
 220                         {
 221                                 components[i]=x;
 222                                 return true;
 223                         }
 224                         break;
 225
 226                 case ValueBase::TYPE_BLINEPOINT:
 227                         if((i==0 || i==4 || i==5) && x->get_type()==ValueBase(Point()).get_type())
 228                         {
 229                                 components[i]=x;
 230                                 return true;
 231                         }
 232                         if((i==1 || i==2) && x->get_type()==ValueBase(Real()).get_type())
 233                         {
 234                                 components[i]=x;
 235                                 return true;
 236                         }
 237                         if(i==3 && x->get_type()==ValueBase(bool()).get_type())
 238                         {
 239                                 components[i]=x;
 240                                 return true;
 241                         }
 242                         break;
 243
 244                 default:
 245                         break;
 246         }
 247         return false;
 248 }
 249
 250 ValueNode::LooseHandle
 251 ValueNode_Composite::get_link_vfunc(int i)const
 252 {
 253         assert(i>=0 && i<link_count());
 254
 255         return components[i];
 256 }
 257
 258 String
 259 ValueNode_Composite::link_local_name(int i)const
 260 {
 261         assert(i>=0 && i<link_count());
 262
 263         switch(get_type())
 264         {
 265                 case ValueBase::TYPE_VECTOR:
 266                         return strprintf("%c-Axis",'X'+i);
 267
 268                 case ValueBase::TYPE_COLOR:
 269                         if(i==0)
 270                                 return _("Red");
 271                         else if(i==1)
 272                                 return _("Green");
 273                         else if(i==2)
 274                                 return _("Blue");
 275                         else if(i==3)
 276                                 return _("Alpha");
 277
 278                 case ValueBase::TYPE_SEGMENT:
 279                         if(i==0)
 280                                 return _("Vertex 1");
 281                         else if(i==1)
 282                                 return _("Tangent 1");
 283                         else if(i==2)
 284                                 return _("Vertex 2");
 285                         else if(i==3)
 286                                 return _("Tangent 2");
 287
 288                 case ValueBase::TYPE_BLINEPOINT:
 289                         if(i==0)
 290                                 return _("Vertex");
 291                         else if(i==1)
 292                                 return _("Width");
 293                         else if(i==2)
 294                                 return _("Origin");
 295                         else if(i==3)
 296                                 return _("Split Tangents");
 297                         else if(i==4)
 298                                 return _("Tangent 1");
 299                         else if(i==5)
 300                                 return _("Tangent 2");
 301
 302                 default:
 303                         assert(0);
 304                         // notice that Composite counts from 1 and Radial Composite counts
 305                         // from 0!  we need to keep it like that to correctly load old
 306                         // animations, but let's not save "c%d" format link names in future
 307                         return etl::strprintf(_("C%d"),i+1);
 308         }
 309 }
 310
 311
 312 String
 313 ValueNode_Composite::link_name(int i)const
 314 {
 315         assert(i>=0 && i<link_count());
 316
 317         if (get_file_version() < RELEASE_VERSION_0_61_08)
 318                 return strprintf("c%d",i+1);
 319
 320         switch(get_type())
 321         {
 322         case ValueBase::TYPE_COLOR:
 323                 switch(i)
 324                 {
 325                 case 0: return "red";
 326                 case 1: return "green";
 327                 case 2: return "blue";
 328                 case 3: return "alpha";
 329                 }
 330                 break;
 331         case ValueBase::TYPE_SEGMENT:
 332                 switch(i)
 333                 {
 334                 case 0: return "p1";
 335                 case 1: return "t1";
 336                 case 2: return "p2";
 337                 case 3: return "t2";
 338                 }
 339                 break;
 340         case ValueBase::TYPE_VECTOR:
 341                 switch(i)
 342                 {
 343                 case 0: return "x";
 344                 case 1: return "y";
 345                 }
 346                 break;
 347         case ValueBase::TYPE_BLINEPOINT:
 348                 switch(i)
 349                 {
 350                 case 0: return "point";
 351                 case 1: return "width";
 352                 case 2: return "origin";
 353                 case 3: return "split";
 354                 case 4: return "t1";
 355                 case 5: return "t2";
 356                 }
 357                 break;
 358         default:
 359                 break;
 360         }
 361
 362         assert(0);
 363         // notice that Composite counts from 1 and Radial Composite counts
 364         // from 0!  we need to keep it like that to correctly load old
 365         // animations, but let's not save "c%d" format link names in future
 366         return strprintf("c%d",i+1);
 367 }
 368
 369 int
 370 ValueNode_Composite::get_link_index_from_name(const String &name)const
 371 {
 372         if(name.empty())
 373                 throw Exception::BadLinkName(name);
 374
 375         if(name[0]=='c' && name.size() == 2 && name[1]-'1' >= 0 && name[1]-'1' < link_count())
 376                 return name[1]-'1';
 377
 378         switch(get_type())
 379         {
 380         case ValueBase::TYPE_COLOR:
 381                 if(name[0]=='r')
 382                         return 0;
 383                 if(name[0]=='g')
 384                         return 1;
 385                 if(name[0]=='b')
 386                         return 2;
 387                 if(name[0]=='a')
 388                         return 3;
 389         case ValueBase::TYPE_SEGMENT:
 390                 if(name=="p1")
 391                         return 0;
 392                 if(name=="t1")
 393                         return 1;
 394                 if(name=="p2")
 395                         return 2;
 396                 if(name=="t2")
 397                         return 3;
 398         case ValueBase::TYPE_VECTOR:
 399                 if(name[0]=='x')
 400                         return 0;
 401                 if(name[0]=='y')
 402                         return 1;
 403                 if(name[0]=='z')                // \todo "z"?  really?
 404                         return 2;
 405         case ValueBase::TYPE_BLINEPOINT:
 406                 if(name[0]=='p' || name=="v1" || name=="p1")
 407                         return 0;
 408                 if(name=="w" || name=="width")
 409                         return 1;
 410                 if(name=="o" || name=="origin")
 411                         return 2;
 412                 if(name=="split")
 413                         return 3;
 414                 if(name=="t1")
 415                         return 4;
 416                 if(name=="t2")
 417                         return 5;
 418         default:
 419                 break;
 420         }
 421
 422         throw Exception::BadLinkName(name);
 423 }
 424
 425 String
 426 ValueNode_Composite::get_name()const
 427 {
 428         return "composite";
 429 }
 430
 431 String
 432 ValueNode_Composite::get_local_name()const
 433 {
 434         return _("Composite");
 435 }
 436
 437 bool
 438 ValueNode_Composite::check_type(ValueBase::Type type)
 439 {
 440         return
 441                 type==ValueBase::TYPE_SEGMENT ||
 442                 type==ValueBase::TYPE_VECTOR ||
 443                 type==ValueBase::TYPE_COLOR ||
 444                 type==ValueBase::TYPE_BLINEPOINT;
 445 }