Xcos MVC: fix includes
[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 = getObject<model::Port>(uid);
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 = getObject<model::Block>(uid);
92         switch (p)
93         {
94             case SIM_FUNCTION_API:
95                 return o->setSimFunctionApi(v);
96             default:
97                 break;
98         }
99     }
100     else if (k == DIAGRAM)
101     {
102         switch (p)
103         {
104             default:
105                 break;
106         }
107     }
108     else if (k == LINK)
109     {
110         model::Link* o = getObject<model::Link>(uid);
111         switch (p)
112         {
113             case COLOR:
114                 return o->setColor(v);
115             case KIND:
116                 return o->setKind(v);
117             default:
118                 break;
119         }
120     }
121     else if (k == PORT)
122     {
123         model::Port* o = getObject<model::Port>(uid);
124         switch (p)
125         {
126             case PORT_KIND:
127                 return o->setKind(v);
128             default:
129                 break;
130         }
131     }
132     return FAIL;
133 }
134
135 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, bool v)
136 {
137
138     if (k == ANNOTATION)
139     {
140         switch (p)
141         {
142             default:
143                 break;
144         }
145     }
146     else if (k == BLOCK)
147     {
148         switch (p)
149         {
150             default:
151                 break;
152         }
153     }
154     else if (k == DIAGRAM)
155     {
156         switch (p)
157         {
158             default:
159                 break;
160         }
161     }
162     else if (k == LINK)
163     {
164         switch (p)
165         {
166             default:
167                 break;
168         }
169     }
170     else if (k == PORT)
171     {
172         model::Port* o = getObject<model::Port>(uid);
173         switch (p)
174         {
175             case IMPLICIT:
176                 return o->setImplicit(v);
177             default:
178                 break;
179         }
180     }
181     return FAIL;
182 }
183
184 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, ScicosID v)
185 {
186
187     if (k == ANNOTATION)
188     {
189         model::Annotation* o = getObject<model::Annotation>(uid);
190         switch (p)
191         {
192             case PARENT_DIAGRAM:
193                 return o->setParentDiagram(v);
194             case PARENT_BLOCK:
195                 return o->setParentBlock(v);
196             default:
197                 break;
198         }
199     }
200     else if (k == BLOCK)
201     {
202         model::Block* o = getObject<model::Block>(uid);
203         switch (p)
204         {
205             case PARENT_DIAGRAM:
206                 return o->setParentDiagram(v);
207             case PARENT_BLOCK:
208                 return o->setParentBlock(v);
209             case PORT_REFERENCE:
210                 return o->setPortReference(v);
211             default:
212                 break;
213         }
214     }
215     else if (k == DIAGRAM)
216     {
217         switch (p)
218         {
219             default:
220                 break;
221         }
222     }
223     else if (k == LINK)
224     {
225         model::Link* o = getObject<model::Link>(uid);
226         switch (p)
227         {
228             case PARENT_DIAGRAM:
229                 return o->setParentDiagram(v);
230             case PARENT_BLOCK:
231                 return o->setParentBlock(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 = getObject<model::Port>(uid);
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 = getObject<model::Annotation>(uid);
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 = getObject<model::Block>(uid);
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 = getObject<model::Diagram>(uid);
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 = getObject<model::Link>(uid);
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 = getObject<model::Port>(uid);
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 = getObject<model::Annotation>(uid);
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 = getObject<model::Block>(uid);
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 ODSTATE:
365                 return o->setODState(v);
366             case RPAR:
367                 return o->setRpar(v);
368             case OPAR:
369                 return o->setOpar(v);
370             default:
371                 break;
372         }
373     }
374     else if (k == DIAGRAM)
375     {
376         model::Diagram* o = getObject<model::Diagram>(uid);
377         switch (p)
378         {
379             case PROPERTIES:
380                 return o->setProperties(v);
381             default:
382                 break;
383         }
384     }
385     else if (k == LINK)
386     {
387         model::Link* o = getObject<model::Link>(uid);
388         switch (p)
389         {
390             case CONTROL_POINTS:
391                 return o->setControlPoints(v);
392             case THICK:
393                 return o->setThick(v);
394             default:
395                 break;
396         }
397     }
398     else if (k == PORT)
399     {
400         switch (p)
401         {
402             default:
403                 break;
404         }
405     }
406     return FAIL;
407 }
408
409 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
410 {
411
412     if (k == ANNOTATION)
413     {
414         switch (p)
415         {
416             default:
417                 break;
418         }
419     }
420     else if (k == BLOCK)
421     {
422         model::Block* o = getObject<model::Block>(uid);
423         switch (p)
424         {
425             case SIM_DEP_UT:
426                 return o->setSimDepUT(v);
427             case NZCROSS:
428                 return o->setNZcross(v);
429             case NMODE:
430                 return o->setNMode(v);
431             case IPAR:
432                 return o->setIpar(v);
433             default:
434                 break;
435         }
436     }
437     else if (k == DIAGRAM)
438     {
439         switch (p)
440         {
441             default:
442                 break;
443         }
444     }
445     else if (k == LINK)
446     {
447         switch (p)
448         {
449             default:
450                 break;
451         }
452     }
453     else if (k == PORT)
454     {
455         model::Port* o = getObject<model::Port>(uid);
456         switch (p)
457         {
458             case DATATYPE:
459                 return o->setDataType(this, v);
460             default:
461                 break;
462         }
463     }
464     return FAIL;
465 }
466
467 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<std::string>& v)
468 {
469
470     if (k == ANNOTATION)
471     {
472         switch (p)
473         {
474             default:
475                 break;
476         }
477     }
478     else if (k == BLOCK)
479     {
480         model::Block* o = getObject<model::Block>(uid);
481         switch (p)
482         {
483             case EXPRS:
484                 return o->setExprs(v);
485             case EQUATIONS:
486                 return o->setEquations(v);
487             default:
488                 break;
489         }
490     }
491     else if (k == DIAGRAM)
492     {
493         model::Diagram* o = getObject<model::Diagram>(uid);
494         switch (p)
495         {
496             case DIAGRAM_CONTEXT:
497                 return o->setContext(v);
498             default:
499                 break;
500         }
501     }
502     else if (k == LINK)
503     {
504         switch (p)
505         {
506             default:
507                 break;
508         }
509     }
510     else if (k == PORT)
511     {
512         switch (p)
513         {
514             default:
515                 break;
516         }
517     }
518     return FAIL;
519 }
520
521 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
522 {
523
524     if (k == ANNOTATION)
525     {
526         switch (p)
527         {
528             default:
529                 break;
530         }
531     }
532     else if (k == BLOCK)
533     {
534         model::Block* o = getObject<model::Block>(uid);
535         switch (p)
536         {
537             case INPUTS:
538                 return o->setIn(v);
539             case OUTPUTS:
540                 return o->setOut(v);
541             case EVENT_INPUTS:
542                 return o->setEin(v);
543             case EVENT_OUTPUTS:
544                 return o->setEout(v);
545             case CHILDREN:
546                 return o->setChildren(v);
547             default:
548                 break;
549         }
550     }
551     else if (k == DIAGRAM)
552     {
553         model::Diagram* o = getObject<model::Diagram>(uid);
554         switch (p)
555         {
556             case CHILDREN:
557                 return o->setChildren(v);
558             default:
559                 break;
560         }
561     }
562     else if (k == LINK)
563     {
564         switch (p)
565         {
566             default:
567                 break;
568         }
569     }
570     else if (k == PORT)
571     {
572         model::Port* o = getObject<model::Port>(uid);
573         switch (p)
574         {
575             case CONNECTED_SIGNALS:
576                 return o->setConnectedSignals(v);
577             default:
578                 break;
579         }
580     }
581     return FAIL;
582 }
583
584 } /* namespace org_scilab_modules_scicos */
585
586