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