Xcos MVC: implement from / to
[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             case PORT_KIND:
146                 o->getKind(v);
147                 return true;
148             default:
149                 break;
150         }
151     }
152     return false;
153 }
154
155 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool& v)
156 {
157
158     if (k == ANNOTATION)
159     {
160         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
161         switch (p)
162         {
163             default:
164                 break;
165         }
166     }
167     else if (k == BLOCK)
168     {
169         model::Block* o = static_cast<model::Block*>(getObject(uid));
170         switch (p)
171         {
172             default:
173                 break;
174         }
175     }
176     else if (k == DIAGRAM)
177     {
178         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
179         switch (p)
180         {
181             default:
182                 break;
183         }
184     }
185     else if (k == LINK)
186     {
187         model::Link* o = static_cast<model::Link*>(getObject(uid));
188         switch (p)
189         {
190             default:
191                 break;
192         }
193     }
194     else if (k == PORT)
195     {
196         model::Port* o = static_cast<model::Port*>(getObject(uid));
197         switch (p)
198         {
199             case IMPLICIT:
200                 o->getImplicit(v);
201                 return true;
202             default:
203                 break;
204         }
205     }
206     return false;
207 }
208
209 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v)
210 {
211
212     if (k == ANNOTATION)
213     {
214         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
215         switch (p)
216         {
217             default:
218                 break;
219         }
220     }
221     else if (k == BLOCK)
222     {
223         model::Block* o = static_cast<model::Block*>(getObject(uid));
224         switch (p)
225         {
226             case INTERFACE_FUNCTION:
227                 o->getInterfaceFunction(v);
228                 return true;
229             case SIM_FUNCTION_NAME:
230                 o->getSimFunctionName(v);
231                 return true;
232             case STYLE:
233                 o->getStyle(v);
234                 return true;
235             case LABEL:
236                 o->getLabel(v);
237                 return true;
238             case UID:
239                 o->getUID(v);
240                 return true;
241             default:
242                 break;
243         }
244     }
245     else if (k == DIAGRAM)
246     {
247         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
248         switch (p)
249         {
250             default:
251                 break;
252         }
253     }
254     else if (k == LINK)
255     {
256         model::Link* o = static_cast<model::Link*>(getObject(uid));
257         switch (p)
258         {
259             case LABEL:
260                 o->getLabel(v);
261                 return true;
262             default:
263                 break;
264         }
265     }
266     else if (k == PORT)
267     {
268         model::Port* o = static_cast<model::Port*>(getObject(uid));
269         switch (p)
270         {
271             case STYLE:
272                 o->getStyle(v);
273                 return true;
274             case LABEL:
275                 o->getLabel(v);
276                 return true;
277             default:
278                 break;
279         }
280     }
281     return false;
282 }
283
284 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v)
285 {
286
287     if (k == ANNOTATION)
288     {
289         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
290         switch (p)
291         {
292             case PARENT_DIAGRAM:
293                 v = o->getParentDiagram();
294                 return true;
295             case RELATED_TO:
296                 v = o->getRelatedTo();
297                 return true;
298             default:
299                 break;
300         }
301     }
302     else if (k == BLOCK)
303     {
304         model::Block* o = static_cast<model::Block*>(getObject(uid));
305         switch (p)
306         {
307             case PARENT_DIAGRAM:
308                 v = o->getParentDiagram();
309                 return true;
310             default:
311                 break;
312         }
313     }
314     else if (k == DIAGRAM)
315     {
316         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
317
318     }
319     else if (k == LINK)
320     {
321         model::Link* o = static_cast<model::Link*>(getObject(uid));
322         switch (p)
323         {
324             case PARENT_DIAGRAM:
325                 v = o->getParentDiagram();
326                 return true;
327             case SOURCE_PORT:
328                 o->getSourcePort(v);
329                 return true;
330             case DESTINATION_PORT:
331                 o->getDestinationPort(v);
332                 return true;
333             default:
334                 break;
335         }
336     }
337     else if (k == PORT)
338     {
339         model::Port* o = static_cast<model::Port*>(getObject(uid));
340         switch (p)
341         {
342             case CONNECTED_SIGNALS:
343                 v = o->getConnectedSignals().front();
344                 return true;
345             default:
346                 break;
347         }
348     }
349     else
350     {
351     }
352     return false;
353 }
354
355 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v)
356 {
357
358     if (k == ANNOTATION)
359     {
360         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
361         switch (p)
362         {
363             case GEOMETRY:
364                 o->getGeometry(v);
365                 return true;
366             default:
367                 break;
368         }
369     }
370     else if (k == BLOCK)
371     {
372         model::Block* o = static_cast<model::Block*>(getObject(uid));
373         switch (p)
374         {
375             case GEOMETRY:
376                 o->getGeometry(v);
377                 return true;
378             case ANGLE:
379                 o->getAngle(v);
380                 return true;
381             case STATE:
382                 o->getState(v);
383                 return true;
384             case DSTATE:
385                 o->getDState(v);
386                 return true;
387             case RPAR:
388                 o->getRpar(v);
389                 return true;
390             default:
391                 break;
392         }
393     }
394     else if (k == DIAGRAM)
395     {
396         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
397     }
398     else if (k == LINK)
399     {
400         model::Link* o = static_cast<model::Link*>(getObject(uid));
401         switch (p)
402         {
403             case CONTROL_POINTS:
404                 o->getControlPoints(v);
405                 return true;
406             case THICK:
407                 o->getThick(v);
408                 return true;
409             default:
410                 break;
411         }
412     }
413     else if (k == PORT)
414     {
415         model::Port* o = static_cast<model::Port*>(getObject(uid));
416     }
417     else
418     {
419     }
420     return false;
421 }
422
423 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v)
424 {
425
426     if (k == ANNOTATION)
427     {
428         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
429         switch (p)
430         {
431             default:
432                 break;
433         }
434     }
435     else if (k == BLOCK)
436     {
437         model::Block* o = static_cast<model::Block*>(getObject(uid));
438         switch (p)
439         {
440             case SIM_DEP_UT:
441                 o->getSimDepUT(v);
442                 return true;
443             case IPAR:
444                 o->getIpar(v);
445                 return true;
446             default:
447                 break;
448         }
449     }
450     else if (k == DIAGRAM)
451     {
452         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
453         switch (p)
454         {
455             default:
456                 break;
457         }
458     }
459     else if (k == LINK)
460     {
461         model::Link* o = static_cast<model::Link*>(getObject(uid));
462         switch (p)
463         {
464             default:
465                 break;
466         }
467     }
468     else if (k == PORT)
469     {
470         model::Port* o = static_cast<model::Port*>(getObject(uid));
471         switch (p)
472         {
473             case DATATYPE:
474                 o->getDataType(v);
475                 return true;
476             default:
477                 break;
478         }
479     }
480     return false;
481 }
482
483 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v)
484 {
485
486     if (k == ANNOTATION)
487     {
488         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
489         switch (p)
490         {
491             default:
492                 break;
493         }
494     }
495     else if (k == BLOCK)
496     {
497         model::Block* o = static_cast<model::Block*>(getObject(uid));
498         switch (p)
499         {
500             case EXPRS:
501                 o->getExprs(v);
502                 return true;
503             default:
504                 break;
505         }
506     }
507     else if (k == DIAGRAM)
508     {
509         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
510         switch (p)
511         {
512             default:
513                 break;
514         }
515     }
516     else if (k == LINK)
517     {
518         model::Link* o = static_cast<model::Link*>(getObject(uid));
519         switch (p)
520         {
521             default:
522                 break;
523         }
524     }
525     else if (k == PORT)
526     {
527         model::Port* o = static_cast<model::Port*>(getObject(uid));
528         switch (p)
529         {
530             default:
531                 break;
532         }
533     }
534     return false;
535 }
536
537 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v)
538 {
539
540     if (k == ANNOTATION)
541     {
542         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
543         switch (p)
544         {
545             default:
546                 break;
547         }
548     }
549     else if (k == BLOCK)
550     {
551         model::Block* o = static_cast<model::Block*>(getObject(uid));
552         switch (p)
553         {
554             case INPUTS:
555                 o->getIn(v);
556                 return true;
557             case OUTPUTS:
558                 o->getOut(v);
559                 return true;
560             case EVENT_INPUTS:
561                 o->getEin(v);
562                 return true;
563             case EVENT_OUTPUTS:
564                 o->getEout(v);
565                 return true;
566             case CHILDREN:
567                 o->getChildren(v);
568                 return true;
569             default:
570                 break;
571         }
572     }
573     else if (k == DIAGRAM)
574     {
575         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
576         switch (p)
577         {
578             case CHILDREN:
579                 v = o->getChildren();
580                 return true;
581             default:
582                 break;
583         }
584     }
585     else if (k == LINK)
586     {
587         model::Link* o = static_cast<model::Link*>(getObject(uid));
588         switch (p)
589         {
590             default:
591                 break;
592         }
593     }
594     else if (k == PORT)
595     {
596         model::Port* o = static_cast<model::Port*>(getObject(uid));
597         switch (p)
598         {
599             case CONNECTED_SIGNALS:
600                 v = o->getConnectedSignals();
601                 return true;
602             default:
603                 break;
604         }
605     }
606     return false;
607 }
608
609 } /* namespace org_scilab_modules_scicos */