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