Xcos MVC: add a default explorer view
[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  *  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 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double& v)  const
30 {
31     model::BaseObject* baseObject = getObject(uid);
32     if (baseObject == nullptr)
33     {
34         return false;
35     }
36
37     if (k == ANNOTATION)
38     {
39         switch (p)
40         {
41             default:
42                 break;
43         }
44     }
45     else if (k == BLOCK)
46     {
47         switch (p)
48         {
49             default:
50                 break;
51         }
52     }
53     else if (k == DIAGRAM)
54     {
55         switch (p)
56         {
57             default:
58                 break;
59         }
60     }
61     else if (k == LINK)
62     {
63         switch (p)
64         {
65             default:
66                 break;
67         }
68     }
69     else if (k == PORT)
70     {
71         model::Port* o = static_cast<model::Port*>(baseObject);
72         switch (p)
73         {
74             case FIRING:
75                 o->getFiring(v);
76                 return true;
77             default:
78                 break;
79         }
80     }
81     return false;
82 }
83
84 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int& v) const
85 {
86     model::BaseObject* baseObject = getObject(uid);
87     if (baseObject == nullptr)
88     {
89         return false;
90     }
91
92     if (k == ANNOTATION)
93     {
94         switch (p)
95         {
96             default:
97                 break;
98         }
99     }
100     else if (k == BLOCK)
101     {
102         model::Block* o = static_cast<model::Block*>(baseObject);
103         switch (p)
104         {
105             case SIM_FUNCTION_API:
106                 o->getSimFunctionApi(v);
107                 return true;
108             default:
109                 break;
110         }
111     }
112     else if (k == DIAGRAM)
113     {
114         switch (p)
115         {
116             default:
117                 break;
118         }
119     }
120     else if (k == LINK)
121     {
122         model::Link* o = static_cast<model::Link*>(baseObject);
123         switch (p)
124         {
125             case COLOR:
126                 o->getColor(v);
127                 return true;
128             case KIND:
129                 o->getKind(v);
130                 return true;
131             default:
132                 break;
133         }
134     }
135     else if (k == PORT)
136     {
137         model::Port* o = static_cast<model::Port*>(baseObject);
138         switch (p)
139         {
140             case PORT_KIND:
141                 o->getKind(v);
142                 return true;
143             default:
144                 break;
145         }
146     }
147     return false;
148 }
149
150 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool& v) const
151 {
152     model::BaseObject* baseObject = getObject(uid);
153     if (baseObject == nullptr)
154     {
155         return false;
156     }
157
158     if (k == ANNOTATION)
159     {
160         switch (p)
161         {
162             default:
163                 break;
164         }
165     }
166     else if (k == BLOCK)
167     {
168         switch (p)
169         {
170             default:
171                 break;
172         }
173     }
174     else if (k == DIAGRAM)
175     {
176         switch (p)
177         {
178             default:
179                 break;
180         }
181     }
182     else if (k == LINK)
183     {
184         switch (p)
185         {
186             default:
187                 break;
188         }
189     }
190     else if (k == PORT)
191     {
192         model::Port* o = static_cast<model::Port*>(baseObject);
193         switch (p)
194         {
195             case IMPLICIT:
196                 o->getImplicit(v);
197                 return true;
198             default:
199                 break;
200         }
201     }
202     return false;
203 }
204
205 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v) const
206 {
207     model::BaseObject* baseObject = getObject(uid);
208     if (baseObject == nullptr)
209     {
210         return false;
211     }
212
213     if (k == ANNOTATION)
214     {
215         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
216         switch (p)
217         {
218             case DESCRIPTION:
219                 o->getDescription(v);
220                 return true;
221             case FONT:
222                 o->getFont(v);
223                 return true;
224             case FONT_SIZE:
225                 o->getFontSize(v);
226                 return true;
227             default:
228                 break;
229         }
230     }
231     else if (k == BLOCK)
232     {
233         model::Block* o = static_cast<model::Block*>(baseObject);
234         switch (p)
235         {
236             case INTERFACE_FUNCTION:
237                 o->getInterfaceFunction(v);
238                 return true;
239             case SIM_FUNCTION_NAME:
240                 o->getSimFunctionName(v);
241                 return true;
242             case SIM_BLOCKTYPE:
243                 o->getSimBlocktype(v);
244                 return true;
245             case STYLE:
246                 o->getStyle(v);
247                 return true;
248             case LABEL:
249                 o->getLabel(v);
250                 return true;
251             case UID:
252                 o->getUID(v);
253                 return true;
254             default:
255                 break;
256         }
257     }
258     else if (k == DIAGRAM)
259     {
260         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
261         switch (p)
262         {
263             case TITLE:
264                 o->getTitle(v);
265                 return true;
266             case PATH:
267                 o->getPath(v);
268                 return true;
269             case VERSION_NUMBER:
270                 o->getVersionNumber(v);
271                 return true;
272             default:
273                 break;
274         }
275     }
276     else if (k == LINK)
277     {
278         model::Link* o = static_cast<model::Link*>(baseObject);
279         switch (p)
280         {
281             case LABEL:
282                 o->getLabel(v);
283                 return true;
284             default:
285                 break;
286         }
287     }
288     else if (k == PORT)
289     {
290         model::Port* o = static_cast<model::Port*>(baseObject);
291         switch (p)
292         {
293             case STYLE:
294                 o->getStyle(v);
295                 return true;
296             case LABEL:
297                 o->getLabel(v);
298                 return true;
299             default:
300                 break;
301         }
302     }
303     return false;
304 }
305
306 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v) const
307 {
308     model::BaseObject* baseObject = getObject(uid);
309     if (baseObject == nullptr)
310     {
311         return false;
312     }
313
314     if (k == ANNOTATION)
315     {
316         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
317         switch (p)
318         {
319             case PARENT_DIAGRAM:
320                 o->getParentDiagram(v);
321                 return true;
322             case PARENT_BLOCK:
323                 o->getParentBlock(v);
324                 return true;
325             case RELATED_TO:
326                 v = o->getRelatedTo();
327                 return true;
328             default:
329                 break;
330         }
331     }
332     else if (k == BLOCK)
333     {
334         model::Block* o = static_cast<model::Block*>(baseObject);
335         switch (p)
336         {
337             case PARENT_DIAGRAM:
338                 o->getParentDiagram(v);
339                 return true;
340             case PARENT_BLOCK:
341                 o->getParentBlock(v);
342                 return true;
343             case PORT_REFERENCE:
344                 o->getPortReference(v);
345                 return true;
346             default:
347                 break;
348         }
349     }
350     else if (k == DIAGRAM)
351     {
352
353     }
354     else if (k == LINK)
355     {
356         model::Link* o = static_cast<model::Link*>(baseObject);
357         switch (p)
358         {
359             case PARENT_DIAGRAM:
360                 o->getParentDiagram(v);
361                 return true;
362             case PARENT_BLOCK:
363                 o->getParentBlock(v);
364                 return true;
365             case SOURCE_PORT:
366                 o->getSourcePort(v);
367                 return true;
368             case DESTINATION_PORT:
369                 o->getDestinationPort(v);
370                 return true;
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 SOURCE_BLOCK:
381                 o->getSourceBlock(v);
382                 return true;
383             case CONNECTED_SIGNALS:
384                 v = o->getConnectedSignals().front();
385                 return true;
386             default:
387                 break;
388         }
389     }
390     return false;
391 }
392
393 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v) const
394 {
395     model::BaseObject* baseObject = getObject(uid);
396     if (baseObject == nullptr)
397     {
398         return false;
399     }
400
401     if (k == ANNOTATION)
402     {
403         model::Annotation* o = static_cast<model::Annotation*>(baseObject);
404         switch (p)
405         {
406             case GEOMETRY:
407                 o->getGeometry(v);
408                 return true;
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                 o->getGeometry(v);
420                 return true;
421             case ANGLE:
422                 o->getAngle(v);
423                 return true;
424             case EXPRS:
425                 o->getExprs(v);
426                 return true;
427             case STATE:
428                 o->getState(v);
429                 return true;
430             case DSTATE:
431                 o->getDState(v);
432                 return true;
433             case ODSTATE:
434                 o->getODState(v);
435                 return true;
436             case RPAR:
437                 o->getRpar(v);
438                 return true;
439             case OPAR:
440                 o->getOpar(v);
441                 return true;
442             default:
443                 break;
444         }
445     }
446     else if (k == DIAGRAM)
447     {
448         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
449         switch (p)
450         {
451             case PROPERTIES:
452                 o->getProperties(v);
453                 return true;
454             default:
455                 break;
456         }
457     }
458     else if (k == LINK)
459     {
460         model::Link* o = static_cast<model::Link*>(baseObject);
461         switch (p)
462         {
463             case CONTROL_POINTS:
464                 o->getControlPoints(v);
465                 return true;
466             case THICK:
467                 o->getThick(v);
468                 return true;
469             default:
470                 break;
471         }
472     }
473     else if (k == PORT)
474     {
475         switch (p)
476         {
477             default:
478                 break;
479         }
480     }
481     return false;
482 }
483
484 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v) const
485 {
486     model::BaseObject* baseObject = getObject(uid);
487     if (baseObject == nullptr)
488     {
489         return false;
490     }
491
492     if (k == ANNOTATION)
493     {
494         switch (p)
495         {
496             default:
497                 break;
498         }
499     }
500     else if (k == BLOCK)
501     {
502         model::Block* o = static_cast<model::Block*>(baseObject);
503         switch (p)
504         {
505             case SIM_DEP_UT:
506                 o->getSimDepUT(v);
507                 return true;
508             case NZCROSS:
509                 o->getNZcross(v);
510                 return true;
511             case NMODE:
512                 o->getNMode(v);
513                 return true;
514             case IPAR:
515                 o->getIpar(v);
516                 return true;
517             default:
518                 break;
519         }
520     }
521     else if (k == DIAGRAM)
522     {
523         switch (p)
524         {
525             default:
526                 break;
527         }
528     }
529     else if (k == LINK)
530     {
531         switch (p)
532         {
533             default:
534                 break;
535         }
536     }
537     else if (k == PORT)
538     {
539         model::Port* o = static_cast<model::Port*>(baseObject);
540         switch (p)
541         {
542             case DATATYPE:
543                 o->getDataType(v);
544                 return true;
545             default:
546                 break;
547         }
548     }
549     return false;
550 }
551
552 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v) const
553 {
554     model::BaseObject* baseObject = getObject(uid);
555     if (baseObject == nullptr)
556     {
557         return false;
558     }
559
560     if (k == ANNOTATION)
561     {
562         switch (p)
563         {
564             default:
565                 break;
566         }
567     }
568     else if (k == BLOCK)
569     {
570         model::Block* o = static_cast<model::Block*>(baseObject);
571         switch (p)
572         {
573             case EQUATIONS:
574                 o->getEquations(v);
575                 return true;
576             default:
577                 break;
578         }
579     }
580     else if (k == DIAGRAM)
581     {
582         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
583         switch (p)
584         {
585             case DIAGRAM_CONTEXT:
586                 o->getContext(v);
587                 return true;
588             default:
589                 break;
590         }
591     }
592     else if (k == LINK)
593     {
594         switch (p)
595         {
596             default:
597                 break;
598         }
599     }
600     else if (k == PORT)
601     {
602         switch (p)
603         {
604             default:
605                 break;
606         }
607     }
608     return false;
609 }
610
611 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v) const
612 {
613     model::BaseObject* baseObject = getObject(uid);
614     if (baseObject == nullptr)
615     {
616         return false;
617     }
618
619     if (k == ANNOTATION)
620     {
621         switch (p)
622         {
623             default:
624                 break;
625         }
626     }
627     else if (k == BLOCK)
628     {
629         model::Block* o = static_cast<model::Block*>(baseObject);
630         switch (p)
631         {
632             case INPUTS:
633                 o->getIn(v);
634                 return true;
635             case OUTPUTS:
636                 o->getOut(v);
637                 return true;
638             case EVENT_INPUTS:
639                 o->getEin(v);
640                 return true;
641             case EVENT_OUTPUTS:
642                 o->getEout(v);
643                 return true;
644             case CHILDREN:
645                 o->getChildren(v);
646                 return true;
647             default:
648                 break;
649         }
650     }
651     else if (k == DIAGRAM)
652     {
653         model::Diagram* o = static_cast<model::Diagram*>(baseObject);
654         switch (p)
655         {
656             case CHILDREN:
657                 o->getChildren(v);
658                 return true;
659             default:
660                 break;
661         }
662     }
663     else if (k == LINK)
664     {
665         switch (p)
666         {
667             default:
668                 break;
669         }
670     }
671     else if (k == PORT)
672     {
673         model::Port* o = static_cast<model::Port*>(baseObject);
674         switch (p)
675         {
676             case CONNECTED_SIGNALS:
677                 v = o->getConnectedSignals();
678                 return true;
679             default:
680                 break;
681         }
682     }
683     return false;
684 }
685
686 } /* namespace org_scilab_modules_scicos */