5707c1d470d5b9b706bca1c26cdbe865f3189fbf
[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             default:
176                 break;
177         }
178     }
179     return false;
180 }
181
182 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v)
183 {
184
185     if (k == ANNOTATION)
186     {
187         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
188         switch (p)
189         {
190             default:
191                 break;
192         }
193     }
194     else if (k == BLOCK)
195     {
196         model::Block* o = static_cast<model::Block*>(getObject(uid));
197         switch (p)
198         {
199             default:
200                 break;
201         }
202     }
203     else if (k == DIAGRAM)
204     {
205         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
206         switch (p)
207         {
208             default:
209                 break;
210         }
211     }
212     else if (k == LINK)
213     {
214         model::Link* o = static_cast<model::Link*>(getObject(uid));
215         switch (p)
216         {
217             default:
218                 break;
219         }
220     }
221     else if (k == PORT)
222     {
223         model::Port* o = static_cast<model::Port*>(getObject(uid));
224         switch (p)
225         {
226             default:
227                 break;
228         }
229     }
230     return false;
231 }
232
233 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v)
234 {
235
236     if (k == ANNOTATION)
237     {
238         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
239         switch (p)
240         {
241             case PARENT_DIAGRAM:
242                 v = o->getParentDiagram();
243                 return true;
244             case RELATED_TO:
245                 v = o->getRelatedTo();
246                 return true;
247             default:
248                 break;
249         }
250     }
251     else if (k == BLOCK)
252     {
253         model::Block* o = static_cast<model::Block*>(getObject(uid));
254         switch (p)
255         {
256             case PARENT_DIAGRAM:
257                 v = o->getParentDiagram();
258                 return true;
259             default:
260                 break;
261         }
262     }
263     else if (k == DIAGRAM)
264     {
265         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
266
267     }
268     else if (k == LINK)
269     {
270         model::Link* o = static_cast<model::Link*>(getObject(uid));
271         switch (p)
272         {
273             case PARENT_DIAGRAM:
274                 v = o->getParentDiagram();
275                 return true;
276             default:
277                 break;
278         }
279     }
280     else if (k == PORT)
281     {
282         model::Port* o = static_cast<model::Port*>(getObject(uid));
283     }
284     else
285     {
286     }
287     return false;
288 }
289
290 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v)
291 {
292
293     if (k == ANNOTATION)
294     {
295         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
296         switch (p)
297         {
298             case GEOMETRY:
299                 o->getGeometry(v);
300                 return true;
301             default:
302                 break;
303         }
304     }
305     else if (k == BLOCK)
306     {
307         model::Block* o = static_cast<model::Block*>(getObject(uid));
308         switch (p)
309         {
310             case GEOMETRY:
311                 o->getGeometry(v);
312                 return true;
313             default:
314                 break;
315         }
316     }
317     else if (k == DIAGRAM)
318     {
319         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
320     }
321     else if (k == LINK)
322     {
323         model::Link* o = static_cast<model::Link*>(getObject(uid));
324     }
325     else if (k == PORT)
326     {
327         model::Port* o = static_cast<model::Port*>(getObject(uid));
328     }
329     else
330     {
331     }
332     return false;
333 }
334
335 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v)
336 {
337
338     if (k == ANNOTATION)
339     {
340         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
341         switch (p)
342         {
343             default:
344                 break;
345         }
346     }
347     else if (k == BLOCK)
348     {
349         model::Block* o = static_cast<model::Block*>(getObject(uid));
350         switch (p)
351         {
352             default:
353                 break;
354         }
355     }
356     else if (k == DIAGRAM)
357     {
358         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
359         switch (p)
360         {
361             default:
362                 break;
363         }
364     }
365     else if (k == LINK)
366     {
367         model::Link* o = static_cast<model::Link*>(getObject(uid));
368         switch (p)
369         {
370             default:
371                 break;
372         }
373     }
374     else if (k == PORT)
375     {
376         model::Port* o = static_cast<model::Port*>(getObject(uid));
377         switch (p)
378         {
379             default:
380                 break;
381         }
382     }
383     return false;
384 }
385
386 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector< std::string >& v)
387 {
388
389     if (k == ANNOTATION)
390     {
391         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
392         switch (p)
393         {
394             default:
395                 break;
396         }
397     }
398     else if (k == BLOCK)
399     {
400         model::Block* o = static_cast<model::Block*>(getObject(uid));
401         switch (p)
402         {
403             default:
404                 break;
405         }
406     }
407     else if (k == DIAGRAM)
408     {
409         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
410         switch (p)
411         {
412             default:
413                 break;
414         }
415     }
416     else if (k == LINK)
417     {
418         model::Link* o = static_cast<model::Link*>(getObject(uid));
419         switch (p)
420         {
421             default:
422                 break;
423         }
424     }
425     else if (k == PORT)
426     {
427         model::Port* o = static_cast<model::Port*>(getObject(uid));
428         switch (p)
429         {
430             default:
431                 break;
432         }
433     }
434     return false;
435 }
436
437 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v)
438 {
439
440     if (k == ANNOTATION)
441     {
442         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
443         switch (p)
444         {
445             default:
446                 break;
447         }
448     }
449     else if (k == BLOCK)
450     {
451         model::Block* o = static_cast<model::Block*>(getObject(uid));
452         switch (p)
453         {
454             default:
455                 break;
456         }
457     }
458     else if (k == DIAGRAM)
459     {
460         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
461         switch (p)
462         {
463             default:
464                 break;
465         }
466     }
467     else if (k == LINK)
468     {
469         model::Link* o = static_cast<model::Link*>(getObject(uid));
470         switch (p)
471         {
472             default:
473                 break;
474         }
475     }
476     else if (k == PORT)
477     {
478         model::Port* o = static_cast<model::Port*>(getObject(uid));
479         switch (p)
480         {
481             default:
482                 break;
483         }
484     }
485     return false;
486 }
487
488 } /* namespace org_scilab_modules_scicos */