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