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