GPL + CeCILL Header change
[scilab.git] / scilab / modules / scicos / src / cpp / Model_getObjectProperties.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 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double& v)  const
34 {
35     model::BaseObject* baseObject = getObject(uid);
36     if (baseObject == nullptr)
37     {
38         return false;
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                 o->getFiring(v);
80                 return true;
81             default:
82                 break;
83         }
84     }
85     return false;
86 }
87
88 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int& v) const
89 {
90     model::BaseObject* baseObject = getObject(uid);
91     if (baseObject == nullptr)
92     {
93         return false;
94     }
95
96     if (k == ANNOTATION)
97     {
98         switch (p)
99         {
100             default:
101                 break;
102         }
103     }
104     else if (k == BLOCK)
105     {
106         model::Block* o = static_cast<model::Block*>(baseObject);
107         switch (p)
108         {
109             case SIM_FUNCTION_API:
110                 o->getSimFunctionApi(v);
111                 return true;
112             default:
113                 break;
114         }
115     }
116     else if (k == DIAGRAM)
117     {
118         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
119         switch (p)
120         {
121             case DEBUG_LEVEL:
122                 o->getDebugLevel(v);
123                 return true;
124             default:
125                 break;
126         }
127     }
128     else if (k == LINK)
129     {
130         model::Link* o = static_cast<model::Link*>(baseObject);
131         switch (p)
132         {
133             case COLOR:
134                 o->getColor(v);
135                 return true;
136             case KIND:
137                 o->getKind(v);
138                 return true;
139             default:
140                 break;
141         }
142     }
143     else if (k == PORT)
144     {
145         model::Port* o = static_cast<model::Port*>(baseObject);
146         switch (p)
147         {
148             case PORT_KIND:
149                 o->getKind(v);
150                 return true;
151             default:
152                 break;
153         }
154     }
155     return false;
156 }
157
158 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool& v) const
159 {
160     model::BaseObject* baseObject = getObject(uid);
161     if (baseObject == nullptr)
162     {
163         return false;
164     }
165
166     if (k == ANNOTATION)
167     {
168         switch (p)
169         {
170             default:
171                 break;
172         }
173     }
174     else if (k == BLOCK)
175     {
176         switch (p)
177         {
178             default:
179                 break;
180         }
181     }
182     else if (k == DIAGRAM)
183     {
184         switch (p)
185         {
186             default:
187                 break;
188         }
189     }
190     else if (k == LINK)
191     {
192         switch (p)
193         {
194             default:
195                 break;
196         }
197     }
198     else if (k == PORT)
199     {
200         model::Port* o = static_cast<model::Port*>(baseObject);
201         switch (p)
202         {
203             case IMPLICIT:
204                 o->getImplicit(v);
205                 return true;
206             default:
207                 break;
208         }
209     }
210     return false;
211 }
212
213 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v) const
214 {
215     model::BaseObject* baseObject = getObject(uid);
216     if (baseObject == nullptr)
217     {
218         return false;
219     }
220
221     if (k == ANNOTATION)
222     {
223         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
224         switch (p)
225         {
226             case DESCRIPTION:
227                 o->getDescription(v);
228                 return true;
229             case FONT:
230                 o->getFont(v);
231                 return true;
232             case FONT_SIZE:
233                 o->getFontSize(v);
234                 return true;
235             case STYLE:
236                 o->getStyle(v);
237                 return true;
238             case UID:
239                 o->getUID(v);
240                 return true;
241             default:
242                 break;
243         }
244     }
245     else if (k == BLOCK)
246     {
247         model::Block* o = static_cast<model::Block*>(baseObject);
248         switch (p)
249         {
250             case INTERFACE_FUNCTION:
251                 o->getInterfaceFunction(v);
252                 return true;
253             case SIM_FUNCTION_NAME:
254                 o->getSimFunctionName(v);
255                 return true;
256             case SIM_BLOCKTYPE:
257                 o->getSimBlocktype(v);
258                 return true;
259             case STYLE:
260                 o->getStyle(v);
261                 return true;
262             case DESCRIPTION:
263                 o->getDescription(v);
264                 return true;
265             case LABEL:
266                 o->getLabel(v);
267                 return true;
268             case UID:
269                 o->getUID(v);
270                 return true;
271             default:
272                 break;
273         }
274     }
275     else if (k == DIAGRAM)
276     {
277         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
278         switch (p)
279         {
280             case TITLE:
281                 o->getTitle(v);
282                 return true;
283             case PATH:
284                 o->getPath(v);
285                 return true;
286             case VERSION_NUMBER:
287                 o->getVersionNumber(v);
288                 return true;
289             default:
290                 break;
291         }
292     }
293     else if (k == LINK)
294     {
295         model::Link* o = static_cast<model::Link*>(baseObject);
296         switch (p)
297         {
298             case LABEL:
299                 o->getLabel(v);
300                 return true;
301             case UID:
302                 o->getUID(v);
303                 return true;
304             default:
305                 break;
306         }
307     }
308     else if (k == PORT)
309     {
310         model::Port* o = static_cast<model::Port*>(baseObject);
311         switch (p)
312         {
313             case STYLE:
314                 o->getStyle(v);
315                 return true;
316             case LABEL:
317                 o->getLabel(v);
318                 return true;
319             case UID:
320                 o->getUID(v);
321                 return true;
322             default:
323                 break;
324         }
325     }
326     return false;
327 }
328
329 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v) const
330 {
331     model::BaseObject* baseObject = getObject(uid);
332     if (baseObject == nullptr)
333     {
334         return false;
335     }
336
337     if (k == ANNOTATION)
338     {
339         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
340         switch (p)
341         {
342             case PARENT_DIAGRAM:
343                 o->getParentDiagram(v);
344                 return true;
345             case PARENT_BLOCK:
346                 o->getParentBlock(v);
347                 return true;
348             case RELATED_TO:
349                 v = o->getRelatedTo();
350                 return true;
351             default:
352                 break;
353         }
354     }
355     else if (k == BLOCK)
356     {
357         model::Block* o = static_cast<model::Block*>(baseObject);
358         switch (p)
359         {
360             case PARENT_DIAGRAM:
361                 o->getParentDiagram(v);
362                 return true;
363             case PARENT_BLOCK:
364                 o->getParentBlock(v);
365                 return true;
366             case PORT_REFERENCE:
367                 o->getPortReference(v);
368                 return true;
369             default:
370                 break;
371         }
372     }
373     else if (k == DIAGRAM)
374     {
375
376     }
377     else if (k == LINK)
378     {
379         model::Link* o = static_cast<model::Link*>(baseObject);
380         switch (p)
381         {
382             case PARENT_DIAGRAM:
383                 o->getParentDiagram(v);
384                 return true;
385             case PARENT_BLOCK:
386                 o->getParentBlock(v);
387                 return true;
388             case SOURCE_PORT:
389                 o->getSourcePort(v);
390                 return true;
391             case DESTINATION_PORT:
392                 o->getDestinationPort(v);
393                 return true;
394             default:
395                 break;
396         }
397     }
398     else if (k == PORT)
399     {
400         model::Port* o = static_cast<model::Port*>(baseObject);
401         switch (p)
402         {
403             case SOURCE_BLOCK:
404                 o->getSourceBlock(v);
405                 return true;
406             case CONNECTED_SIGNALS:
407                 v = o->getConnectedSignals().front();
408                 return true;
409             default:
410                 break;
411         }
412     }
413     return false;
414 }
415
416 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v) const
417 {
418     model::BaseObject* baseObject = getObject(uid);
419     if (baseObject == nullptr)
420     {
421         return false;
422     }
423
424     if (k == ANNOTATION)
425     {
426         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
427         switch (p)
428         {
429             case GEOMETRY:
430                 o->getGeometry(v);
431                 return true;
432             default:
433                 break;
434         }
435     }
436     else if (k == BLOCK)
437     {
438         model::Block* o = static_cast<model::Block*>(baseObject);
439         switch (p)
440         {
441             case GEOMETRY:
442                 o->getGeometry(v);
443                 return true;
444             case ANGLE:
445                 o->getAngle(v);
446                 return true;
447             case EXPRS:
448                 o->getExprs(v);
449                 return true;
450             case STATE:
451                 o->getState(v);
452                 return true;
453             case DSTATE:
454                 o->getDState(v);
455                 return true;
456             case ODSTATE:
457                 o->getODState(v);
458                 return true;
459             case RPAR:
460                 o->getRpar(v);
461                 return true;
462             case OPAR:
463                 o->getOpar(v);
464                 return true;
465             case EQUATIONS:
466                 o->getEquations(v);
467                 return true;
468             default:
469                 break;
470         }
471     }
472     else if (k == DIAGRAM)
473     {
474         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
475         switch (p)
476         {
477             case PROPERTIES:
478                 o->getProperties(v);
479                 return true;
480             default:
481                 break;
482         }
483     }
484     else if (k == LINK)
485     {
486         model::Link* o = static_cast<model::Link*>(baseObject);
487         switch (p)
488         {
489             case CONTROL_POINTS:
490                 o->getControlPoints(v);
491                 return true;
492             case THICK:
493                 o->getThick(v);
494                 return true;
495             default:
496                 break;
497         }
498     }
499     else if (k == PORT)
500     {
501         switch (p)
502         {
503             default:
504                 break;
505         }
506     }
507     return false;
508 }
509
510 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v) const
511 {
512     model::BaseObject* baseObject = getObject(uid);
513     if (baseObject == nullptr)
514     {
515         return false;
516     }
517
518     if (k == ANNOTATION)
519     {
520         switch (p)
521         {
522             default:
523                 break;
524         }
525     }
526     else if (k == BLOCK)
527     {
528         model::Block* o = static_cast<model::Block*>(baseObject);
529         switch (p)
530         {
531             case SIM_DEP_UT:
532                 o->getSimDepUT(v);
533                 return true;
534             case NZCROSS:
535                 o->getNZcross(v);
536                 return true;
537             case NMODE:
538                 o->getNMode(v);
539                 return true;
540             case IPAR:
541                 o->getIpar(v);
542                 return true;
543             case COLOR:
544                 o->getChildrenColor(v);
545                 return true;
546             default:
547                 break;
548         }
549     }
550     else if (k == DIAGRAM)
551     {
552         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
553         switch (p)
554         {
555             case COLOR:
556                 o->getColor(v);
557                 return true;
558             default:
559                 break;
560         }
561     }
562     else if (k == LINK)
563     {
564         switch (p)
565         {
566             default:
567                 break;
568         }
569     }
570     else if (k == PORT)
571     {
572         model::Port* o = static_cast<model::Port*>(baseObject);
573         switch (p)
574         {
575             case DATATYPE:
576                 o->getDataType(v);
577                 return true;
578             default:
579                 break;
580         }
581     }
582     return false;
583 }
584
585 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<bool>& /*v*/) const
586 {
587     model::BaseObject* baseObject = getObject(uid);
588     if (baseObject == nullptr)
589     {
590         return false;
591     }
592
593     if (k == ANNOTATION)
594     {
595         switch (p)
596         {
597             default:
598                 break;
599         }
600     }
601     else if (k == BLOCK)
602     {
603         switch (p)
604         {
605             default:
606                 break;
607         }
608     }
609     else if (k == DIAGRAM)
610     {
611         switch (p)
612         {
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 false;
634 }
635
636 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v) const
637 {
638     model::BaseObject* baseObject = getObject(uid);
639     if (baseObject == nullptr)
640     {
641         return false;
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 DIAGRAM_CONTEXT:
658                 o->getContext(v);
659                 return true;
660             default:
661                 break;
662         }
663     }
664     else if (k == DIAGRAM)
665     {
666         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
667         switch (p)
668         {
669             case DIAGRAM_CONTEXT:
670                 o->getContext(v);
671                 return true;
672             default:
673                 break;
674         }
675     }
676     else if (k == LINK)
677     {
678         switch (p)
679         {
680             default:
681                 break;
682         }
683     }
684     else if (k == PORT)
685     {
686         switch (p)
687         {
688             default:
689                 break;
690         }
691     }
692     return false;
693 }
694
695 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v) const
696 {
697     model::BaseObject* baseObject = getObject(uid);
698     if (baseObject == nullptr)
699     {
700         return false;
701     }
702
703     if (k == ANNOTATION)
704     {
705         switch (p)
706         {
707             default:
708                 break;
709         }
710     }
711     else if (k == BLOCK)
712     {
713         model::Block* o = static_cast<model::Block*>(baseObject);
714         switch (p)
715         {
716             case INPUTS:
717                 o->getIn(v);
718                 return true;
719             case OUTPUTS:
720                 o->getOut(v);
721                 return true;
722             case EVENT_INPUTS:
723                 o->getEin(v);
724                 return true;
725             case EVENT_OUTPUTS:
726                 o->getEout(v);
727                 return true;
728             case CHILDREN:
729                 o->getChildren(v);
730                 return true;
731             default:
732                 break;
733         }
734     }
735     else if (k == DIAGRAM)
736     {
737         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
738         switch (p)
739         {
740             case CHILDREN:
741                 o->getChildren(v);
742                 return true;
743             default:
744                 break;
745         }
746     }
747     else if (k == LINK)
748     {
749         switch (p)
750         {
751             default:
752                 break;
753         }
754     }
755     else if (k == PORT)
756     {
757         model::Port* o = static_cast<model::Port*>(baseObject);
758         switch (p)
759         {
760             case CONNECTED_SIGNALS:
761                 v = o->getConnectedSignals();
762                 return true;
763             default:
764                 break;
765         }
766     }
767     return false;
768 }
769
770 } /* namespace org_scilab_modules_scicos */