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