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