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