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