Xcos MVC: implement from / to
[scilab.git] / scilab / modules / scicos / src / cpp / Model_setObjectProperties.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014-2014 - Scilab Enterprises - Clement DAVID
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  */
12
13 #include <string>
14 #include <vector>
15
16 #include "Model.hxx"
17 #include "utilities.hxx"
18
19 #include "model/BaseObject.hxx"
20 #include "model/Annotation.hxx"
21 #include "model/Diagram.hxx"
22 #include "model/Block.hxx"
23 #include "model/Link.hxx"
24 #include "model/Port.hxx"
25
26 namespace org_scilab_modules_scicos
27 {
28
29 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double v)
30 {
31
32     if (k == ANNOTATION)
33     {
34         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
35         switch (p)
36         {
37             default:
38                 break;
39         }
40     }
41     else if (k == BLOCK)
42     {
43         model::Block* o = static_cast<model::Block*>(getObject(uid));
44         switch (p)
45         {
46             default:
47                 break;
48         }
49     }
50     else if (k == DIAGRAM)
51     {
52         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
53         switch (p)
54         {
55             default:
56                 break;
57         }
58     }
59     else if (k == LINK)
60     {
61         model::Link* o = static_cast<model::Link*>(getObject(uid));
62         switch (p)
63         {
64             default:
65                 break;
66         }
67     }
68     else if (k == PORT)
69     {
70         model::Port* o = static_cast<model::Port*>(getObject(uid));
71         switch (p)
72         {
73             case FIRING:
74                 return o->setFiring(v);
75             default:
76                 break;
77         }
78     }
79     return FAIL;
80 }
81
82 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int v)
83 {
84
85     if (k == ANNOTATION)
86     {
87         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
88         switch (p)
89         {
90             default:
91                 break;
92         }
93     }
94     else if (k == BLOCK)
95     {
96         model::Block* o = static_cast<model::Block*>(getObject(uid));
97         switch (p)
98         {
99             case SIM_FUNCTION_API:
100                 return o->setSimFunctionApi(v);
101             case SIM_BLOCKTYPE:
102                 return o->setSimBlocktype(v);
103             case NZCROSS:
104                 return o->setNZcross(v);
105             case NMODE:
106                 return o->setNMode(v);
107             default:
108                 break;
109         }
110     }
111     else if (k == DIAGRAM)
112     {
113         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
114         switch (p)
115         {
116             default:
117                 break;
118         }
119     }
120     else if (k == LINK)
121     {
122         model::Link* o = static_cast<model::Link*>(getObject(uid));
123         switch (p)
124         {
125             case COLOR:
126                 return o->setColor(v);
127             case KIND:
128                 return o->setKind(v);
129             default:
130                 break;
131         }
132     }
133     else if (k == PORT)
134     {
135         model::Port* o = static_cast<model::Port*>(getObject(uid));
136         switch (p)
137         {
138             case PORT_KIND:
139                 return o->setKind(v);
140             default:
141                 break;
142         }
143     }
144     return FAIL;
145 }
146
147 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool v)
148 {
149
150     if (k == ANNOTATION)
151     {
152         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
153         switch (p)
154         {
155             default:
156                 break;
157         }
158     }
159     else if (k == BLOCK)
160     {
161         model::Block* o = static_cast<model::Block*>(getObject(uid));
162         switch (p)
163         {
164             default:
165                 break;
166         }
167     }
168     else if (k == DIAGRAM)
169     {
170         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
171         switch (p)
172         {
173             default:
174                 break;
175         }
176     }
177     else if (k == LINK)
178     {
179         model::Link* o = static_cast<model::Link*>(getObject(uid));
180         switch (p)
181         {
182             default:
183                 break;
184         }
185     }
186     else if (k == PORT)
187     {
188         model::Port* o = static_cast<model::Port*>(getObject(uid));
189         switch (p)
190         {
191             case IMPLICIT:
192                 return o->setImplicit(v);
193             default:
194                 break;
195         }
196     }
197     return FAIL;
198 }
199
200 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p,
201         ScicosID v)
202 {
203
204     if (k == ANNOTATION)
205     {
206         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
207         switch (p)
208         {
209             default:
210                 break;
211         }
212     }
213     else if (k == BLOCK)
214     {
215         model::Block* o = static_cast<model::Block*>(getObject(uid));
216         switch (p)
217         {
218             default:
219                 break;
220         }
221     }
222     else if (k == DIAGRAM)
223     {
224         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
225         switch (p)
226         {
227             default:
228                 break;
229         }
230     }
231     else if (k == LINK)
232     {
233         model::Link* o = static_cast<model::Link*>(getObject(uid));
234         switch (p)
235         {
236             case SOURCE_PORT:
237                 return o->setSourcePort(v);
238             case DESTINATION_PORT:
239                 return o->setDestinationPort(v);
240             default:
241                 break;
242         }
243     }
244     else if (k == PORT)
245     {
246         model::Port* o = static_cast<model::Port*>(getObject(uid));
247         switch (p)
248         {
249             case SOURCE_BLOCK:
250                 return o->setSourceBlock(v);
251             case CONNECTED_SIGNALS:
252                 return o->setConnectedSignals(std::vector<ScicosID> (1, v));
253             default:
254                 break;
255         }
256     }
257     return FAIL;
258 }
259
260 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p,
261         std::string v)
262 {
263
264     if (k == ANNOTATION)
265     {
266         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
267         switch (p)
268         {
269             default:
270                 break;
271         }
272     }
273     else if (k == BLOCK)
274     {
275         model::Block* o = static_cast<model::Block*>(getObject(uid));
276         switch (p)
277         {
278             case INTERFACE_FUNCTION:
279                 return o->setInterfaceFunction(v);
280             case SIM_FUNCTION_NAME:
281                 return o->setSimFunctionName(v);
282             case STYLE:
283                 return o->setStyle(v);
284             case LABEL:
285                 return o->setLabel(v);
286             case UID:
287                 return o->setUID(v);
288             default:
289                 break;
290         }
291     }
292     else if (k == DIAGRAM)
293     {
294         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
295         switch (p)
296         {
297             default:
298                 break;
299         }
300     }
301     else if (k == LINK)
302     {
303         model::Link* o = static_cast<model::Link*>(getObject(uid));
304         switch (p)
305         {
306             case LABEL:
307                 return o->setLabel(v);
308             default:
309                 break;
310         }
311     }
312     else if (k == PORT)
313     {
314         model::Port* o = static_cast<model::Port*>(getObject(uid));
315         switch (p)
316         {
317             case STYLE:
318                 return o->setStyle(v);
319             case LABEL:
320                 return o->setLabel(v);
321             default:
322                 break;
323         }
324     }
325     return FAIL;
326 }
327
328 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
329 {
330
331     if (k == ANNOTATION)
332     {
333         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
334         switch (p)
335         {
336             case GEOMETRY:
337                 return o->setGeometry(v);
338             default:
339                 break;
340         }
341     }
342     else if (k == BLOCK)
343     {
344         model::Block* o = static_cast<model::Block*>(getObject(uid));
345         switch (p)
346         {
347             case GEOMETRY:
348                 return o->setGeometry(v);
349             case ANGLE:
350                 return o->setAngle(v);
351             case STATE:
352                 return o->setState(v);
353             case DSTATE:
354                 return o->setDState(v);
355             case RPAR:
356                 return o->setRpar(v);
357             default:
358                 break;
359         }
360     }
361     else if (k == DIAGRAM)
362     {
363         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
364         switch (p)
365         {
366             default:
367                 break;
368         }
369     }
370     else if (k == LINK)
371     {
372         model::Link* o = static_cast<model::Link*>(getObject(uid));
373         switch (p)
374         {
375             case CONTROL_POINTS:
376                 return o->setControlPoints(v);
377             case THICK:
378                 return o->setThick(v);
379             default:
380                 break;
381         }
382     }
383     else if (k == PORT)
384     {
385         model::Port* o = static_cast<model::Port*>(getObject(uid));
386         switch (p)
387         {
388             default:
389                 break;
390         }
391     }
392     return FAIL;
393 }
394
395 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
396 {
397
398     if (k == ANNOTATION)
399     {
400         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
401         switch (p)
402         {
403             default:
404                 break;
405         }
406     }
407     else if (k == BLOCK)
408     {
409         model::Block* o = static_cast<model::Block*>(getObject(uid));
410         switch (p)
411         {
412             case SIM_DEP_UT:
413                 return o->setSimDepUT(v);
414             case IPAR:
415                 return o->setIpar(v);
416             default:
417                 break;
418         }
419     }
420     else if (k == DIAGRAM)
421     {
422         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
423         switch (p)
424         {
425             default:
426                 break;
427         }
428     }
429     else if (k == LINK)
430     {
431         model::Link* o = static_cast<model::Link*>(getObject(uid));
432         switch (p)
433         {
434             default:
435                 break;
436         }
437     }
438     else if (k == PORT)
439     {
440         model::Port* o = static_cast<model::Port*>(getObject(uid));
441         switch (p)
442         {
443             case DATATYPE:
444                 return o->setDataType(this, v);
445             default:
446                 break;
447         }
448     }
449     return FAIL;
450 }
451
452 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<std::string>& v)
453 {
454
455     if (k == ANNOTATION)
456     {
457         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
458         switch (p)
459         {
460             default:
461                 break;
462         }
463     }
464     else if (k == BLOCK)
465     {
466         model::Block* o = static_cast<model::Block*>(getObject(uid));
467         switch (p)
468         {
469             case EXPRS:
470                 return o->setExprs(v);
471             default:
472                 break;
473         }
474     }
475     else if (k == DIAGRAM)
476     {
477         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
478         switch (p)
479         {
480             default:
481                 break;
482         }
483     }
484     else if (k == LINK)
485     {
486         model::Link* o = static_cast<model::Link*>(getObject(uid));
487         switch (p)
488         {
489             default:
490                 break;
491         }
492     }
493     else if (k == PORT)
494     {
495         model::Port* o = static_cast<model::Port*>(getObject(uid));
496         switch (p)
497         {
498             default:
499                 break;
500         }
501     }
502     return FAIL;
503 }
504
505 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
506 {
507
508     if (k == ANNOTATION)
509     {
510         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
511         switch (p)
512         {
513             default:
514                 break;
515         }
516     }
517     else if (k == BLOCK)
518     {
519         model::Block* o = static_cast<model::Block*>(getObject(uid));
520         switch (p)
521         {
522             case INPUTS:
523                 return o->setIn(v);
524             case OUTPUTS:
525                 return o->setOut(v);
526             case EVENT_INPUTS:
527                 return o->setEin(v);
528             case EVENT_OUTPUTS:
529                 return o->setEout(v);
530             default:
531                 break;
532         }
533     }
534     else if (k == DIAGRAM)
535     {
536         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
537         switch (p)
538         {
539             default:
540                 break;
541         }
542     }
543     else if (k == LINK)
544     {
545         model::Link* o = static_cast<model::Link*>(getObject(uid));
546         switch (p)
547         {
548             default:
549                 break;
550         }
551     }
552     else if (k == PORT)
553     {
554         model::Port* o = static_cast<model::Port*>(getObject(uid));
555         switch (p)
556         {
557             case CONNECTED_SIGNALS:
558                 return o->setConnectedSignals(v);
559             default:
560                 break;
561         }
562     }
563     return FAIL;
564 }
565
566 } /* namespace org_scilab_modules_scicos */
567
568