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