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