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