Xcos MVC: implement firing / dep_ut / label / nzcross / nmode
[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             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             default:
131                 break;
132         }
133     }
134     else if (k == PORT)
135     {
136         model::Port* o = static_cast<model::Port*>(getObject(uid));
137         switch (p)
138         {
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)
147 {
148
149     if (k == ANNOTATION)
150     {
151         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
152         switch (p)
153         {
154             default:
155                 break;
156         }
157     }
158     else if (k == BLOCK)
159     {
160         model::Block* o = static_cast<model::Block*>(getObject(uid));
161         switch (p)
162         {
163             default:
164                 break;
165         }
166     }
167     else if (k == DIAGRAM)
168     {
169         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
170         switch (p)
171         {
172             default:
173                 break;
174         }
175     }
176     else if (k == LINK)
177     {
178         model::Link* o = static_cast<model::Link*>(getObject(uid));
179         switch (p)
180         {
181             default:
182                 break;
183         }
184     }
185     else if (k == PORT)
186     {
187         model::Port* o = static_cast<model::Port*>(getObject(uid));
188         switch (p)
189         {
190             case IMPLICIT:
191                 o->getImplicit(v);
192                 return true;
193             default:
194                 break;
195         }
196     }
197     return false;
198 }
199
200 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string& v)
201 {
202
203     if (k == ANNOTATION)
204     {
205         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
206         switch (p)
207         {
208             default:
209                 break;
210         }
211     }
212     else if (k == BLOCK)
213     {
214         model::Block* o = static_cast<model::Block*>(getObject(uid));
215         switch (p)
216         {
217             case SIM_FUNCTION_NAME:
218                 o->getSimFunctionName(v);
219                 return true;
220             case STYLE:
221                 o->getStyle(v);
222                 return true;
223             case LABEL:
224                 o->getLabel(v);
225                 return true;
226             default:
227                 break;
228         }
229     }
230     else if (k == DIAGRAM)
231     {
232         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
233         switch (p)
234         {
235             default:
236                 break;
237         }
238     }
239     else if (k == LINK)
240     {
241         model::Link* o = static_cast<model::Link*>(getObject(uid));
242         switch (p)
243         {
244             default:
245                 break;
246         }
247     }
248     else if (k == PORT)
249     {
250         model::Port* o = static_cast<model::Port*>(getObject(uid));
251         switch (p)
252         {
253             case STYLE:
254                 o->getStyle(v);
255                 return true;
256             case LABEL:
257                 o->getLabel(v);
258                 return true;
259             default:
260                 break;
261         }
262     }
263     return false;
264 }
265
266 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID& v)
267 {
268
269     if (k == ANNOTATION)
270     {
271         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
272         switch (p)
273         {
274             case PARENT_DIAGRAM:
275                 v = o->getParentDiagram();
276                 return true;
277             case RELATED_TO:
278                 v = o->getRelatedTo();
279                 return true;
280             default:
281                 break;
282         }
283     }
284     else if (k == BLOCK)
285     {
286         model::Block* o = static_cast<model::Block*>(getObject(uid));
287         switch (p)
288         {
289             case PARENT_DIAGRAM:
290                 v = o->getParentDiagram();
291                 return true;
292             default:
293                 break;
294         }
295     }
296     else if (k == DIAGRAM)
297     {
298         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
299
300     }
301     else if (k == LINK)
302     {
303         model::Link* o = static_cast<model::Link*>(getObject(uid));
304         switch (p)
305         {
306             case PARENT_DIAGRAM:
307                 v = o->getParentDiagram();
308                 return true;
309             case SOURCE_PORT:
310                 v = o->getSourcePort();
311                 return true;
312             case DESTINATION_PORT:
313                 v = o->getDestinationPort();
314                 return true;
315             default:
316                 break;
317         }
318     }
319     else if (k == PORT)
320     {
321         model::Port* o = static_cast<model::Port*>(getObject(uid));
322         switch (p)
323         {
324             case CONNECTED_SIGNALS:
325                 v = o->getConnectedSignals().front();
326                 return true;
327             default:
328                 break;
329         }
330     }
331     else
332     {
333     }
334     return false;
335 }
336
337 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<double>& v)
338 {
339
340     if (k == ANNOTATION)
341     {
342         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
343         switch (p)
344         {
345             case GEOMETRY:
346                 o->getGeometry(v);
347                 return true;
348             default:
349                 break;
350         }
351     }
352     else if (k == BLOCK)
353     {
354         model::Block* o = static_cast<model::Block*>(getObject(uid));
355         switch (p)
356         {
357             case GEOMETRY:
358                 o->getGeometry(v);
359                 return true;
360             case ANGLE:
361                 o->getAngle(v);
362                 return true;
363             case STATE:
364                 o->getState(v);
365                 return true;
366             case DSTATE:
367                 o->getDState(v);
368                 return true;
369             default:
370                 break;
371         }
372     }
373     else if (k == DIAGRAM)
374     {
375         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
376     }
377     else if (k == LINK)
378     {
379         model::Link* o = static_cast<model::Link*>(getObject(uid));
380     }
381     else if (k == PORT)
382     {
383         model::Port* o = static_cast<model::Port*>(getObject(uid));
384     }
385     else
386     {
387     }
388     return false;
389 }
390
391 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v)
392 {
393
394     if (k == ANNOTATION)
395     {
396         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
397         switch (p)
398         {
399             default:
400                 break;
401         }
402     }
403     else if (k == BLOCK)
404     {
405         model::Block* o = static_cast<model::Block*>(getObject(uid));
406         switch (p)
407         {
408             case SIM_DEP_UT:
409                 o->getSimDepUT(v);
410                 return true;
411             default:
412                 break;
413         }
414     }
415     else if (k == DIAGRAM)
416     {
417         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
418         switch (p)
419         {
420             default:
421                 break;
422         }
423     }
424     else if (k == LINK)
425     {
426         model::Link* o = static_cast<model::Link*>(getObject(uid));
427         switch (p)
428         {
429             default:
430                 break;
431         }
432     }
433     else if (k == PORT)
434     {
435         model::Port* o = static_cast<model::Port*>(getObject(uid));
436         switch (p)
437         {
438             case DATATYPE:
439                 o->getDataType(v);
440                 return true;
441             default:
442                 break;
443         }
444     }
445     return false;
446 }
447
448 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v)
449 {
450
451     if (k == ANNOTATION)
452     {
453         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
454         switch (p)
455         {
456             default:
457                 break;
458         }
459     }
460     else if (k == BLOCK)
461     {
462         model::Block* o = static_cast<model::Block*>(getObject(uid));
463         switch (p)
464         {
465             case EXPRS:
466                 o->getExprs(v);
467                 return true;
468             default:
469                 break;
470         }
471     }
472     else if (k == DIAGRAM)
473     {
474         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
475         switch (p)
476         {
477             default:
478                 break;
479         }
480     }
481     else if (k == LINK)
482     {
483         model::Link* o = static_cast<model::Link*>(getObject(uid));
484         switch (p)
485         {
486             default:
487                 break;
488         }
489     }
490     else if (k == PORT)
491     {
492         model::Port* o = static_cast<model::Port*>(getObject(uid));
493         switch (p)
494         {
495             default:
496                 break;
497         }
498     }
499     return false;
500 }
501
502 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v)
503 {
504
505     if (k == ANNOTATION)
506     {
507         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
508         switch (p)
509         {
510             default:
511                 break;
512         }
513     }
514     else if (k == BLOCK)
515     {
516         model::Block* o = static_cast<model::Block*>(getObject(uid));
517         switch (p)
518         {
519             case INPUTS:
520                 o->getIn(v);
521                 return true;
522             case OUTPUTS:
523                 o->getOut(v);
524                 return true;
525             case EVENT_INPUTS:
526                 o->getEin(v);
527                 return true;
528             case EVENT_OUTPUTS:
529                 o->getEout(v);
530                 return true;
531             default:
532                 break;
533         }
534     }
535     else if (k == DIAGRAM)
536     {
537         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
538         switch (p)
539         {
540             case CHILDREN:
541                 v = o->getChildren();
542                 return true;
543             default:
544                 break;
545         }
546     }
547     else if (k == LINK)
548     {
549         model::Link* o = static_cast<model::Link*>(getObject(uid));
550         switch (p)
551         {
552             default:
553                 break;
554         }
555     }
556     else if (k == PORT)
557     {
558         model::Port* o = static_cast<model::Port*>(getObject(uid));
559         switch (p)
560         {
561             case CONNECTED_SIGNALS:
562                 v = o->getConnectedSignals();
563                 return true;
564             default:
565                 break;
566         }
567     }
568     return false;
569 }
570
571 } /* namespace org_scilab_modules_scicos */