52158496677c0455544230d3d2fb48293302fe87
[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             case ANGLE:
305                 return o->setAngle(v);
306             default:
307                 break;
308         }
309     }
310     else if (k == DIAGRAM)
311     {
312         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
313         switch (p)
314         {
315             default:
316                 break;
317         }
318     }
319     else if (k == LINK)
320     {
321         model::Link* o = static_cast<model::Link*>(getObject(uid));
322         switch (p)
323         {
324             default:
325                 break;
326         }
327     }
328     else if (k == PORT)
329     {
330         model::Port* o = static_cast<model::Port*>(getObject(uid));
331         switch (p)
332         {
333             default:
334                 break;
335         }
336     }
337     return FAIL;
338 }
339
340 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
341 {
342
343     if (k == ANNOTATION)
344     {
345         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
346         switch (p)
347         {
348             default:
349                 break;
350         }
351     }
352     else if (k == BLOCK)
353     {
354         model::Block* o = static_cast<model::Block*>(getObject(uid));
355         switch (p)
356         {
357             default:
358                 break;
359         }
360     }
361     else if (k == DIAGRAM)
362     {
363         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
364         switch (p)
365         {
366             default:
367                 break;
368         }
369     }
370     else if (k == LINK)
371     {
372         model::Link* o = static_cast<model::Link*>(getObject(uid));
373         switch (p)
374         {
375             default:
376                 break;
377         }
378     }
379     else if (k == PORT)
380     {
381         model::Port* o = static_cast<model::Port*>(getObject(uid));
382         switch (p)
383         {
384             default:
385                 break;
386         }
387     }
388     return FAIL;
389 }
390
391 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector< std::string >& v)
392 {
393
394     if (k == ANNOTATION)
395     {
396         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
397         switch (p)
398         {
399             default:
400                 break;
401         }
402     }
403     else if (k == BLOCK)
404     {
405         model::Block* o = static_cast<model::Block*>(getObject(uid));
406         switch (p)
407         {
408             case EXPRS:
409                 return o->setExprs(v);
410             default:
411                 break;
412         }
413     }
414     else if (k == DIAGRAM)
415     {
416         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
417         switch (p)
418         {
419             default:
420                 break;
421         }
422     }
423     else if (k == LINK)
424     {
425         model::Link* o = static_cast<model::Link*>(getObject(uid));
426         switch (p)
427         {
428             default:
429                 break;
430         }
431     }
432     else if (k == PORT)
433     {
434         model::Port* o = static_cast<model::Port*>(getObject(uid));
435         switch (p)
436         {
437             default:
438                 break;
439         }
440     }
441     return FAIL;
442 }
443
444 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
445 {
446
447     if (k == ANNOTATION)
448     {
449         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
450         switch (p)
451         {
452             default:
453                 break;
454         }
455     }
456     else if (k == BLOCK)
457     {
458         model::Block* o = static_cast<model::Block*>(getObject(uid));
459         switch (p)
460         {
461             case INPUTS:
462                 if (v.size() > o->in.size()); // FIXME: Input port creation
463                 if (v.size() < o->in.size()); // FIXME: Input port deletion
464                 {
465                     o->setIn(v);
466                 }
467                 return SUCCESS;
468             case OUTPUTS:
469                 if (v.size() > o->out.size()); // FIXME: Output port creation
470                 if (v.size() < o->out.size()); // FIXME: Output port deletion
471                 {
472                     o->setOut(v);
473                 }
474                 return SUCCESS;
475             default:
476                 break;
477         }
478     }
479     else if (k == DIAGRAM)
480     {
481         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
482         switch (p)
483         {
484             default:
485                 break;
486         }
487     }
488     else if (k == LINK)
489     {
490         model::Link* o = static_cast<model::Link*>(getObject(uid));
491         switch (p)
492         {
493             default:
494                 break;
495         }
496     }
497     else if (k == PORT)
498     {
499         model::Port* o = static_cast<model::Port*>(getObject(uid));
500         switch (p)
501         {
502             default:
503                 break;
504         }
505     }
506     return FAIL;
507 }
508
509 } /* namespace org_scilab_modules_scicos */
510
511