Xcos MVC: use shared_ptr on the Model
[scilab.git] / scilab / modules / scicos / src / cpp / Model_setObjectProperties.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 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, double v)
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).get());
67         switch (p)
68         {
69             case FIRING:
70                 return o->setFiring(v);
71             default:
72                 break;
73         }
74     }
75     return FAIL;
76 }
77
78 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, int v)
79 {
80
81     if (k == ANNOTATION)
82     {
83         switch (p)
84         {
85             default:
86                 break;
87         }
88     }
89     else if (k == BLOCK)
90     {
91         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
92         switch (p)
93         {
94             case SIM_FUNCTION_API:
95                 return o->setSimFunctionApi(v);
96             case NZCROSS:
97                 return o->setNZcross(v);
98             case NMODE:
99                 return o->setNMode(v);
100             default:
101                 break;
102         }
103     }
104     else if (k == DIAGRAM)
105     {
106         switch (p)
107         {
108             default:
109                 break;
110         }
111     }
112     else if (k == LINK)
113     {
114         model::Link* o = static_cast<model::Link*>(getObject(uid).get());
115         switch (p)
116         {
117             case COLOR:
118                 return o->setColor(v);
119             case KIND:
120                 return o->setKind(v);
121             default:
122                 break;
123         }
124     }
125     else if (k == PORT)
126     {
127         model::Port* o = static_cast<model::Port*>(getObject(uid).get());
128         switch (p)
129         {
130             case PORT_KIND:
131                 return o->setKind(v);
132             default:
133                 break;
134         }
135     }
136     return FAIL;
137 }
138
139 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool v)
140 {
141
142     if (k == ANNOTATION)
143     {
144         switch (p)
145         {
146             default:
147                 break;
148         }
149     }
150     else if (k == BLOCK)
151     {
152         switch (p)
153         {
154             default:
155                 break;
156         }
157     }
158     else if (k == DIAGRAM)
159     {
160         switch (p)
161         {
162             default:
163                 break;
164         }
165     }
166     else if (k == LINK)
167     {
168         switch (p)
169         {
170             default:
171                 break;
172         }
173     }
174     else if (k == PORT)
175     {
176         model::Port* o = static_cast<model::Port*>(getObject(uid).get());
177         switch (p)
178         {
179             case IMPLICIT:
180                 return o->setImplicit(v);
181             default:
182                 break;
183         }
184     }
185     return FAIL;
186 }
187
188 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID v)
189 {
190
191     if (k == ANNOTATION)
192     {
193         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid).get());
194         switch (p)
195         {
196             case PARENT_DIAGRAM:
197                 return o->setParentDiagram(v);
198             default:
199                 break;
200         }
201     }
202     else if (k == BLOCK)
203     {
204         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
205         switch (p)
206         {
207             case PARENT_DIAGRAM:
208                 return o->setParentDiagram(v);
209             case PARENT_BLOCK:
210                 return o->setParentBlock(v);
211             case PORT_REFERENCE:
212                 return o->setPortReference(v);
213             default:
214                 break;
215         }
216     }
217     else if (k == DIAGRAM)
218     {
219         switch (p)
220         {
221             default:
222                 break;
223         }
224     }
225     else if (k == LINK)
226     {
227         model::Link* o = static_cast<model::Link*>(getObject(uid).get());
228         switch (p)
229         {
230             case PARENT_DIAGRAM:
231                 return o->setParentDiagram(v);
232             case SOURCE_PORT:
233                 return o->setSourcePort(v);
234             case DESTINATION_PORT:
235                 return o->setDestinationPort(v);
236             default:
237                 break;
238         }
239     }
240     else if (k == PORT)
241     {
242         model::Port* o = static_cast<model::Port*>(getObject(uid).get());
243         switch (p)
244         {
245             case SOURCE_BLOCK:
246                 return o->setSourceBlock(v);
247             case CONNECTED_SIGNALS:
248                 return o->setConnectedSignals(std::vector<ScicosID> (1, v));
249             default:
250                 break;
251         }
252     }
253     return FAIL;
254 }
255
256 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string v)
257 {
258
259     if (k == ANNOTATION)
260     {
261         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid).get());
262         switch (p)
263         {
264             case DESCRIPTION:
265                 return o->setDescription(v);
266             case FONT:
267                 return o->setFont(v);
268             case FONT_SIZE:
269                 return o->setFontSize(v);
270             default:
271                 break;
272         }
273     }
274     else if (k == BLOCK)
275     {
276         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
277         switch (p)
278         {
279             case INTERFACE_FUNCTION:
280                 return o->setInterfaceFunction(v);
281             case SIM_FUNCTION_NAME:
282                 return o->setSimFunctionName(v);
283             case SIM_BLOCKTYPE:
284                 return o->setSimBlocktype(v);
285             case STYLE:
286                 return o->setStyle(v);
287             case LABEL:
288                 return o->setLabel(v);
289             case UID:
290                 return o->setUID(v);
291             default:
292                 break;
293         }
294     }
295     else if (k == DIAGRAM)
296     {
297         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid).get());
298         switch (p)
299         {
300             case TITLE:
301                 return o->setTitle(v);
302             case PATH:
303                 return o->setPath(v);
304             case VERSION_NUMBER:
305                 return o->setVersionNumber(v);
306             default:
307                 break;
308         }
309     }
310     else if (k == LINK)
311     {
312         model::Link* o = static_cast<model::Link*>(getObject(uid).get());
313         switch (p)
314         {
315             case LABEL:
316                 return o->setLabel(v);
317             default:
318                 break;
319         }
320     }
321     else if (k == PORT)
322     {
323         model::Port* o = static_cast<model::Port*>(getObject(uid).get());
324         switch (p)
325         {
326             case STYLE:
327                 return o->setStyle(v);
328             case LABEL:
329                 return o->setLabel(v);
330             default:
331                 break;
332         }
333     }
334     return FAIL;
335 }
336
337 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
338 {
339
340     if (k == ANNOTATION)
341     {
342         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid).get());
343         switch (p)
344         {
345             case GEOMETRY:
346                 return o->setGeometry(v);
347             default:
348                 break;
349         }
350     }
351     else if (k == BLOCK)
352     {
353         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
354         switch (p)
355         {
356             case GEOMETRY:
357                 return o->setGeometry(v);
358             case ANGLE:
359                 return o->setAngle(v);
360             case STATE:
361                 return o->setState(v);
362             case DSTATE:
363                 return o->setDState(v);
364             case RPAR:
365                 return o->setRpar(v);
366             default:
367                 break;
368         }
369     }
370     else if (k == DIAGRAM)
371     {
372         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid).get());
373         switch (p)
374         {
375             case PROPERTIES:
376                 return o->setProperties(v);
377             default:
378                 break;
379         }
380     }
381     else if (k == LINK)
382     {
383         model::Link* o = static_cast<model::Link*>(getObject(uid).get());
384         switch (p)
385         {
386             case CONTROL_POINTS:
387                 return o->setControlPoints(v);
388             case THICK:
389                 return o->setThick(v);
390             default:
391                 break;
392         }
393     }
394     else if (k == PORT)
395     {
396         switch (p)
397         {
398             default:
399                 break;
400         }
401     }
402     return FAIL;
403 }
404
405 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
406 {
407
408     if (k == ANNOTATION)
409     {
410         switch (p)
411         {
412             default:
413                 break;
414         }
415     }
416     else if (k == BLOCK)
417     {
418         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
419         switch (p)
420         {
421             case SIM_DEP_UT:
422                 return o->setSimDepUT(v);
423             case ODSTATE:
424                 return o->setODState(v);
425             case IPAR:
426                 return o->setIpar(v);
427             case OPAR:
428                 return o->setOpar(v);
429             default:
430                 break;
431         }
432     }
433     else if (k == DIAGRAM)
434     {
435         switch (p)
436         {
437             default:
438                 break;
439         }
440     }
441     else if (k == LINK)
442     {
443         switch (p)
444         {
445             default:
446                 break;
447         }
448     }
449     else if (k == PORT)
450     {
451         model::Port* o = static_cast<model::Port*>(getObject(uid).get());
452         switch (p)
453         {
454             case DATATYPE:
455                 return o->setDataType(this, v);
456             default:
457                 break;
458         }
459     }
460     return FAIL;
461 }
462
463 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<std::string>& v)
464 {
465
466     if (k == ANNOTATION)
467     {
468         switch (p)
469         {
470             default:
471                 break;
472         }
473     }
474     else if (k == BLOCK)
475     {
476         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
477         switch (p)
478         {
479             case EXPRS:
480                 return o->setExprs(v);
481             default:
482                 break;
483         }
484     }
485     else if (k == DIAGRAM)
486     {
487         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid).get());
488         switch (p)
489         {
490             case DIAGRAM_CONTEXT:
491                 return o->setContext(v);
492             default:
493                 break;
494         }
495     }
496     else if (k == LINK)
497     {
498         switch (p)
499         {
500             default:
501                 break;
502         }
503     }
504     else if (k == PORT)
505     {
506         switch (p)
507         {
508             default:
509                 break;
510         }
511     }
512     return FAIL;
513 }
514
515 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
516 {
517
518     if (k == ANNOTATION)
519     {
520         switch (p)
521         {
522             default:
523                 break;
524         }
525     }
526     else if (k == BLOCK)
527     {
528         model::Block* o = static_cast<model::Block*>(getObject(uid).get());
529         switch (p)
530         {
531             case INPUTS:
532                 return o->setIn(v);
533             case OUTPUTS:
534                 return o->setOut(v);
535             case EVENT_INPUTS:
536                 return o->setEin(v);
537             case EVENT_OUTPUTS:
538                 return o->setEout(v);
539             case CHILDREN:
540                 return o->setChildren(v);
541             default:
542                 break;
543         }
544     }
545     else if (k == DIAGRAM)
546     {
547         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid).get());
548         switch (p)
549         {
550             case CHILDREN:
551                 return o->setChildren(v);
552             default:
553                 break;
554         }
555     }
556     else if (k == LINK)
557     {
558         switch (p)
559         {
560             default:
561                 break;
562         }
563     }
564     else if (k == PORT)
565     {
566         model::Port* o = static_cast<model::Port*>(getObject(uid).get());
567         switch (p)
568         {
569             case CONNECTED_SIGNALS:
570                 return o->setConnectedSignals(v);
571             default:
572                 break;
573         }
574     }
575     return FAIL;
576 }
577
578 } /* namespace org_scilab_modules_scicos */
579
580