97790e3c35973e28ccd4cffda403670736ce683d
[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             default:
173                 break;
174         }
175     }
176     return FAIL;
177 }
178
179 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p,
180         ScicosID v)
181 {
182
183     if (k == ANNOTATION)
184     {
185         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
186         switch (p)
187         {
188             default:
189                 break;
190         }
191     }
192     else if (k == BLOCK)
193     {
194         model::Block* o = static_cast<model::Block*>(getObject(uid));
195         switch (p)
196         {
197             default:
198                 break;
199         }
200     }
201     else if (k == DIAGRAM)
202     {
203         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
204         switch (p)
205         {
206             default:
207                 break;
208         }
209     }
210     else if (k == LINK)
211     {
212         model::Link* o = static_cast<model::Link*>(getObject(uid));
213         switch (p)
214         {
215             default:
216                 break;
217         }
218     }
219     else if (k == PORT)
220     {
221         model::Port* o = static_cast<model::Port*>(getObject(uid));
222         switch (p)
223         {
224             default:
225                 break;
226         }
227     }
228     return FAIL;
229 }
230
231 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p,
232         std::string v)
233 {
234
235     if (k == ANNOTATION)
236     {
237         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
238         switch (p)
239         {
240             default:
241                 break;
242         }
243     }
244     else if (k == BLOCK)
245     {
246         model::Block* o = static_cast<model::Block*>(getObject(uid));
247         switch (p)
248         {
249             default:
250                 break;
251         }
252     }
253     else if (k == DIAGRAM)
254     {
255         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
256         switch (p)
257         {
258             default:
259                 break;
260         }
261     }
262     else if (k == LINK)
263     {
264         model::Link* o = static_cast<model::Link*>(getObject(uid));
265         switch (p)
266         {
267             default:
268                 break;
269         }
270     }
271     else if (k == PORT)
272     {
273         model::Port* o = static_cast<model::Port*>(getObject(uid));
274         switch (p)
275         {
276             default:
277                 break;
278         }
279     }
280     return FAIL;
281 }
282
283 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
284 {
285
286     if (k == ANNOTATION)
287     {
288         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
289         switch (p)
290         {
291             case GEOMETRY:
292                 return o->setGeometry(v);
293             default:
294                 break;
295         }
296     }
297     else if (k == BLOCK)
298     {
299         model::Block* o = static_cast<model::Block*>(getObject(uid));
300         switch (p)
301         {
302             case GEOMETRY:
303                 return o->setGeometry(v);
304             default:
305                 break;
306         }
307     }
308     else if (k == DIAGRAM)
309     {
310         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
311         switch (p)
312         {
313             default:
314                 break;
315         }
316     }
317     else if (k == LINK)
318     {
319         model::Link* o = static_cast<model::Link*>(getObject(uid));
320         switch (p)
321         {
322             default:
323                 break;
324         }
325     }
326     else if (k == PORT)
327     {
328         model::Port* o = static_cast<model::Port*>(getObject(uid));
329         switch (p)
330         {
331             default:
332                 break;
333         }
334     }
335     return FAIL;
336 }
337
338 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
339 {
340
341     if (k == ANNOTATION)
342     {
343         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
344         switch (p)
345         {
346             default:
347                 break;
348         }
349     }
350     else if (k == BLOCK)
351     {
352         model::Block* o = static_cast<model::Block*>(getObject(uid));
353         switch (p)
354         {
355             default:
356                 break;
357         }
358     }
359     else if (k == DIAGRAM)
360     {
361         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
362         switch (p)
363         {
364             default:
365                 break;
366         }
367     }
368     else if (k == LINK)
369     {
370         model::Link* o = static_cast<model::Link*>(getObject(uid));
371         switch (p)
372         {
373             default:
374                 break;
375         }
376     }
377     else if (k == PORT)
378     {
379         model::Port* o = static_cast<model::Port*>(getObject(uid));
380         switch (p)
381         {
382             default:
383                 break;
384         }
385     }
386     return FAIL;
387 }
388
389 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector< std::string >& v)
390 {
391
392     if (k == ANNOTATION)
393     {
394         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
395         switch (p)
396         {
397             default:
398                 break;
399         }
400     }
401     else if (k == BLOCK)
402     {
403         model::Block* o = static_cast<model::Block*>(getObject(uid));
404         switch (p)
405         {
406             default:
407                 break;
408         }
409     }
410     else if (k == DIAGRAM)
411     {
412         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
413         switch (p)
414         {
415             default:
416                 break;
417         }
418     }
419     else if (k == LINK)
420     {
421         model::Link* o = static_cast<model::Link*>(getObject(uid));
422         switch (p)
423         {
424             default:
425                 break;
426         }
427     }
428     else if (k == PORT)
429     {
430         model::Port* o = static_cast<model::Port*>(getObject(uid));
431         switch (p)
432         {
433             default:
434                 break;
435         }
436     }
437     return FAIL;
438 }
439
440 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
441 {
442
443     if (k == ANNOTATION)
444     {
445         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
446         switch (p)
447         {
448             default:
449                 break;
450         }
451     }
452     else if (k == BLOCK)
453     {
454         model::Block* o = static_cast<model::Block*>(getObject(uid));
455         switch (p)
456         {
457             default:
458                 break;
459         }
460     }
461     else if (k == DIAGRAM)
462     {
463         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
464         switch (p)
465         {
466             default:
467                 break;
468         }
469     }
470     else if (k == LINK)
471     {
472         model::Link* o = static_cast<model::Link*>(getObject(uid));
473         switch (p)
474         {
475             default:
476                 break;
477         }
478     }
479     else if (k == PORT)
480     {
481         model::Port* o = static_cast<model::Port*>(getObject(uid));
482         switch (p)
483         {
484             default:
485                 break;
486         }
487     }
488     return FAIL;
489 }
490
491 } /* namespace org_scilab_modules_scicos */
492
493