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