94b34dc610ae61e21eb710aa9944431e49da139f
[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 ID:
252                 return o->setIdentifier(v);
253             default:
254                 break;
255         }
256     }
257     else if (k == DIAGRAM)
258     {
259         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
260         switch (p)
261         {
262             default:
263                 break;
264         }
265     }
266     else if (k == LINK)
267     {
268         model::Link* o = static_cast<model::Link*>(getObject(uid));
269         switch (p)
270         {
271             default:
272                 break;
273         }
274     }
275     else if (k == PORT)
276     {
277         model::Port* o = static_cast<model::Port*>(getObject(uid));
278         switch (p)
279         {
280             default:
281                 break;
282         }
283     }
284     return FAIL;
285 }
286
287 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
288 {
289
290     if (k == ANNOTATION)
291     {
292         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
293         switch (p)
294         {
295             case GEOMETRY:
296                 return o->setGeometry(v);
297             default:
298                 break;
299         }
300     }
301     else if (k == BLOCK)
302     {
303         model::Block* o = static_cast<model::Block*>(getObject(uid));
304         switch (p)
305         {
306             case GEOMETRY:
307                 return o->setGeometry(v);
308             case ANGLE:
309                 return o->setAngle(v);
310             default:
311                 break;
312         }
313     }
314     else if (k == DIAGRAM)
315     {
316         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
317         switch (p)
318         {
319             default:
320                 break;
321         }
322     }
323     else if (k == LINK)
324     {
325         model::Link* o = static_cast<model::Link*>(getObject(uid));
326         switch (p)
327         {
328             default:
329                 break;
330         }
331     }
332     else if (k == PORT)
333     {
334         model::Port* o = static_cast<model::Port*>(getObject(uid));
335         switch (p)
336         {
337             default:
338                 break;
339         }
340     }
341     return FAIL;
342 }
343
344 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
345 {
346
347     if (k == ANNOTATION)
348     {
349         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
350         switch (p)
351         {
352             default:
353                 break;
354         }
355     }
356     else if (k == BLOCK)
357     {
358         model::Block* o = static_cast<model::Block*>(getObject(uid));
359         switch (p)
360         {
361             default:
362                 break;
363         }
364     }
365     else if (k == DIAGRAM)
366     {
367         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
368         switch (p)
369         {
370             default:
371                 break;
372         }
373     }
374     else if (k == LINK)
375     {
376         model::Link* o = static_cast<model::Link*>(getObject(uid));
377         switch (p)
378         {
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< std::string >& 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 EXPRS:
413                 return o->setExprs(v);
414             default:
415                 break;
416         }
417     }
418     else if (k == DIAGRAM)
419     {
420         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
421         switch (p)
422         {
423             default:
424                 break;
425         }
426     }
427     else if (k == LINK)
428     {
429         model::Link* o = static_cast<model::Link*>(getObject(uid));
430         switch (p)
431         {
432             default:
433                 break;
434         }
435     }
436     else if (k == PORT)
437     {
438         model::Port* o = static_cast<model::Port*>(getObject(uid));
439         switch (p)
440         {
441             default:
442                 break;
443         }
444     }
445     return FAIL;
446 }
447
448 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
449 {
450
451     if (k == ANNOTATION)
452     {
453         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
454         switch (p)
455         {
456             default:
457                 break;
458         }
459     }
460     else if (k == BLOCK)
461     {
462         model::Block* o = static_cast<model::Block*>(getObject(uid));
463         switch (p)
464         {
465             case INPUTS:
466                 return o->setIn(v);
467             case OUTPUTS:
468                 return o->setOut(v);
469             case EVENT_INPUTS:
470                 return o->setEin(v);
471             case EVENT_OUTPUTS:
472                 return o->setEout(v);
473             default:
474                 break;
475         }
476     }
477     else if (k == DIAGRAM)
478     {
479         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
480         switch (p)
481         {
482             default:
483                 break;
484         }
485     }
486     else if (k == LINK)
487     {
488         model::Link* o = static_cast<model::Link*>(getObject(uid));
489         switch (p)
490         {
491             default:
492                 break;
493         }
494     }
495     else if (k == PORT)
496     {
497         model::Port* o = static_cast<model::Port*>(getObject(uid));
498         switch (p)
499         {
500             default:
501                 break;
502         }
503     }
504     return FAIL;
505 }
506
507 } /* namespace org_scilab_modules_scicos */
508
509