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