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