GPL + CeCILL Header change
[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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  * === LICENSE_END ===
14  *
15  */
16
17 #include <string>
18 #include <vector>
19
20 #include "Model.hxx"
21 #include "utilities.hxx"
22
23 #include "model/BaseObject.hxx"
24 #include "model/Annotation.hxx"
25 #include "model/Diagram.hxx"
26 #include "model/Block.hxx"
27 #include "model/Link.hxx"
28 #include "model/Port.hxx"
29
30 namespace org_scilab_modules_scicos
31 {
32
33 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double v)
34 {
35     model::BaseObject* baseObject = getObject(uid);
36     if (baseObject == nullptr)
37     {
38         return FAIL;
39     }
40
41     if (k == ANNOTATION)
42     {
43         switch (p)
44         {
45             default:
46                 break;
47         }
48     }
49     else if (k == BLOCK)
50     {
51         switch (p)
52         {
53             default:
54                 break;
55         }
56     }
57     else if (k == DIAGRAM)
58     {
59         switch (p)
60         {
61             default:
62                 break;
63         }
64     }
65     else if (k == LINK)
66     {
67         switch (p)
68         {
69             default:
70                 break;
71         }
72     }
73     else if (k == PORT)
74     {
75         model::Port* o = static_cast<model::Port*>(baseObject);
76         switch (p)
77         {
78             case FIRING:
79                 return o->setFiring(v);
80             default:
81                 break;
82         }
83     }
84     return FAIL;
85 }
86
87 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int v)
88 {
89     model::BaseObject* baseObject = getObject(uid);
90     if (baseObject == nullptr)
91     {
92         return FAIL;
93     }
94
95     if (k == ANNOTATION)
96     {
97         switch (p)
98         {
99             default:
100                 break;
101         }
102     }
103     else if (k == BLOCK)
104     {
105         model::Block* o = static_cast<model::Block*>(baseObject);
106         switch (p)
107         {
108             case SIM_FUNCTION_API:
109                 return o->setSimFunctionApi(v);
110             default:
111                 break;
112         }
113     }
114     else if (k == DIAGRAM)
115     {
116         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
117         switch (p)
118         {
119             case DEBUG_LEVEL:
120                 return o->setDebugLevel(v);
121             default:
122                 break;
123         }
124     }
125     else if (k == LINK)
126     {
127         model::Link* o = static_cast<model::Link*>(baseObject);
128         switch (p)
129         {
130             case COLOR:
131                 return o->setColor(v);
132             case KIND:
133                 return o->setKind(v);
134             default:
135                 break;
136         }
137     }
138     else if (k == PORT)
139     {
140         model::Port* o = static_cast<model::Port*>(baseObject);
141         switch (p)
142         {
143             case PORT_KIND:
144                 return o->setKind(v);
145             default:
146                 break;
147         }
148     }
149     return FAIL;
150 }
151
152 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool v)
153 {
154     model::BaseObject* baseObject = getObject(uid);
155     if (baseObject == nullptr)
156     {
157         return FAIL;
158     }
159
160     if (k == ANNOTATION)
161     {
162         switch (p)
163         {
164             default:
165                 break;
166         }
167     }
168     else if (k == BLOCK)
169     {
170         switch (p)
171         {
172             default:
173                 break;
174         }
175     }
176     else if (k == DIAGRAM)
177     {
178         switch (p)
179         {
180             default:
181                 break;
182         }
183     }
184     else if (k == LINK)
185     {
186         switch (p)
187         {
188             default:
189                 break;
190         }
191     }
192     else if (k == PORT)
193     {
194         model::Port* o = static_cast<model::Port*>(baseObject);
195         switch (p)
196         {
197             case IMPLICIT:
198                 return o->setImplicit(v);
199             default:
200                 break;
201         }
202     }
203     return FAIL;
204 }
205
206 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID v)
207 {
208     model::BaseObject* baseObject = getObject(uid);
209     if (baseObject == nullptr)
210     {
211         return FAIL;
212     }
213
214     if (k == ANNOTATION)
215     {
216         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
217         switch (p)
218         {
219             case PARENT_DIAGRAM:
220                 return o->setParentDiagram(v);
221             case PARENT_BLOCK:
222                 return o->setParentBlock(v);
223             default:
224                 break;
225         }
226     }
227     else if (k == BLOCK)
228     {
229         model::Block* o = static_cast<model::Block*>(baseObject);
230         switch (p)
231         {
232             case PARENT_DIAGRAM:
233                 return o->setParentDiagram(v);
234             case PARENT_BLOCK:
235                 return o->setParentBlock(v);
236             case PORT_REFERENCE:
237                 return o->setPortReference(v);
238             default:
239                 break;
240         }
241     }
242     else if (k == DIAGRAM)
243     {
244         switch (p)
245         {
246             default:
247                 break;
248         }
249     }
250     else if (k == LINK)
251     {
252         model::Link* o = static_cast<model::Link*>(baseObject);
253         switch (p)
254         {
255             case PARENT_DIAGRAM:
256                 return o->setParentDiagram(v);
257             case PARENT_BLOCK:
258                 return o->setParentBlock(v);
259             case SOURCE_PORT:
260                 return o->setSourcePort(v);
261             case DESTINATION_PORT:
262                 return o->setDestinationPort(v);
263             default:
264                 break;
265         }
266     }
267     else if (k == PORT)
268     {
269         model::Port* o = static_cast<model::Port*>(baseObject);
270         switch (p)
271         {
272             case SOURCE_BLOCK:
273                 return o->setSourceBlock(v);
274             case CONNECTED_SIGNALS:
275                 return o->setConnectedSignals(std::vector<ScicosID> (1, v));
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, std::string v)
284 {
285     model::BaseObject* baseObject = getObject(uid);
286     if (baseObject == nullptr)
287     {
288         return FAIL;
289     }
290
291     if (k == ANNOTATION)
292     {
293         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
294         switch (p)
295         {
296             case DESCRIPTION:
297                 return o->setDescription(v);
298             case FONT:
299                 return o->setFont(v);
300             case FONT_SIZE:
301                 return o->setFontSize(v);
302             case STYLE:
303                 return o->setStyle(v);
304             case UID:
305                 return o->setUID(v);
306             default:
307                 break;
308         }
309     }
310     else if (k == BLOCK)
311     {
312         model::Block* o = static_cast<model::Block*>(baseObject);
313         switch (p)
314         {
315             case INTERFACE_FUNCTION:
316                 return o->setInterfaceFunction(v);
317             case SIM_FUNCTION_NAME:
318                 return o->setSimFunctionName(v);
319             case SIM_BLOCKTYPE:
320                 return o->setSimBlocktype(v);
321             case STYLE:
322                 return o->setStyle(v);
323             case DESCRIPTION:
324                 return o->setDescription(v);
325             case LABEL:
326                 return o->setLabel(v);
327             case UID:
328                 return o->setUID(v);
329             default:
330                 break;
331         }
332     }
333     else if (k == DIAGRAM)
334     {
335         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
336         switch (p)
337         {
338             case TITLE:
339                 return o->setTitle(v);
340             case PATH:
341                 return o->setPath(v);
342             case VERSION_NUMBER:
343                 return o->setVersionNumber(v);
344             default:
345                 break;
346         }
347     }
348     else if (k == LINK)
349     {
350         model::Link* o = static_cast<model::Link*>(baseObject);
351         switch (p)
352         {
353             case LABEL:
354                 return o->setLabel(v);
355             case UID:
356                 return o->setUID(v);
357             default:
358                 break;
359         }
360     }
361     else if (k == PORT)
362     {
363         model::Port* o = static_cast<model::Port*>(baseObject);
364         switch (p)
365         {
366             case STYLE:
367                 return o->setStyle(v);
368             case LABEL:
369                 return o->setLabel(v);
370             case UID:
371                 return o->setUID(v);
372             default:
373                 break;
374         }
375     }
376     return FAIL;
377 }
378
379 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
380 {
381     model::BaseObject* baseObject = getObject(uid);
382     if (baseObject == nullptr)
383     {
384         return FAIL;
385     }
386
387     if (k == ANNOTATION)
388     {
389         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
390         switch (p)
391         {
392             case GEOMETRY:
393                 return o->setGeometry(v);
394             default:
395                 break;
396         }
397     }
398     else if (k == BLOCK)
399     {
400         model::Block* o = static_cast<model::Block*>(baseObject);
401         switch (p)
402         {
403             case GEOMETRY:
404                 return o->setGeometry(v);
405             case ANGLE:
406                 return o->setAngle(v);
407             case EXPRS:
408                 return o->setExprs(v);
409             case STATE:
410                 return o->setState(v);
411             case DSTATE:
412                 return o->setDState(v);
413             case ODSTATE:
414                 return o->setODState(v);
415             case RPAR:
416                 return o->setRpar(v);
417             case OPAR:
418                 return o->setOpar(v);
419             case EQUATIONS:
420                 return o->setEquations(v);
421             default:
422                 break;
423         }
424     }
425     else if (k == DIAGRAM)
426     {
427         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
428         switch (p)
429         {
430             case PROPERTIES:
431                 return o->setProperties(v);
432             default:
433                 break;
434         }
435     }
436     else if (k == LINK)
437     {
438         model::Link* o = static_cast<model::Link*>(baseObject);
439         switch (p)
440         {
441             case CONTROL_POINTS:
442                 return o->setControlPoints(v);
443             case THICK:
444                 return o->setThick(v);
445             default:
446                 break;
447         }
448     }
449     else if (k == PORT)
450     {
451         switch (p)
452         {
453             default:
454                 break;
455         }
456     }
457     return FAIL;
458 }
459
460 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
461 {
462     model::BaseObject* baseObject = getObject(uid);
463     if (baseObject == nullptr)
464     {
465         return FAIL;
466     }
467
468     if (k == ANNOTATION)
469     {
470         switch (p)
471         {
472             default:
473                 break;
474         }
475     }
476     else if (k == BLOCK)
477     {
478         model::Block* o = static_cast<model::Block*>(baseObject);
479         switch (p)
480         {
481             case SIM_DEP_UT:
482                 return o->setSimDepUT(v);
483             case NZCROSS:
484                 return o->setNZcross(v);
485             case NMODE:
486                 return o->setNMode(v);
487             case IPAR:
488                 return o->setIpar(v);
489             case COLOR:
490                 return o->setChildrenColor(v);
491             default:
492                 break;
493         }
494     }
495     else if (k == DIAGRAM)
496     {
497         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
498         switch (p)
499         {
500             case COLOR:
501                 return o->setColor(v);
502             default:
503                 break;
504         }
505     }
506     else if (k == LINK)
507     {
508         switch (p)
509         {
510             default:
511                 break;
512         }
513     }
514     else if (k == PORT)
515     {
516         model::Port* o = static_cast<model::Port*>(baseObject);
517         switch (p)
518         {
519             case DATATYPE:
520                 return o->setDataType(this, v);
521             default:
522                 break;
523         }
524     }
525     return FAIL;
526 }
527
528 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<bool>& /*v*/)
529 {
530     model::BaseObject* baseObject = getObject(uid);
531     if (baseObject == nullptr)
532     {
533         return FAIL;
534     }
535
536     if (k == ANNOTATION)
537     {
538         switch (p)
539         {
540             default:
541                 break;
542         }
543     }
544     else if (k == BLOCK)
545     {
546         switch (p)
547         {
548             default:
549                 break;
550         }
551     }
552     else if (k == DIAGRAM)
553     {
554         switch (p)
555         {
556             default:
557                 break;
558         }
559     }
560     else if (k == LINK)
561     {
562         switch (p)
563         {
564             default:
565                 break;
566         }
567     }
568     else if (k == PORT)
569     {
570         switch (p)
571         {
572             default:
573                 break;
574         }
575     }
576     return FAIL;
577 }
578
579 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<std::string>& v)
580 {
581     model::BaseObject* baseObject = getObject(uid);
582     if (baseObject == nullptr)
583     {
584         return FAIL;
585     }
586
587     if (k == ANNOTATION)
588     {
589         switch (p)
590         {
591             default:
592                 break;
593         }
594     }
595     else if (k == BLOCK)
596     {
597         model::Block* o = static_cast<model::Block*>(baseObject);
598         switch (p)
599         {
600             case DIAGRAM_CONTEXT:
601                 return o->setContext(v);
602             default:
603                 break;
604         }
605     }
606     else if (k == DIAGRAM)
607     {
608         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
609         switch (p)
610         {
611             case DIAGRAM_CONTEXT:
612                 return o->setContext(v);
613             default:
614                 break;
615         }
616     }
617     else if (k == LINK)
618     {
619         switch (p)
620         {
621             default:
622                 break;
623         }
624     }
625     else if (k == PORT)
626     {
627         switch (p)
628         {
629             default:
630                 break;
631         }
632     }
633     return FAIL;
634 }
635
636 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
637 {
638     model::BaseObject* baseObject = getObject(uid);
639     if (baseObject == nullptr)
640     {
641         return FAIL;
642     }
643
644     if (k == ANNOTATION)
645     {
646         switch (p)
647         {
648             default:
649                 break;
650         }
651     }
652     else if (k == BLOCK)
653     {
654         model::Block* o = static_cast<model::Block*>(baseObject);
655         switch (p)
656         {
657             case INPUTS:
658                 return o->setIn(v);
659             case OUTPUTS:
660                 return o->setOut(v);
661             case EVENT_INPUTS:
662                 return o->setEin(v);
663             case EVENT_OUTPUTS:
664                 return o->setEout(v);
665             case CHILDREN:
666                 return o->setChildren(v);
667             default:
668                 break;
669         }
670     }
671     else if (k == DIAGRAM)
672     {
673         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
674         switch (p)
675         {
676             case CHILDREN:
677                 return o->setChildren(v);
678             default:
679                 break;
680         }
681     }
682     else if (k == LINK)
683     {
684         switch (p)
685         {
686             default:
687                 break;
688         }
689     }
690     else if (k == PORT)
691     {
692         model::Port* o = static_cast<model::Port*>(baseObject);
693         switch (p)
694         {
695             case CONNECTED_SIGNALS:
696                 return o->setConnectedSignals(v);
697             default:
698                 break;
699         }
700     }
701     return FAIL;
702 }
703
704 } /* namespace org_scilab_modules_scicos */
705
706