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