synfig-core/trunk/src/synfig/value.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file value.cpp
   3 **      \brief Template Header
   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 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "value.h"
  34 #include "general.h"
  35 #include <ETL/stringf>
  36 #include "canvas.h"
  37 #include "gradient.h"
  38
  39
  40
  41 #include "vector.h"
  42 #include "time.h"
  43 #include "segment.h"
  44 #include "color.h"
  45
  46 #endif
  47
  48 using namespace synfig;
  49 using namespace std;
  50 using namespace etl;
  51
  52 /* === M A C R O S ========================================================= */
  53
  54 /* === G L O B A L S ======================================================= */
  55
  56 /* === P R O C E D U R E S ================================================= */
  57
  58 /* === M E T H O D S ======================================================= */
  59
  60 ValueBase::ValueBase():type(TYPE_NIL),data(0),ref_count(0),loop_(0)
  61 {
  62 }
  63
  64 ValueBase::ValueBase(Type x):
  65         type(x),
  66         data(0),
  67         loop_(0)
  68 {
  69         switch(type)
  70         {
  71         case TYPE_BOOL:                 data=static_cast<void*>(new bool());                            break;
  72         case TYPE_INTEGER:              data=static_cast<void*>(new int());                                     break;
  73         case TYPE_ANGLE:                data=static_cast<void*>(new Angle());                           break;
  74         case TYPE_VECTOR:               data=static_cast<void*>(new Vector());                          break;
  75         case TYPE_TIME:                 data=static_cast<void*>(new Time());                            break;
  76         case TYPE_REAL:                 data=static_cast<void*>(new Real());                            break;
  77         case TYPE_COLOR:                data=static_cast<void*>(new Color());                           break;
  78         case TYPE_SEGMENT:              data=static_cast<void*>(new Segment());                         break;
  79         case TYPE_BLINEPOINT:   data=static_cast<void*>(new BLinePoint());                      break;
  80         case TYPE_LIST:                 data=static_cast<void*>(new list_type());                       break;
  81         case TYPE_STRING:               data=static_cast<void*>(new String());                          break;
  82         case TYPE_GRADIENT:             data=static_cast<void*>(new Gradient());                        break;
  83         case TYPE_CANVAS:               data=static_cast<void*>(new etl::handle<Canvas>());     break;
  84         default:                                                                                                                                        break;
  85         }
  86 }
  87
  88 ValueBase::~ValueBase()
  89 {
  90         clear();
  91 }
  92
  93 const char*
  94 ValueBase::get(const char*)const
  95 {
  96         return get(String()).c_str();
  97 }
  98
  99 #ifdef _DEBUG
 100 String
 101 ValueBase::get_string() const
 102 {
 103         switch(type)
 104         {
 105         case TYPE_NIL:                  return "Nil";
 106         case TYPE_BOOL:                 return strprintf("Bool (%s)", get(bool()) ? "true" : "false");
 107         case TYPE_INTEGER:              return strprintf("Integer (%s)", get(int()));
 108         case TYPE_ANGLE:                return strprintf("Angle (%.2f)", Angle::deg(get(Angle())).get());
 109
 110                 // All types after this point are larger than 32 bits
 111
 112         case TYPE_TIME:                 return strprintf("Time (%s)", get(Time()).get_string().c_str());
 113         case TYPE_REAL:                 return strprintf("Real (%f)", get(Real()));
 114
 115                 // All types after this point are larger than 64 bits
 116
 117         case TYPE_VECTOR:               return strprintf("Vector (%f, %f)", get(Vector())[0], get(Vector())[1]);
 118         case TYPE_COLOR:                return strprintf("Color (%s)", get(Color()).get_string().c_str());
 119         case TYPE_SEGMENT:              return strprintf("Segment ((%f, %f) to (%f, %f))", get(Segment()).p1[0], get(Segment()).p1[1], get(Segment()).p2[0], get(Segment()).p2[1]);
 120         case TYPE_BLINEPOINT:   return strprintf("BLinePoint (%s)", get(BLinePoint()).get_vertex()[0], get(BLinePoint()).get_vertex()[1]);
 121
 122                 // All types after this point require construction/destruction
 123
 124         case TYPE_LIST:                 return strprintf("List (%d elements)", get(list_type()).size());
 125         case TYPE_CANVAS:               return strprintf("Canvas (%s)", get(etl::loose_handle<Canvas>())->get_id().c_str());
 126         case TYPE_STRING:               return strprintf("String (%s)", get(String()).c_str());
 127         case TYPE_GRADIENT:             return strprintf("Gradient (%d cpoints)", get(Gradient()).size());
 128         default:                                return "Invalid type";
 129         }
 130 }
 131 #endif  // _DEBUG
 132
 133 void
 134 ValueBase::set(Canvas* x)
 135 {
 136         clear();
 137         if(x && x->is_inline())
 138         {
 139                 _set(etl::handle<Canvas>(x));
 140         }
 141         else
 142         {
 143                 _set(etl::loose_handle<Canvas>(x));
 144         }
 145         assert(get(x)==x);
 146 }
 147
 148 void
 149 ValueBase::set(etl::loose_handle<Canvas> x)
 150 {
 151         clear();
 152         if(x && x->is_inline())
 153                 _set(etl::handle<Canvas>(x));
 154         else
 155                 _set(etl::loose_handle<Canvas>(x));
 156         assert(get(x)==x);
 157 }
 158
 159 void
 160 ValueBase::set(etl::handle<Canvas> x)
 161 {
 162         clear();
 163         if(x && x->is_inline())
 164                 _set(etl::handle<Canvas>(x));
 165         else
 166                 _set(etl::loose_handle<Canvas>(x));
 167         assert(get(x)==x);
 168 }
 169
 170 void
 171 ValueBase::set(const list_type &x)
 172 {
 173         _set(x);
 174 }
 175
 176 void
 177 ValueBase::set(const char* x)
 178 {
 179         _set(String(x));
 180 }
 181
 182 void
 183 ValueBase::set(char* x)
 184 {
 185         _set(String(x));
 186 }
 187
 188 bool
 189 ValueBase::is_valid()const
 190 {
 191         return type>TYPE_NIL && type<TYPE_END && ref_count;
 192 }
 193
 194 bool
 195 ValueBase::empty()const
 196 {
 197         return !is_valid() || ((type==TYPE_LIST)?get_list().empty():false);
 198 }
 199
 200 ValueBase::Type
 201 ValueBase::get_contained_type()const
 202 {
 203         if(type!=TYPE_LIST || empty())
 204                 return TYPE_NIL;
 205         return get_list().front().get_type();
 206 }
 207
 208 ValueBase&
 209 ValueBase::operator=(const ValueBase& x)
 210 {
 211         if(data!=x.data)
 212         {
 213                 clear();
 214                 type=x.type;
 215                 data=x.data;
 216                 ref_count=x.ref_count;
 217         }
 218         loop_=x.loop_;
 219         return *this;
 220 }
 221
 222 void
 223 ValueBase::clear()
 224 {
 225         if(ref_count.unique() && data)
 226         {
 227                 switch(type)
 228                 {
 229                 case TYPE_BOOL:                 delete static_cast<bool*>(data);                break;
 230                 case TYPE_INTEGER:              delete static_cast<int*>(data);                 break;
 231                 case TYPE_ANGLE:                delete static_cast<Angle*>(data);               break;
 232                 case TYPE_TIME:                 delete static_cast<Time*>(data);                break;
 233                 case TYPE_REAL:                 delete static_cast<Real*>(data);                break;
 234                 case TYPE_VECTOR:               delete static_cast<Vector*>(data);              break;
 235                 case TYPE_COLOR:                delete static_cast<Color*>(data);               break;
 236                 case TYPE_SEGMENT:              delete static_cast<Segment*>(data);             break;
 237                 case TYPE_BLINEPOINT:   delete static_cast<BLinePoint*>(data);  break;
 238                 case TYPE_LIST:                 delete static_cast<list_type*>(data);   break;
 239                 case TYPE_CANVAS:
 240                 {
 241                         etl::handle<Canvas> canvas(get(etl::loose_handle<Canvas>()));
 242                         if(canvas && canvas->is_inline())
 243                                 delete static_cast<etl::handle<Canvas>*>(data);
 244                         else
 245                                 delete static_cast<etl::loose_handle<Canvas>*>(data);
 246                         break;
 247                 }
 248                 case TYPE_STRING:               delete static_cast<String*>(data);              break;
 249                 case TYPE_GRADIENT:             delete static_cast<Gradient*>(data);    break;
 250                 default:
 251                         break;
 252                 }
 253         }
 254
 255         ref_count.detach();
 256         data=0;
 257         type=TYPE_NIL;
 258 }
 259
 260
 261 String
 262 ValueBase::type_name(Type id)
 263 {
 264         // don't internationalize these type names - they're using in .sif files
 265         switch(id)
 266         {
 267                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 268         case TYPE_BOOL:                 return N_("bool");
 269                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 270         case TYPE_INTEGER:              return N_("integer");
 271                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 272         case TYPE_ANGLE:                return N_("angle");
 273                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 274         case TYPE_TIME:                 return N_("time");
 275                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 276         case TYPE_REAL:                 return N_("real");
 277                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 278         case TYPE_VECTOR:               return N_("vector");
 279                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 280         case TYPE_COLOR:                return N_("color");
 281                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 282         case TYPE_SEGMENT:              return N_("segment");
 283                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 284         case TYPE_BLINEPOINT:   return N_("bline_point");
 285                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 286         case TYPE_LIST:                 return N_("list");
 287                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 288         case TYPE_CANVAS:               return N_("canvas");
 289                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 290         case TYPE_STRING:               return N_("string");
 291                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 292         case TYPE_GRADIENT:             return N_("gradient");
 293                 /* TRANSLATORS: this is the name of a type -- see http://synfig.org/Types */
 294         case TYPE_NIL:                  return N_("nil");
 295         default:
 296                 break;
 297         }
 298         synfig::warning("Encountered unknown ValueBase with an Type of %d",id);
 299 //      assert(0);
 300         return "UNKNOWN";
 301 }
 302
 303 String
 304 ValueBase::type_local_name(Type id)
 305 {
 306         return dgettext("synfig",type_name(id).c_str());
 307 }
 308
 309 ValueBase::Type
 310 ValueBase::ident_type(const String &str)
 311 {
 312         if(str=="nil" ||
 313            str=="null")                         return TYPE_NIL;
 314         else if(str=="time" ||
 315                         str==_("time"))         return TYPE_TIME;
 316         else if(str=="real" ||
 317                         str=="float" ||
 318                         str==_("real"))         return TYPE_REAL;
 319         else if(str=="integer" ||
 320                         str=="int" ||
 321                         str==_("integer"))      return TYPE_INTEGER;
 322         else if(str=="bool" ||
 323                         str==_("bool"))         return TYPE_BOOL;
 324         else if(str=="angle" ||
 325                         str=="degrees" ||
 326                         str=="radians" ||
 327                         str=="rotations")       return TYPE_ANGLE;
 328         else if(str=="vector" ||
 329                         str=="point")           return TYPE_VECTOR;
 330         else if(str=="color")           return TYPE_COLOR;
 331         else if(str=="string")          return TYPE_STRING;
 332         else if(str=="canvas")          return TYPE_CANVAS;
 333         else if(str=="list")            return TYPE_LIST;
 334         else if(str=="segment")         return TYPE_SEGMENT;
 335         else if(str=="gradient")        return TYPE_GRADIENT;
 336         else if(str=="bline_point" ||
 337                         str=="blinepoint")      return TYPE_BLINEPOINT;
 338
 339         return TYPE_NIL;
 340 }
 341
 342 bool
 343 ValueBase::operator==(const ValueBase& rhs)const
 344 {
 345         if(get_type()!=rhs.get_type())
 346                 return false;
 347         if(data==rhs.data)
 348                 return true;
 349
 350         switch(get_type())
 351         {
 352         case TYPE_TIME:                    return get(Time()).is_equal(rhs.get(Time()));
 353         case TYPE_REAL:                    return abs(get(Real())-rhs.get(Real()))<=0.00000000000001;
 354         case TYPE_INTEGER:                 return get(int())==rhs.get(int());
 355         case TYPE_BOOL:                    return get(bool())==rhs.get(bool());
 356         case TYPE_ANGLE:                   return get(Angle())==rhs.get(Angle());
 357         case TYPE_VECTOR:                  return get(Vector()).is_equal_to(rhs.get(Vector()));
 358         case TYPE_COLOR:                   return get(Color())==rhs.get(Color());
 359         case TYPE_STRING:                  return get(String())==rhs.get(String());
 360         case TYPE_CANVAS:                  return get(Canvas::LooseHandle())==rhs.get(Canvas::LooseHandle());
 361         case TYPE_LIST:                    return get_list()==rhs.get_list();
 362         case TYPE_SEGMENT:              // return get(Segment())==rhs.get(Segment());
 363         case TYPE_GRADIENT:             // return get(Gradient())==rhs.get(Gradient());
 364         case TYPE_BLINEPOINT:   // return get(BLinePoint())==rhs.get(BLinePoint());
 365         case TYPE_NIL:
 366         default:                                   return false;
 367         }
 368         return false;
 369 }