Xcos MVC: blk.model.blocktype is a string
[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         switch (p)
202         {
203             default:
204                 break;
205         }
206     }
207     else if (k == BLOCK)
208     {
209         model::Block* o = static_cast<model::Block*>(getObject(uid));
210         switch (p)
211         {
212             case INTERFACE_FUNCTION:
213                 o->getInterfaceFunction(v);
214                 return true;
215             case SIM_FUNCTION_NAME:
216                 o->getSimFunctionName(v);
217                 return true;
218             case SIM_BLOCKTYPE:
219                 o->getSimBlocktype(v);
220                 return true;
221             case STYLE:
222                 o->getStyle(v);
223                 return true;
224             case LABEL:
225                 o->getLabel(v);
226                 return true;
227             case UID:
228                 o->getUID(v);
229                 return true;
230             default:
231                 break;
232         }
233     }
234     else if (k == DIAGRAM)
235     {
236         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
237         switch (p)
238         {
239             case TITLE:
240                 o->getTitle(v);
241                 return true;
242             case PATH:
243                 o->getPath(v);
244                 return true;
245             case VERSION_NUMBER:
246                 o->getVersionNumber(v);
247                 return true;
248             default:
249                 break;
250         }
251     }
252     else if (k == LINK)
253     {
254         model::Link* o = static_cast<model::Link*>(getObject(uid));
255         switch (p)
256         {
257             case LABEL:
258                 o->getLabel(v);
259                 return true;
260             default:
261                 break;
262         }
263     }
264     else if (k == PORT)
265     {
266         model::Port* o = static_cast<model::Port*>(getObject(uid));
267         switch (p)
268         {
269             case STYLE:
270                 o->getStyle(v);
271                 return true;
272             case LABEL:
273                 o->getLabel(v);
274                 return true;
275             default:
276                 break;
277         }
278     }
279     return false;
280 }
281
282 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v) const
283 {
284
285     if (k == ANNOTATION)
286     {
287         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
288         switch (p)
289         {
290             case PARENT_DIAGRAM:
291                 v = o->getParentDiagram();
292                 return true;
293             case RELATED_TO:
294                 v = o->getRelatedTo();
295                 return true;
296             default:
297                 break;
298         }
299     }
300     else if (k == BLOCK)
301     {
302         model::Block* o = static_cast<model::Block*>(getObject(uid));
303         switch (p)
304         {
305             case PARENT_DIAGRAM:
306                 v = o->getParentDiagram();
307                 return true;
308             default:
309                 break;
310         }
311     }
312     else if (k == DIAGRAM)
313     {
314
315     }
316     else if (k == LINK)
317     {
318         model::Link* o = static_cast<model::Link*>(getObject(uid));
319         switch (p)
320         {
321             case PARENT_DIAGRAM:
322                 v = o->getParentDiagram();
323                 return true;
324             case SOURCE_PORT:
325                 o->getSourcePort(v);
326                 return true;
327             case DESTINATION_PORT:
328                 o->getDestinationPort(v);
329                 return true;
330             default:
331                 break;
332         }
333     }
334     else if (k == PORT)
335     {
336         model::Port* o = static_cast<model::Port*>(getObject(uid));
337         switch (p)
338         {
339             case CONNECTED_SIGNALS:
340                 v = o->getConnectedSignals().front();
341                 return true;
342             default:
343                 break;
344         }
345     }
346     else
347     {
348     }
349     return false;
350 }
351
352 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v) const
353 {
354
355     if (k == ANNOTATION)
356     {
357         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
358         switch (p)
359         {
360             case GEOMETRY:
361                 o->getGeometry(v);
362                 return true;
363             default:
364                 break;
365         }
366     }
367     else if (k == BLOCK)
368     {
369         model::Block* o = static_cast<model::Block*>(getObject(uid));
370         switch (p)
371         {
372             case GEOMETRY:
373                 o->getGeometry(v);
374                 return true;
375             case ANGLE:
376                 o->getAngle(v);
377                 return true;
378             case STATE:
379                 o->getState(v);
380                 return true;
381             case DSTATE:
382                 o->getDState(v);
383                 return true;
384             case RPAR:
385                 o->getRpar(v);
386                 return true;
387             default:
388                 break;
389         }
390     }
391     else if (k == DIAGRAM)
392     {
393         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
394         switch (p)
395         {
396             case PROPERTIES:
397                 o->getProperties(v);
398                 return true;
399             default:
400                 break;
401         }
402     }
403     else if (k == LINK)
404     {
405         model::Link* o = static_cast<model::Link*>(getObject(uid));
406         switch (p)
407         {
408             case CONTROL_POINTS:
409                 o->getControlPoints(v);
410                 return true;
411             case THICK:
412                 o->getThick(v);
413                 return true;
414             default:
415                 break;
416         }
417     }
418     else if (k == PORT)
419     {
420         switch (p)
421         {
422             default:
423                 break;
424         }
425     }
426
427     return false;
428 }
429
430 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v) const
431 {
432
433     if (k == ANNOTATION)
434     {
435         switch (p)
436         {
437             default:
438                 break;
439         }
440     }
441     else if (k == BLOCK)
442     {
443         model::Block* o = static_cast<model::Block*>(getObject(uid));
444         switch (p)
445         {
446             case SIM_DEP_UT:
447                 o->getSimDepUT(v);
448                 return true;
449             case IPAR:
450                 o->getIpar(v);
451                 return true;
452             default:
453                 break;
454         }
455     }
456     else if (k == DIAGRAM)
457     {
458         switch (p)
459         {
460             default:
461                 break;
462         }
463     }
464     else if (k == LINK)
465     {
466         switch (p)
467         {
468             default:
469                 break;
470         }
471     }
472     else if (k == PORT)
473     {
474         model::Port* o = static_cast<model::Port*>(getObject(uid));
475         switch (p)
476         {
477             case DATATYPE:
478                 o->getDataType(v);
479                 return true;
480             default:
481                 break;
482         }
483     }
484     return false;
485 }
486
487 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v) const
488 {
489
490     if (k == ANNOTATION)
491     {
492         switch (p)
493         {
494             default:
495                 break;
496         }
497     }
498     else if (k == BLOCK)
499     {
500         model::Block* o = static_cast<model::Block*>(getObject(uid));
501         switch (p)
502         {
503             case EXPRS:
504                 o->getExprs(v);
505                 return true;
506             default:
507                 break;
508         }
509     }
510     else if (k == DIAGRAM)
511     {
512         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
513         switch (p)
514         {
515             case DIAGRAM_CONTEXT:
516                 o->getContext(v);
517                 return true;
518             default:
519                 break;
520         }
521     }
522     else if (k == LINK)
523     {
524         switch (p)
525         {
526             default:
527                 break;
528         }
529     }
530     else if (k == PORT)
531     {
532         switch (p)
533         {
534             default:
535                 break;
536         }
537     }
538     return false;
539 }
540
541 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v) const
542 {
543
544     if (k == ANNOTATION)
545     {
546         switch (p)
547         {
548             default:
549                 break;
550         }
551     }
552     else if (k == BLOCK)
553     {
554         model::Block* o = static_cast<model::Block*>(getObject(uid));
555         switch (p)
556         {
557             case INPUTS:
558                 o->getIn(v);
559                 return true;
560             case OUTPUTS:
561                 o->getOut(v);
562                 return true;
563             case EVENT_INPUTS:
564                 o->getEin(v);
565                 return true;
566             case EVENT_OUTPUTS:
567                 o->getEout(v);
568                 return true;
569             case CHILDREN:
570                 o->getChildren(v);
571                 return true;
572             default:
573                 break;
574         }
575     }
576     else if (k == DIAGRAM)
577     {
578         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
579         switch (p)
580         {
581             case CHILDREN:
582                 o->getChildren(v);
583                 return true;
584             default:
585                 break;
586         }
587     }
588     else if (k == LINK)
589     {
590         switch (p)
591         {
592             default:
593                 break;
594         }
595     }
596     else if (k == PORT)
597     {
598         model::Port* o = static_cast<model::Port*>(getObject(uid));
599         switch (p)
600         {
601             case CONNECTED_SIGNALS:
602                 v = o->getConnectedSignals();
603                 return true;
604             default:
605                 break;
606         }
607     }
608     return false;
609 }
610
611 } /* namespace org_scilab_modules_scicos */