Xcos MVC: implement graphics.flip, theta, exprs, pin, pout
[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             case ANGLE:
314                 o->getAngle(v);
315                 return true;
316             default:
317                 break;
318         }
319     }
320     else if (k == DIAGRAM)
321     {
322         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
323     }
324     else if (k == LINK)
325     {
326         model::Link* o = static_cast<model::Link*>(getObject(uid));
327     }
328     else if (k == PORT)
329     {
330         model::Port* o = static_cast<model::Port*>(getObject(uid));
331     }
332     else
333     {
334     }
335     return false;
336 }
337
338 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v)
339 {
340
341     if (k == ANNOTATION)
342     {
343         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
344         switch (p)
345         {
346             default:
347                 break;
348         }
349     }
350     else if (k == BLOCK)
351     {
352         model::Block* o = static_cast<model::Block*>(getObject(uid));
353         switch (p)
354         {
355             default:
356                 break;
357         }
358     }
359     else if (k == DIAGRAM)
360     {
361         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
362         switch (p)
363         {
364             default:
365                 break;
366         }
367     }
368     else if (k == LINK)
369     {
370         model::Link* o = static_cast<model::Link*>(getObject(uid));
371         switch (p)
372         {
373             default:
374                 break;
375         }
376     }
377     else if (k == PORT)
378     {
379         model::Port* o = static_cast<model::Port*>(getObject(uid));
380         switch (p)
381         {
382             default:
383                 break;
384         }
385     }
386     return false;
387 }
388
389 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector< std::string >& v)
390 {
391
392     if (k == ANNOTATION)
393     {
394         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
395         switch (p)
396         {
397             default:
398                 break;
399         }
400     }
401     else if (k == BLOCK)
402     {
403         model::Block* o = static_cast<model::Block*>(getObject(uid));
404         switch (p)
405         {
406             case EXPRS:
407                 o->getExprs(v);
408                 return true;
409             default:
410                 break;
411         }
412     }
413     else if (k == DIAGRAM)
414     {
415         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
416         switch (p)
417         {
418             default:
419                 break;
420         }
421     }
422     else if (k == LINK)
423     {
424         model::Link* o = static_cast<model::Link*>(getObject(uid));
425         switch (p)
426         {
427             default:
428                 break;
429         }
430     }
431     else if (k == PORT)
432     {
433         model::Port* o = static_cast<model::Port*>(getObject(uid));
434         switch (p)
435         {
436             default:
437                 break;
438         }
439     }
440     return false;
441 }
442
443 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v)
444 {
445
446     if (k == ANNOTATION)
447     {
448         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
449         switch (p)
450         {
451             default:
452                 break;
453         }
454     }
455     else if (k == BLOCK)
456     {
457         model::Block* o = static_cast<model::Block*>(getObject(uid));
458         switch (p)
459         {
460             case INPUTS:
461                 v = o->getIn();
462                 return true;
463             case OUTPUTS:
464                 v = o->getOut();
465                 return true;
466             default:
467                 break;
468         }
469     }
470     else if (k == DIAGRAM)
471     {
472         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
473         switch (p)
474         {
475             default:
476                 break;
477         }
478     }
479     else if (k == LINK)
480     {
481         model::Link* o = static_cast<model::Link*>(getObject(uid));
482         switch (p)
483         {
484             default:
485                 break;
486         }
487     }
488     else if (k == PORT)
489     {
490         model::Port* o = static_cast<model::Port*>(getObject(uid));
491         switch (p)
492         {
493             default:
494                 break;
495         }
496     }
497     return false;
498 }
499
500 } /* namespace org_scilab_modules_scicos */