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)51 Action::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)97 Param::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)181 Param::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)201 Param::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)210 Param::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)218 Param::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)226 Param::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)235 Param::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)244 Param::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)253 Param::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)262 Param::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)271 Param::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)279 Param::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)287 Param::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)296 Param::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)304 Param::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)312 Param::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)320 Param::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)328 Param::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)337 Param::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)346 Param::Param(const int& x):
347 	type_(TYPE_INTEGER)
348 {
349 	_ParamCounter::counter++;
350 	data.integer=x;
351 }
352 
Param(const EditMode & x)353 Param::Param(const EditMode& x):
354 	type_(TYPE_EDITMODE)
355 {
356 	_ParamCounter::counter++;
357 	data.edit_mode=x;
358 }
359 
Param(const synfig::Real & x)360 Param::Param(const synfig::Real& x):
361 
362 	type_(TYPE_REAL)
363 {
364 	_ParamCounter::counter++;
365 	data.real=x;
366 }
367 
Param(const bool & x)368 Param::Param(const bool& x):
369 
370 	type_(TYPE_BOOL)
371 {
372 	_ParamCounter::counter++;
373 	data.b=x;
374 }
375 
Param(const synfig::Interpolation & x)376 Param::Param(const synfig::Interpolation& x):
377 	type_(TYPE_INTERPOLATION)
378 {
379 	_ParamCounter::counter++;
380 	data.interpolation=x;
381 }
382 
~Param()383 Param::~Param()
384 {
385 	clear();
386 	_ParamCounter::counter--;
387 }
388 
389 Param&
operator =(const Param & rhs)390 Param::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()477 Param::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