d30e4d863ebfba0b6652b11f117e0f9ff2a0e046
[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.1-en.txt
10  *
11  */
12
13 #include <string>
14 #include <vector>
15
16 #include "Model.hxx"
17 #include "utilities.hxx"
18
19 #include "model/BaseObject.hxx"
20 #include "model/Annotation.hxx"
21 #include "model/Diagram.hxx"
22 #include "model/Block.hxx"
23 #include "model/Link.hxx"
24 #include "model/Port.hxx"
25
26 namespace org_scilab_modules_scicos
27 {
28
29 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double v)
30 {
31
32     if (k == ANNOTATION)
33     {
34         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
35         switch (p)
36         {
37             default:
38                 break;
39         }
40     }
41     else if (k == BLOCK)
42     {
43         model::Block* o = static_cast<model::Block*>(getObject(uid));
44         switch (p)
45         {
46             default:
47                 break;
48         }
49     }
50     else if (k == DIAGRAM)
51     {
52         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
53         switch (p)
54         {
55             default:
56                 break;
57         }
58     }
59     else if (k == LINK)
60     {
61         model::Link* o = static_cast<model::Link*>(getObject(uid));
62         switch (p)
63         {
64             default:
65                 break;
66         }
67     }
68     else if (k == PORT)
69     {
70         model::Port* o = static_cast<model::Port*>(getObject(uid));
71         switch (p)
72         {
73             case FIRING:
74                 return o->setFiring(v);
75             default:
76                 break;
77         }
78     }
79     return FAIL;
80 }
81
82 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int v)
83 {
84
85     if (k == ANNOTATION)
86     {
87         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
88         switch (p)
89         {
90             default:
91                 break;
92         }
93     }
94     else if (k == BLOCK)
95     {
96         model::Block* o = static_cast<model::Block*>(getObject(uid));
97         switch (p)
98         {
99             case SIM_FUNCTION_API:
100                 return o->setSimFunctionApi(v);
101             case SIM_BLOCKTYPE:
102                 return o->setSimBlocktype(v);
103             case NZCROSS:
104                 return o->setNZcross(v);
105             case NMODE:
106                 return o->setNMode(v);
107             default:
108                 break;
109         }
110     }
111     else if (k == DIAGRAM)
112     {
113         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
114         switch (p)
115         {
116             default:
117                 break;
118         }
119     }
120     else if (k == LINK)
121     {
122         model::Link* o = static_cast<model::Link*>(getObject(uid));
123         switch (p)
124         {
125             case COLOR:
126                 return o->setColor(v);
127             case KIND:
128                 return o->setKind(v);
129             default:
130                 break;
131         }
132     }
133     else if (k == PORT)
134     {
135         model::Port* o = static_cast<model::Port*>(getObject(uid));
136         switch (p)
137         {
138             default:
139                 break;
140         }
141     }
142     return FAIL;
143 }
144
145 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool v)
146 {
147
148     if (k == ANNOTATION)
149     {
150         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
151         switch (p)
152         {
153             default:
154                 break;
155         }
156     }
157     else if (k == BLOCK)
158     {
159         model::Block* o = static_cast<model::Block*>(getObject(uid));
160         switch (p)
161         {
162             default:
163                 break;
164         }
165     }
166     else if (k == DIAGRAM)
167     {
168         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
169         switch (p)
170         {
171             default:
172                 break;
173         }
174     }
175     else if (k == LINK)
176     {
177         model::Link* o = static_cast<model::Link*>(getObject(uid));
178         switch (p)
179         {
180             default:
181                 break;
182         }
183     }
184     else if (k == PORT)
185     {
186         model::Port* o = static_cast<model::Port*>(getObject(uid));
187         switch (p)
188         {
189             case IMPLICIT:
190                 return o->setImplicit(v);
191             default:
192                 break;
193         }
194     }
195     return FAIL;
196 }
197
198 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p,
199         ScicosID v)
200 {
201
202     if (k == ANNOTATION)
203     {
204         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
205         switch (p)
206         {
207             default:
208                 break;
209         }
210     }
211     else if (k == BLOCK)
212     {
213         model::Block* o = static_cast<model::Block*>(getObject(uid));
214         switch (p)
215         {
216             default:
217                 break;
218         }
219     }
220     else if (k == DIAGRAM)
221     {
222         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
223         switch (p)
224         {
225             default:
226                 break;
227         }
228     }
229     else if (k == LINK)
230     {
231         model::Link* o = static_cast<model::Link*>(getObject(uid));
232         switch (p)
233         {
234             default:
235                 break;
236         }
237     }
238     else if (k == PORT)
239     {
240         model::Port* o = static_cast<model::Port*>(getObject(uid));
241         switch (p)
242         {
243             case SOURCE_BLOCK:
244                 return o->setSourceBlock(v);
245             default:
246                 break;
247         }
248     }
249     return FAIL;
250 }
251
252 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p,
253         std::string v)
254 {
255
256     if (k == ANNOTATION)
257     {
258         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
259         switch (p)
260         {
261             default:
262                 break;
263         }
264     }
265     else if (k == BLOCK)
266     {
267         model::Block* o = static_cast<model::Block*>(getObject(uid));
268         switch (p)
269         {
270             case SIM_FUNCTION_NAME:
271                 return o->setSimFunctionName(v);
272             case STYLE:
273                 return o->setStyle(v);
274             case LABEL:
275                 return o->setLabel(v);
276             case UID:
277                 return o->setUID(v);
278             default:
279                 break;
280         }
281     }
282     else if (k == DIAGRAM)
283     {
284         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
285         switch (p)
286         {
287             default:
288                 break;
289         }
290     }
291     else if (k == LINK)
292     {
293         model::Link* o = static_cast<model::Link*>(getObject(uid));
294         switch (p)
295         {
296             case LABEL:
297                 return o->setLabel(v);
298             default:
299                 break;
300         }
301     }
302     else if (k == PORT)
303     {
304         model::Port* o = static_cast<model::Port*>(getObject(uid));
305         switch (p)
306         {
307             case STYLE:
308                 return o->setStyle(v);
309             case LABEL:
310                 return o->setLabel(v);
311             default:
312                 break;
313         }
314     }
315     return FAIL;
316 }
317
318 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
319 {
320
321     if (k == ANNOTATION)
322     {
323         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
324         switch (p)
325         {
326             case GEOMETRY:
327                 return o->setGeometry(v);
328             default:
329                 break;
330         }
331     }
332     else if (k == BLOCK)
333     {
334         model::Block* o = static_cast<model::Block*>(getObject(uid));
335         switch (p)
336         {
337             case GEOMETRY:
338                 return o->setGeometry(v);
339             case ANGLE:
340                 return o->setAngle(v);
341             case STATE:
342                 return o->setState(v);
343             case DSTATE:
344                 return o->setDState(v);
345             case RPAR:
346                 return o->setRpar(v);
347             default:
348                 break;
349         }
350     }
351     else if (k == DIAGRAM)
352     {
353         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
354         switch (p)
355         {
356             default:
357                 break;
358         }
359     }
360     else if (k == LINK)
361     {
362         model::Link* o = static_cast<model::Link*>(getObject(uid));
363         switch (p)
364         {
365             case CONTROL_POINTS:
366                 return o->setControlPoints(v);
367             case THICK:
368                 return o->setThick(v);
369             default:
370                 break;
371         }
372     }
373     else if (k == PORT)
374     {
375         model::Port* o = static_cast<model::Port*>(getObject(uid));
376         switch (p)
377         {
378             default:
379                 break;
380         }
381     }
382     return FAIL;
383 }
384
385 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
386 {
387
388     if (k == ANNOTATION)
389     {
390         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
391         switch (p)
392         {
393             default:
394                 break;
395         }
396     }
397     else if (k == BLOCK)
398     {
399         model::Block* o = static_cast<model::Block*>(getObject(uid));
400         switch (p)
401         {
402             case SIM_DEP_UT:
403                 return o->setSimDepUT(v);
404             case IPAR:
405                 return o->setIpar(v);
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             case DATATYPE:
434                 return o->setDataType(this, v);
435             default:
436                 break;
437         }
438     }
439     return FAIL;
440 }
441
442 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<std::string>& v)
443 {
444
445     if (k == ANNOTATION)
446     {
447         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
448         switch (p)
449         {
450             default:
451                 break;
452         }
453     }
454     else if (k == BLOCK)
455     {
456         model::Block* o = static_cast<model::Block*>(getObject(uid));
457         switch (p)
458         {
459             case EXPRS:
460                 return o->setExprs(v);
461             default:
462                 break;
463         }
464     }
465     else if (k == DIAGRAM)
466     {
467         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
468         switch (p)
469         {
470             default:
471                 break;
472         }
473     }
474     else if (k == LINK)
475     {
476         model::Link* o = static_cast<model::Link*>(getObject(uid));
477         switch (p)
478         {
479             default:
480                 break;
481         }
482     }
483     else if (k == PORT)
484     {
485         model::Port* o = static_cast<model::Port*>(getObject(uid));
486         switch (p)
487         {
488             default:
489                 break;
490         }
491     }
492     return FAIL;
493 }
494
495 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
496 {
497
498     if (k == ANNOTATION)
499     {
500         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
501         switch (p)
502         {
503             default:
504                 break;
505         }
506     }
507     else if (k == BLOCK)
508     {
509         model::Block* o = static_cast<model::Block*>(getObject(uid));
510         switch (p)
511         {
512             case INPUTS:
513                 return o->setIn(v);
514             case OUTPUTS:
515                 return o->setOut(v);
516             case EVENT_INPUTS:
517                 return o->setEin(v);
518             case EVENT_OUTPUTS:
519                 return o->setEout(v);
520             default:
521                 break;
522         }
523     }
524     else if (k == DIAGRAM)
525     {
526         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
527         switch (p)
528         {
529             default:
530                 break;
531         }
532     }
533     else if (k == LINK)
534     {
535         model::Link* o = static_cast<model::Link*>(getObject(uid));
536         switch (p)
537         {
538             default:
539                 break;
540         }
541     }
542     else if (k == PORT)
543     {
544         model::Port* o = static_cast<model::Port*>(getObject(uid));
545         switch (p)
546         {
547             default:
548                 break;
549         }
550     }
551     return FAIL;
552 }
553
554 } /* namespace org_scilab_modules_scicos */
555
556