Xcos MVC: implement clone / delete on the Model side
[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             case PARENT_BLOCK:
319                 o->getParentBlock(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 = static_cast<model::Link*>(getObject(uid));
332         switch (p)
333         {
334             case PARENT_DIAGRAM:
335                 o->getParentDiagram(v);
336                 return true;
337             case SOURCE_PORT:
338                 o->getSourcePort(v);
339                 return true;
340             case DESTINATION_PORT:
341                 o->getDestinationPort(v);
342                 return true;
343             default:
344                 break;
345         }
346     }
347     else if (k == PORT)
348     {
349         model::Port* o = static_cast<model::Port*>(getObject(uid));
350         switch (p)
351         {
352             case SOURCE_BLOCK:
353                 o->getSourceBlock(v);
354                 return true;
355             case CONNECTED_SIGNALS:
356                 v = o->getConnectedSignals().front();
357                 return true;
358             default:
359                 break;
360         }
361     }
362     else
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 = static_cast<model::Annotation*>(getObject(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 = static_cast<model::Block*>(getObject(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 RPAR:
401                 o->getRpar(v);
402                 return true;
403             default:
404                 break;
405         }
406     }
407     else if (k == DIAGRAM)
408     {
409         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
410         switch (p)
411         {
412             case PROPERTIES:
413                 o->getProperties(v);
414                 return true;
415             default:
416                 break;
417         }
418     }
419     else if (k == LINK)
420     {
421         model::Link* o = static_cast<model::Link*>(getObject(uid));
422         switch (p)
423         {
424             case CONTROL_POINTS:
425                 o->getControlPoints(v);
426                 return true;
427             case THICK:
428                 o->getThick(v);
429                 return true;
430             default:
431                 break;
432         }
433     }
434     else if (k == PORT)
435     {
436         switch (p)
437         {
438             default:
439                 break;
440         }
441     }
442
443     return false;
444 }
445
446 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<int>& v) const
447 {
448
449     if (k == ANNOTATION)
450     {
451         switch (p)
452         {
453             default:
454                 break;
455         }
456     }
457     else if (k == BLOCK)
458     {
459         model::Block* o = static_cast<model::Block*>(getObject(uid));
460         switch (p)
461         {
462             case SIM_DEP_UT:
463                 o->getSimDepUT(v);
464                 return true;
465             case IPAR:
466                 o->getIpar(v);
467                 return true;
468             default:
469                 break;
470         }
471     }
472     else if (k == DIAGRAM)
473     {
474         switch (p)
475         {
476             default:
477                 break;
478         }
479     }
480     else if (k == LINK)
481     {
482         switch (p)
483         {
484             default:
485                 break;
486         }
487     }
488     else if (k == PORT)
489     {
490         model::Port* o = static_cast<model::Port*>(getObject(uid));
491         switch (p)
492         {
493             case DATATYPE:
494                 o->getDataType(v);
495                 return true;
496             default:
497                 break;
498         }
499     }
500     return false;
501 }
502
503 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<std::string>& v) const
504 {
505
506     if (k == ANNOTATION)
507     {
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 EXPRS:
520                 o->getExprs(v);
521                 return true;
522             default:
523                 break;
524         }
525     }
526     else if (k == DIAGRAM)
527     {
528         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
529         switch (p)
530         {
531             case DIAGRAM_CONTEXT:
532                 o->getContext(v);
533                 return true;
534             default:
535                 break;
536         }
537     }
538     else if (k == LINK)
539     {
540         switch (p)
541         {
542             default:
543                 break;
544         }
545     }
546     else if (k == PORT)
547     {
548         switch (p)
549         {
550             default:
551                 break;
552         }
553     }
554     return false;
555 }
556
557 bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::vector<ScicosID>& v) const
558 {
559
560     if (k == ANNOTATION)
561     {
562         switch (p)
563         {
564             default:
565                 break;
566         }
567     }
568     else if (k == BLOCK)
569     {
570         model::Block* o = static_cast<model::Block*>(getObject(uid));
571         switch (p)
572         {
573             case INPUTS:
574                 o->getIn(v);
575                 return true;
576             case OUTPUTS:
577                 o->getOut(v);
578                 return true;
579             case EVENT_INPUTS:
580                 o->getEin(v);
581                 return true;
582             case EVENT_OUTPUTS:
583                 o->getEout(v);
584                 return true;
585             case CHILDREN:
586                 o->getChildren(v);
587                 return true;
588             default:
589                 break;
590         }
591     }
592     else if (k == DIAGRAM)
593     {
594         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
595         switch (p)
596         {
597             case CHILDREN:
598                 o->getChildren(v);
599                 return true;
600             default:
601                 break;
602         }
603     }
604     else if (k == LINK)
605     {
606         switch (p)
607         {
608             default:
609                 break;
610         }
611     }
612     else if (k == PORT)
613     {
614         model::Port* o = static_cast<model::Port*>(getObject(uid));
615         switch (p)
616         {
617             case CONNECTED_SIGNALS:
618                 v = o->getConnectedSignals();
619                 return true;
620             default:
621                 break;
622         }
623     }
624     return false;
625 }
626
627 } /* namespace org_scilab_modules_scicos */