synfig-studio/tags/stable/src/sinfgapp/action_param.cpp

   1 /* === S I N F G =========================================================== */
   2 /*!     \file action_param.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id: action_param.cpp,v 1.1.1.1 2005/01/07 03:34:37 darco Exp $
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002 Robert B. Quattlebaum Jr.
   9 **
  10 **      This software and associated documentation
  11 **      are CONFIDENTIAL and PROPRIETARY property of
  12 **      the above-mentioned copyright holder.
  13 **
  14 **      You may not copy, print, publish, or in any
  15 **      other way distribute this software without
  16 **      a prior written agreement with
  17 **      the copyright holder.
  18 **      \endlegal
  19 */
  20 /* ========================================================================= */
  21
  22 /* === H E A D E R S ======================================================= */
  23
  24 #ifdef USING_PCH
  25 #       include "pch.h"
  26 #else
  27 #ifdef HAVE_CONFIG_H
  28 #       include <config.h>
  29 #endif
  30
  31 #include "action_param.h"
  32 #include "action.h"
  33 #include "canvasinterface.h"
  34
  35 #endif
  36
  37 using namespace std;
  38 using namespace etl;
  39 using namespace sinfg;
  40 using namespace sinfgapp;
  41 using namespace Action;
  42
  43 /* === P R O C E D U R E S ================================================= */
  44
  45 bool
  46 Action::canidate_check(const ParamVocab& param_vocab, const ParamList& param_list)
  47 {
  48         ParamVocab::const_iterator iter;
  49
  50         for(iter=param_vocab.begin();iter!=param_vocab.end();++iter)
  51         {
  52                 int n(param_list.count(iter->get_name()));
  53
  54 //              if(n && !iter->get_mutual_exclusion().empty() && param_list.count(iter->get_mutual_exclusion()))
  55 //                      return false;
  56
  57                 if(!n && !iter->get_mutual_exclusion().empty() && param_list.count(iter->get_mutual_exclusion()))
  58                         continue;
  59
  60                 if(iter->get_user_supplied() || iter->get_optional())
  61                         continue;
  62
  63                 if(n==0)
  64                         return false;
  65                 if(n==1 && iter->get_requires_multiple())
  66                         return false;
  67                 if(n>1 && !iter->get_supports_multiple())
  68                         return false;
  69
  70                 if(iter->get_type()!=param_list.find(iter->get_name())->second.get_type())
  71                         return false;
  72         }
  73         return true;
  74 }
  75
  76 /* === S T A T I C S ======================================================= */
  77
  78 struct _ParamCounter
  79 {
  80         static int counter;
  81         ~_ParamCounter()
  82         {
  83                 if(counter)
  84                         sinfg::error("%d action params not yet deleted!",counter);
  85         }
  86 } _param_counter;
  87
  88 int _ParamCounter::counter(0);
  89
  90 /* === M E T H O D S ======================================================= */
  91
  92 Param::Param(const Param &rhs):
  93         type_(rhs.type_)
  94 {
  95         _ParamCounter::counter++;
  96         switch(type_)
  97         {
  98         case TYPE_ACTIVEPOINT:
  99                 data.activepoint.construct();
 100                 data.activepoint.get()=rhs.data.activepoint.get();
 101                 break;
 102         case TYPE_WAYPOINT:
 103                 data.waypoint.construct();
 104                 data.waypoint.get()=rhs.data.waypoint.get();
 105                 break;
 106         case TYPE_WAYPOINTMODEL:
 107                 data.waypoint_model.construct();
 108                 data.waypoint_model.get()=rhs.data.waypoint_model.get();
 109                 break;
 110         case TYPE_KEYFRAME:
 111                 data.keyframe.construct();
 112                 data.keyframe.get()=rhs.data.keyframe.get();
 113                 break;
 114         case TYPE_CANVAS:
 115                 data.canvas.construct();
 116                 data.canvas.get()=rhs.data.canvas.get();
 117                 break;
 118         case TYPE_CANVASINTERFACE:
 119                 data.canvas_interface.construct();
 120                 data.canvas_interface.get()=rhs.data.canvas_interface.get();
 121                 break;
 122         case TYPE_LAYER:
 123                 data.layer.construct();
 124                 data.layer.get()=rhs.data.layer.get();
 125                 break;
 126         case TYPE_VALUENODE:
 127                 data.value_node.construct();
 128                 data.value_node.get()=rhs.data.value_node.get();
 129                 break;
 130         case TYPE_VALUEDESC:
 131                 data.value_desc.construct();
 132                 data.value_desc.get()=rhs.data.value_desc.get();
 133                 break;
 134         case TYPE_VALUE:
 135                 data.value.construct();
 136                 data.value.get()=rhs.data.value.get();
 137                 break;
 138         case TYPE_STRING:
 139                 data.string.construct();
 140                 data.string.get()=rhs.data.string.get();
 141                 break;
 142         case TYPE_RENDDESC:
 143                 data.rend_desc.construct();
 144                 data.rend_desc.get()=rhs.data.rend_desc.get();
 145                 break;
 146         case TYPE_TIME:
 147                 data.time.construct();
 148                 data.time.get()=rhs.data.time.get();
 149                 break;
 150
 151         case TYPE_INTEGER:
 152                 data.integer=rhs.data.integer;
 153                 break;
 154         case TYPE_EDITMODE:
 155                 data.edit_mode=rhs.data.edit_mode;
 156                 break;
 157         case TYPE_REAL:
 158                 data.real=rhs.data.real;
 159                 break;
 160         case TYPE_BOOL:
 161                 data.b=rhs.data.b;
 162                 break;
 163
 164         case TYPE_NIL:
 165                 break;
 166
 167         default:
 168                 assert(0);
 169                 break;
 170         }
 171 }
 172
 173 Param::Param(const etl::handle<sinfgapp::CanvasInterface>& x):
 174
 175         type_(TYPE_CANVASINTERFACE)
 176 {
 177         _ParamCounter::counter++;
 178         data.canvas_interface.construct();
 179         data.canvas_interface.get()=x;
 180 }
 181
 182 /*
 183 Param::Param(sinfgapp::CanvasInterface* x):
 184
 185         type_(TYPE_CANVASINTERFACE)
 186 {
 187         _ParamCounter::counter++;
 188         data.canvas_interface.construct();
 189         data.canvas_interface=x;
 190 }
 191 */
 192
 193 Param::Param(const etl::loose_handle<sinfgapp::CanvasInterface>& x):
 194
 195         type_(TYPE_CANVASINTERFACE)
 196 {
 197         _ParamCounter::counter++;
 198         data.canvas_interface.construct();
 199         data.canvas_interface.get()=x;
 200 }
 201
 202 Param::Param(const sinfg::Canvas::Handle& x):
 203         type_(TYPE_CANVAS)
 204 {
 205         _ParamCounter::counter++;
 206         data.canvas.construct();
 207         data.canvas.get()=x;
 208 }
 209
 210 Param::Param(const sinfg::Canvas::LooseHandle& x):
 211         type_(TYPE_CANVAS)
 212 {
 213         _ParamCounter::counter++;
 214         data.canvas.construct();
 215         data.canvas.get()=x;
 216 }
 217
 218 Param::Param(const sinfg::Layer::Handle& x):
 219
 220         type_(TYPE_LAYER)
 221 {
 222         _ParamCounter::counter++;
 223         data.layer.construct();
 224         data.layer.get()=x;
 225 }
 226
 227 Param::Param(const sinfg::Layer::LooseHandle& x):
 228
 229         type_(TYPE_LAYER)
 230 {
 231         _ParamCounter::counter++;
 232         data.layer.construct();
 233         data.layer.get()=x;
 234 }
 235
 236 Param::Param(const sinfg::ValueNode::Handle& x):
 237
 238         type_(TYPE_VALUENODE)
 239 {
 240         _ParamCounter::counter++;
 241         data.value_node.construct();
 242         data.value_node.get()=x;
 243 }
 244
 245 Param::Param(const sinfg::ValueNode::LooseHandle& x):
 246
 247         type_(TYPE_VALUENODE)
 248 {
 249         _ParamCounter::counter++;
 250         data.value_node.construct();
 251         data.value_node.get()=x;
 252 }
 253
 254 Param::Param(const sinfg::ValueBase& x):
 255
 256         type_(TYPE_VALUE)
 257 {
 258         _ParamCounter::counter++;
 259         data.value.construct();
 260         data.value.get()=x;
 261 }
 262
 263 Param::Param(const sinfg::RendDesc& x):
 264         type_(TYPE_RENDDESC)
 265 {
 266         _ParamCounter::counter++;
 267         data.rend_desc.construct();
 268         data.rend_desc.get()=x;
 269 }
 270
 271 Param::Param(const sinfg::Time& x):
 272         type_(TYPE_TIME)
 273 {
 274         _ParamCounter::counter++;
 275         data.time.construct();
 276         data.time.get()=x;
 277 }
 278
 279 Param::Param(const sinfg::Activepoint& x):
 280
 281         type_(TYPE_ACTIVEPOINT)
 282 {
 283         _ParamCounter::counter++;
 284         data.activepoint.construct();
 285         data.activepoint.get()=x;
 286 }
 287
 288 Param::Param(const sinfg::Waypoint& x):
 289         type_(TYPE_WAYPOINT)
 290 {
 291         _ParamCounter::counter++;
 292         data.waypoint.construct();
 293         data.waypoint.get()=x;
 294 }
 295
 296 Param::Param(const sinfg::Waypoint::Model& x):
 297         type_(TYPE_WAYPOINTMODEL)
 298 {
 299         _ParamCounter::counter++;
 300         data.waypoint_model.construct();
 301         data.waypoint_model.get()=x;
 302 }
 303
 304 Param::Param(const sinfg::String& x):
 305         type_(TYPE_STRING)
 306 {
 307         _ParamCounter::counter++;
 308         data.string.construct();
 309         data.string.get()=x;
 310 }
 311
 312 Param::Param(const char * x):
 313         type_(TYPE_STRING)
 314 {
 315         _ParamCounter::counter++;
 316         data.string.construct();
 317         data.string.get()=x;
 318 }
 319
 320 Param::Param(const sinfg::Keyframe& x):
 321
 322         type_(TYPE_KEYFRAME)
 323 {
 324         _ParamCounter::counter++;
 325         data.keyframe.construct();
 326         data.keyframe.get()=x;
 327 }
 328
 329 Param::Param(const sinfgapp::ValueDesc& x):
 330
 331         type_(TYPE_VALUEDESC)
 332 {
 333         _ParamCounter::counter++;
 334         data.value_desc.construct();
 335         data.value_desc.get()=x;
 336 }
 337
 338 Param::Param(const int& x):
 339         type_(TYPE_INTEGER)
 340 {
 341         _ParamCounter::counter++;
 342         data.integer=x;
 343 }
 344
 345 Param::Param(const EditMode& x):
 346         type_(TYPE_EDITMODE)
 347 {
 348         _ParamCounter::counter++;
 349         data.edit_mode=x;
 350 }
 351
 352 Param::Param(const sinfg::Real& x):
 353
 354         type_(TYPE_REAL)
 355 {
 356         _ParamCounter::counter++;
 357         data.real=x;
 358 }
 359
 360 Param::Param(const bool& x):
 361
 362         type_(TYPE_BOOL)
 363 {
 364         _ParamCounter::counter++;
 365         data.b=x;
 366 }
 367
 368 Param::~Param()
 369 {
 370         clear();
 371         _ParamCounter::counter--;
 372 }
 373
 374 Param&
 375 Param::operator=(const Param& rhs)
 376 {
 377         clear();
 378         type_=rhs.type_;
 379
 380         switch(type_)
 381         {
 382         case TYPE_ACTIVEPOINT:
 383                 data.activepoint.construct();
 384                 data.activepoint.get()=rhs.data.activepoint.get();
 385                 break;
 386         case TYPE_WAYPOINT:
 387                 data.waypoint.construct();
 388                 data.waypoint.get()=rhs.data.waypoint.get();
 389                 break;
 390         case TYPE_WAYPOINTMODEL:
 391                 data.waypoint_model.construct();
 392                 data.waypoint_model.get()=rhs.data.waypoint_model.get();
 393                 break;
 394         case TYPE_KEYFRAME:
 395                 data.keyframe.construct();
 396                 data.keyframe.get()=rhs.data.keyframe.get();
 397                 break;
 398         case TYPE_CANVAS:
 399                 data.canvas.construct();
 400                 data.canvas.get()=rhs.data.canvas.get();
 401                 break;
 402         case TYPE_CANVASINTERFACE:
 403                 data.canvas_interface.construct();
 404                 data.canvas_interface.get()=rhs.data.canvas_interface.get();
 405                 break;
 406         case TYPE_TIME:
 407                 data.time.construct();
 408                 data.time.get()=rhs.data.time.get();
 409                 break;
 410         case TYPE_LAYER:
 411                 data.layer.construct();
 412                 data.layer.get()=rhs.data.layer.get();
 413                 break;
 414         case TYPE_VALUENODE:
 415                 data.value_node.construct();
 416                 data.value_node.get()=rhs.data.value_node.get();
 417                 break;
 418         case TYPE_VALUEDESC:
 419                 data.value_desc.construct();
 420                 data.value_desc.get()=rhs.data.value_desc.get();
 421                 break;
 422         case TYPE_VALUE:
 423                 data.value.construct();
 424                 data.value.get()=rhs.data.value.get();
 425                 break;
 426         case TYPE_RENDDESC:
 427                 data.rend_desc.construct();
 428                 data.rend_desc.get()=rhs.data.rend_desc.get();
 429                 break;
 430         case TYPE_STRING:
 431                 data.string.construct();
 432                 data.string.get()=rhs.data.string.get();
 433                 break;
 434
 435         case TYPE_INTEGER:
 436                 data.integer=rhs.data.integer;
 437                 break;
 438         case TYPE_EDITMODE:
 439                 data.integer=rhs.data.integer;
 440                 break;
 441         case TYPE_REAL:
 442                 data.real=rhs.data.real;
 443                 break;
 444         case TYPE_BOOL:
 445                 data.b=rhs.data.b;
 446                 break;
 447
 448         case TYPE_NIL:
 449                 break;
 450
 451         default:
 452                 assert(0);
 453                 break;
 454         }
 455         return *this;
 456 }
 457
 458 void
 459 Param::clear()
 460 {
 461         switch(type_)
 462         {
 463         case TYPE_ACTIVEPOINT:
 464                 data.activepoint.destruct();
 465                 break;
 466         case TYPE_WAYPOINT:
 467                 data.waypoint.destruct();
 468                 break;
 469         case TYPE_WAYPOINTMODEL:
 470                 data.waypoint_model.destruct();
 471                 break;
 472         case TYPE_KEYFRAME:
 473                 data.keyframe.destruct();
 474                 break;
 475         case TYPE_CANVAS:
 476                 data.canvas.destruct();
 477                 break;
 478         case TYPE_CANVASINTERFACE:
 479                 data.canvas_interface.destruct();
 480                 break;
 481         case TYPE_LAYER:
 482                 data.layer.destruct();
 483                 break;
 484         case TYPE_TIME:
 485                 data.time.destruct();
 486                 break;
 487         case TYPE_VALUENODE:
 488                 data.value_node.destruct();
 489                 break;
 490         case TYPE_VALUEDESC:
 491                 data.value_desc.destruct();
 492                 break;
 493         case TYPE_VALUE:
 494                 data.value.destruct();
 495                 break;
 496         case TYPE_RENDDESC:
 497                 data.rend_desc.destruct();
 498                 break;
 499         case TYPE_STRING:
 500                 data.string.destruct();
 501                 break;
 502
 503         case TYPE_NIL:
 504         case TYPE_EDITMODE:
 505         case TYPE_INTEGER:
 506         case TYPE_REAL:
 507         case TYPE_BOOL:
 508                 break;
 509
 510         default:
 511                 assert(0);
 512                 break;
 513         }
 514         type_=TYPE_NIL;
 515 }