Xcos MVC: implement in_style / out_style / in_label / out_label / style
[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 STYLE:
203                 o->getStyle(v);
204                 return true;
205             case LABEL:
206                 o->getLabel(v);
207                 return true;
208             default:
209                 break;
210         }
211     }
212     else if (k == DIAGRAM)
213     {
214         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
215         switch (p)
216         {
217             default:
218                 break;
219         }
220     }
221     else if (k == LINK)
222     {
223         model::Link* o = static_cast<model::Link*>(getObject(uid));
224         switch (p)
225         {
226             default:
227                 break;
228         }
229     }
230     else if (k == PORT)
231     {
232         model::Port* o = static_cast<model::Port*>(getObject(uid));
233         switch (p)
234         {
235             case STYLE:
236                 o->getStyle(v);
237                 return true;
238             case LABEL:
239                 o->getLabel(v);
240                 return true;
241             default:
242                 break;
243         }
244     }
245     return false;
246 }
247
248 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v)
249 {
250
251     if (k == ANNOTATION)
252     {
253         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
254         switch (p)
255         {
256             case PARENT_DIAGRAM:
257                 v = o->getParentDiagram();
258                 return true;
259             case RELATED_TO:
260                 v = o->getRelatedTo();
261                 return true;
262             default:
263                 break;
264         }
265     }
266     else if (k == BLOCK)
267     {
268         model::Block* o = static_cast<model::Block*>(getObject(uid));
269         switch (p)
270         {
271             case PARENT_DIAGRAM:
272                 v = o->getParentDiagram();
273                 return true;
274             default:
275                 break;
276         }
277     }
278     else if (k == DIAGRAM)
279     {
280         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
281
282     }
283     else if (k == LINK)
284     {
285         model::Link* o = static_cast<model::Link*>(getObject(uid));
286         switch (p)
287         {
288             case PARENT_DIAGRAM:
289                 v = o->getParentDiagram();
290                 return true;
291             case SOURCE_PORT:
292                 v = o->getSourcePort();
293                 return true;
294             case DESTINATION_PORT:
295                 v = o->getDestinationPort();
296                 return true;
297             default:
298                 break;
299         }
300     }
301     else if (k == PORT)
302     {
303         model::Port* o = static_cast<model::Port*>(getObject(uid));
304         switch (p)
305         {
306             case CONNECTED_SIGNALS:
307                 v = o->getConnectedSignals().front();
308                 return true;
309             default:
310                 break;
311         }
312     }
313     else
314     {
315     }
316     return false;
317 }
318
319 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v)
320 {
321
322     if (k == ANNOTATION)
323     {
324         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
325         switch (p)
326         {
327             case GEOMETRY:
328                 o->getGeometry(v);
329                 return true;
330             default:
331                 break;
332         }
333     }
334     else if (k == BLOCK)
335     {
336         model::Block* o = static_cast<model::Block*>(getObject(uid));
337         switch (p)
338         {
339             case GEOMETRY:
340                 o->getGeometry(v);
341                 return true;
342             case ANGLE:
343                 o->getAngle(v);
344                 return true;
345             default:
346                 break;
347         }
348     }
349     else if (k == DIAGRAM)
350     {
351         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
352     }
353     else if (k == LINK)
354     {
355         model::Link* o = static_cast<model::Link*>(getObject(uid));
356     }
357     else if (k == PORT)
358     {
359         model::Port* o = static_cast<model::Port*>(getObject(uid));
360     }
361     else
362     {
363     }
364     return false;
365 }
366
367 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v)
368 {
369
370     if (k == ANNOTATION)
371     {
372         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
373         switch (p)
374         {
375             default:
376                 break;
377         }
378     }
379     else if (k == BLOCK)
380     {
381         model::Block* o = static_cast<model::Block*>(getObject(uid));
382         switch (p)
383         {
384             default:
385                 break;
386         }
387     }
388     else if (k == DIAGRAM)
389     {
390         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
391         switch (p)
392         {
393             default:
394                 break;
395         }
396     }
397     else if (k == LINK)
398     {
399         model::Link* o = static_cast<model::Link*>(getObject(uid));
400         switch (p)
401         {
402             default:
403                 break;
404         }
405     }
406     else if (k == PORT)
407     {
408         model::Port* o = static_cast<model::Port*>(getObject(uid));
409         switch (p)
410         {
411             default:
412                 break;
413         }
414     }
415     return false;
416 }
417
418 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector< std::string >& v)
419 {
420
421     if (k == ANNOTATION)
422     {
423         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
424         switch (p)
425         {
426             default:
427                 break;
428         }
429     }
430     else if (k == BLOCK)
431     {
432         model::Block* o = static_cast<model::Block*>(getObject(uid));
433         switch (p)
434         {
435             case EXPRS:
436                 o->getExprs(v);
437                 return true;
438             default:
439                 break;
440         }
441     }
442     else if (k == DIAGRAM)
443     {
444         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
445         switch (p)
446         {
447             default:
448                 break;
449         }
450     }
451     else if (k == LINK)
452     {
453         model::Link* o = static_cast<model::Link*>(getObject(uid));
454         switch (p)
455         {
456             default:
457                 break;
458         }
459     }
460     else if (k == PORT)
461     {
462         model::Port* o = static_cast<model::Port*>(getObject(uid));
463         switch (p)
464         {
465             default:
466                 break;
467         }
468     }
469     return false;
470 }
471
472 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v)
473 {
474
475     if (k == ANNOTATION)
476     {
477         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
478         switch (p)
479         {
480             default:
481                 break;
482         }
483     }
484     else if (k == BLOCK)
485     {
486         model::Block* o = static_cast<model::Block*>(getObject(uid));
487         switch (p)
488         {
489             case INPUTS:
490                 o->getIn(v);
491                 return true;
492             case OUTPUTS:
493                 o->getOut(v);
494                 return true;
495             case EVENT_INPUTS:
496                 o->getEin(v);
497                 return true;
498             case EVENT_OUTPUTS:
499                 o->getEout(v);
500                 return true;
501             default:
502                 break;
503         }
504     }
505     else if (k == DIAGRAM)
506     {
507         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
508         switch (p)
509         {
510             case CHILDREN:
511                 v = o->getChildren();
512                 return true;
513             default:
514                 break;
515         }
516     }
517     else if (k == LINK)
518     {
519         model::Link* o = static_cast<model::Link*>(getObject(uid));
520         switch (p)
521         {
522             default:
523                 break;
524         }
525     }
526     else if (k == PORT)
527     {
528         model::Port* o = static_cast<model::Port*>(getObject(uid));
529         switch (p)
530         {
531             case CONNECTED_SIGNALS:
532                 v = o->getConnectedSignals();
533                 return true;
534             default:
535                 break;
536         }
537     }
538     return false;
539 }
540
541 } /* namespace org_scilab_modules_scicos */