fix windows compilation, rename CONTEXT in scicos MVC to DIAGRAM_CONTEXT ( CONTEXT...
[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.1-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             case FIRING:
74                 o->getFiring(v);
75                 return true;
76             default:
77                 break;
78         }
79     }
80     return false;
81 }
82
83 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int& v)
84 {
85
86     if (k == ANNOTATION)
87     {
88         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
89         switch (p)
90         {
91             default:
92                 break;
93         }
94     }
95     else if (k == BLOCK)
96     {
97         model::Block* o = static_cast<model::Block*>(getObject(uid));
98         switch (p)
99         {
100             case SIM_FUNCTION_API:
101                 o->getSimFunctionApi(v);
102                 return true;
103             case SIM_BLOCKTYPE:
104                 o->getSimBlocktype(v);
105                 return true;
106             case NZCROSS:
107                 o->getNZcross(v);
108                 return true;
109             case NMODE:
110                 o->getNMode(v);
111                 return true;
112             default:
113                 break;
114         }
115     }
116     else if (k == DIAGRAM)
117     {
118         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
119         switch (p)
120         {
121             default:
122                 break;
123         }
124     }
125     else if (k == LINK)
126     {
127         model::Link* o = static_cast<model::Link*>(getObject(uid));
128         switch (p)
129         {
130             case COLOR:
131                 o->getColor(v);
132                 return true;
133             case KIND:
134                 o->getKind(v);
135                 return true;
136             default:
137                 break;
138         }
139     }
140     else if (k == PORT)
141     {
142         model::Port* o = static_cast<model::Port*>(getObject(uid));
143         switch (p)
144         {
145             case PORT_KIND:
146                 o->getKind(v);
147                 return true;
148             default:
149                 break;
150         }
151     }
152     return false;
153 }
154
155 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool& v)
156 {
157
158     if (k == ANNOTATION)
159     {
160         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
161         switch (p)
162         {
163             default:
164                 break;
165         }
166     }
167     else if (k == BLOCK)
168     {
169         model::Block* o = static_cast<model::Block*>(getObject(uid));
170         switch (p)
171         {
172             default:
173                 break;
174         }
175     }
176     else if (k == DIAGRAM)
177     {
178         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
179         switch (p)
180         {
181             default:
182                 break;
183         }
184     }
185     else if (k == LINK)
186     {
187         model::Link* o = static_cast<model::Link*>(getObject(uid));
188         switch (p)
189         {
190             default:
191                 break;
192         }
193     }
194     else if (k == PORT)
195     {
196         model::Port* o = static_cast<model::Port*>(getObject(uid));
197         switch (p)
198         {
199             case IMPLICIT:
200                 o->getImplicit(v);
201                 return true;
202             default:
203                 break;
204         }
205     }
206     return false;
207 }
208
209 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v)
210 {
211
212     if (k == ANNOTATION)
213     {
214         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
215         switch (p)
216         {
217             default:
218                 break;
219         }
220     }
221     else if (k == BLOCK)
222     {
223         model::Block* o = static_cast<model::Block*>(getObject(uid));
224         switch (p)
225         {
226             case INTERFACE_FUNCTION:
227                 o->getInterfaceFunction(v);
228                 return true;
229             case SIM_FUNCTION_NAME:
230                 o->getSimFunctionName(v);
231                 return true;
232             case STYLE:
233                 o->getStyle(v);
234                 return true;
235             case LABEL:
236                 o->getLabel(v);
237                 return true;
238             case UID:
239                 o->getUID(v);
240                 return true;
241             default:
242                 break;
243         }
244     }
245     else if (k == DIAGRAM)
246     {
247         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
248         switch (p)
249         {
250             case TITLE:
251                 o->getTitle(v);
252                 return true;
253             case PATH:
254                 o->getPath(v);
255                 return true;
256             default:
257                 break;
258         }
259     }
260     else if (k == LINK)
261     {
262         model::Link* o = static_cast<model::Link*>(getObject(uid));
263         switch (p)
264         {
265             case LABEL:
266                 o->getLabel(v);
267                 return true;
268             default:
269                 break;
270         }
271     }
272     else if (k == PORT)
273     {
274         model::Port* o = static_cast<model::Port*>(getObject(uid));
275         switch (p)
276         {
277             case STYLE:
278                 o->getStyle(v);
279                 return true;
280             case LABEL:
281                 o->getLabel(v);
282                 return true;
283             default:
284                 break;
285         }
286     }
287     return false;
288 }
289
290 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v)
291 {
292
293     if (k == ANNOTATION)
294     {
295         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
296         switch (p)
297         {
298             case PARENT_DIAGRAM:
299                 v = o->getParentDiagram();
300                 return true;
301             case RELATED_TO:
302                 v = o->getRelatedTo();
303                 return true;
304             default:
305                 break;
306         }
307     }
308     else if (k == BLOCK)
309     {
310         model::Block* o = static_cast<model::Block*>(getObject(uid));
311         switch (p)
312         {
313             case PARENT_DIAGRAM:
314                 v = o->getParentDiagram();
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     }
325     else if (k == LINK)
326     {
327         model::Link* o = static_cast<model::Link*>(getObject(uid));
328         switch (p)
329         {
330             case PARENT_DIAGRAM:
331                 v = o->getParentDiagram();
332                 return true;
333             case SOURCE_PORT:
334                 o->getSourcePort(v);
335                 return true;
336             case DESTINATION_PORT:
337                 o->getDestinationPort(v);
338                 return true;
339             default:
340                 break;
341         }
342     }
343     else if (k == PORT)
344     {
345         model::Port* o = static_cast<model::Port*>(getObject(uid));
346         switch (p)
347         {
348             case CONNECTED_SIGNALS:
349                 v = o->getConnectedSignals().front();
350                 return true;
351             default:
352                 break;
353         }
354     }
355     else
356     {
357     }
358     return false;
359 }
360
361 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v)
362 {
363
364     if (k == ANNOTATION)
365     {
366         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
367         switch (p)
368         {
369             case GEOMETRY:
370                 o->getGeometry(v);
371                 return true;
372             default:
373                 break;
374         }
375     }
376     else if (k == BLOCK)
377     {
378         model::Block* o = static_cast<model::Block*>(getObject(uid));
379         switch (p)
380         {
381             case GEOMETRY:
382                 o->getGeometry(v);
383                 return true;
384             case ANGLE:
385                 o->getAngle(v);
386                 return true;
387             case STATE:
388                 o->getState(v);
389                 return true;
390             case DSTATE:
391                 o->getDState(v);
392                 return true;
393             case RPAR:
394                 o->getRpar(v);
395                 return true;
396             default:
397                 break;
398         }
399     }
400     else if (k == DIAGRAM)
401     {
402         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
403         switch (p)
404         {
405             case PROPERTIES:
406                 o->getProperties(v);
407                 return true;
408             default:
409                 break;
410         }
411     }
412     else if (k == LINK)
413     {
414         model::Link* o = static_cast<model::Link*>(getObject(uid));
415         switch (p)
416         {
417             case CONTROL_POINTS:
418                 o->getControlPoints(v);
419                 return true;
420             case THICK:
421                 o->getThick(v);
422                 return true;
423             default:
424                 break;
425         }
426     }
427     else if (k == PORT)
428     {
429         model::Port* o = static_cast<model::Port*>(getObject(uid));
430     }
431     else
432     {
433     }
434     return false;
435 }
436
437 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& 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             case SIM_DEP_UT:
455                 o->getSimDepUT(v);
456                 return true;
457             case IPAR:
458                 o->getIpar(v);
459                 return true;
460             default:
461                 break;
462         }
463     }
464     else if (k == DIAGRAM)
465     {
466         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
467         switch (p)
468         {
469             default:
470                 break;
471         }
472     }
473     else if (k == LINK)
474     {
475         model::Link* o = static_cast<model::Link*>(getObject(uid));
476         switch (p)
477         {
478             default:
479                 break;
480         }
481     }
482     else if (k == PORT)
483     {
484         model::Port* o = static_cast<model::Port*>(getObject(uid));
485         switch (p)
486         {
487             case DATATYPE:
488                 o->getDataType(v);
489                 return true;
490             default:
491                 break;
492         }
493     }
494     return false;
495 }
496
497 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v)
498 {
499
500     if (k == ANNOTATION)
501     {
502         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
503         switch (p)
504         {
505             default:
506                 break;
507         }
508     }
509     else if (k == BLOCK)
510     {
511         model::Block* o = static_cast<model::Block*>(getObject(uid));
512         switch (p)
513         {
514             case EXPRS:
515                 o->getExprs(v);
516                 return true;
517             default:
518                 break;
519         }
520     }
521     else if (k == DIAGRAM)
522     {
523         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
524         switch (p)
525         {
526             case DIAGRAM_CONTEXT:
527                 o->getContext(v);
528                 return true;
529             default:
530                 break;
531         }
532     }
533     else if (k == LINK)
534     {
535         model::Link* o = static_cast<model::Link*>(getObject(uid));
536         switch (p)
537         {
538             default:
539                 break;
540         }
541     }
542     else if (k == PORT)
543     {
544         model::Port* o = static_cast<model::Port*>(getObject(uid));
545         switch (p)
546         {
547             default:
548                 break;
549         }
550     }
551     return false;
552 }
553
554 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v)
555 {
556
557     if (k == ANNOTATION)
558     {
559         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
560         switch (p)
561         {
562             default:
563                 break;
564         }
565     }
566     else if (k == BLOCK)
567     {
568         model::Block* o = static_cast<model::Block*>(getObject(uid));
569         switch (p)
570         {
571             case INPUTS:
572                 o->getIn(v);
573                 return true;
574             case OUTPUTS:
575                 o->getOut(v);
576                 return true;
577             case EVENT_INPUTS:
578                 o->getEin(v);
579                 return true;
580             case EVENT_OUTPUTS:
581                 o->getEout(v);
582                 return true;
583             case CHILDREN:
584                 o->getChildren(v);
585                 return true;
586             default:
587                 break;
588         }
589     }
590     else if (k == DIAGRAM)
591     {
592         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
593         switch (p)
594         {
595             case CHILDREN:
596                 v = o->getChildren();
597                 return true;
598             default:
599                 break;
600         }
601     }
602     else if (k == LINK)
603     {
604         model::Link* o = static_cast<model::Link*>(getObject(uid));
605         switch (p)
606         {
607             default:
608                 break;
609         }
610     }
611     else if (k == PORT)
612     {
613         model::Port* o = static_cast<model::Port*>(getObject(uid));
614         switch (p)
615         {
616             case CONNECTED_SIGNALS:
617                 v = o->getConnectedSignals();
618                 return true;
619             default:
620                 break;
621         }
622     }
623     return false;
624 }
625
626 } /* namespace org_scilab_modules_scicos */