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