Xcos MVC: blk.model.blocktype is a string
[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));
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));
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));
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));
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));
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         switch (p)
194         {
195             default:
196                 break;
197         }
198     }
199     else if (k == BLOCK)
200     {
201         switch (p)
202         {
203             default:
204                 break;
205         }
206     }
207     else if (k == DIAGRAM)
208     {
209         switch (p)
210         {
211             default:
212                 break;
213         }
214     }
215     else if (k == LINK)
216     {
217         model::Link* o = static_cast<model::Link*>(getObject(uid));
218         switch (p)
219         {
220             case SOURCE_PORT:
221                 return o->setSourcePort(v);
222             case DESTINATION_PORT:
223                 return o->setDestinationPort(v);
224             default:
225                 break;
226         }
227     }
228     else if (k == PORT)
229     {
230         model::Port* o = static_cast<model::Port*>(getObject(uid));
231         switch (p)
232         {
233             case SOURCE_BLOCK:
234                 return o->setSourceBlock(v);
235             case CONNECTED_SIGNALS:
236                 return o->setConnectedSignals(std::vector<ScicosID> (1, v));
237             default:
238                 break;
239         }
240     }
241     return FAIL;
242 }
243
244 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std::string v)
245 {
246
247     if (k == ANNOTATION)
248     {
249         switch (p)
250         {
251             default:
252                 break;
253         }
254     }
255     else if (k == BLOCK)
256     {
257         model::Block* o = static_cast<model::Block*>(getObject(uid));
258         switch (p)
259         {
260             case INTERFACE_FUNCTION:
261                 return o->setInterfaceFunction(v);
262             case SIM_FUNCTION_NAME:
263                 return o->setSimFunctionName(v);
264             case SIM_BLOCKTYPE:
265                 return o->setSimBlocktype(v);
266             case STYLE:
267                 return o->setStyle(v);
268             case LABEL:
269                 return o->setLabel(v);
270             case UID:
271                 return o->setUID(v);
272             default:
273                 break;
274         }
275     }
276     else if (k == DIAGRAM)
277     {
278         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
279         switch (p)
280         {
281             case TITLE:
282                 return o->setTitle(v);
283             case PATH:
284                 return o->setPath(v);
285             case VERSION_NUMBER:
286                 return o->setVersionNumber(v);
287             default:
288                 break;
289         }
290     }
291     else if (k == LINK)
292     {
293         model::Link* o = static_cast<model::Link*>(getObject(uid));
294         switch (p)
295         {
296             case LABEL:
297                 return o->setLabel(v);
298             default:
299                 break;
300         }
301     }
302     else if (k == PORT)
303     {
304         model::Port* o = static_cast<model::Port*>(getObject(uid));
305         switch (p)
306         {
307             case STYLE:
308                 return o->setStyle(v);
309             case LABEL:
310                 return o->setLabel(v);
311             default:
312                 break;
313         }
314     }
315     return FAIL;
316 }
317
318 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<double>& v)
319 {
320
321     if (k == ANNOTATION)
322     {
323         model::Annotation* o = static_cast<model::Annotation*>(getObject(uid));
324         switch (p)
325         {
326             case GEOMETRY:
327                 return o->setGeometry(v);
328             default:
329                 break;
330         }
331     }
332     else if (k == BLOCK)
333     {
334         model::Block* o = static_cast<model::Block*>(getObject(uid));
335         switch (p)
336         {
337             case GEOMETRY:
338                 return o->setGeometry(v);
339             case ANGLE:
340                 return o->setAngle(v);
341             case STATE:
342                 return o->setState(v);
343             case DSTATE:
344                 return o->setDState(v);
345             case RPAR:
346                 return o->setRpar(v);
347             default:
348                 break;
349         }
350     }
351     else if (k == DIAGRAM)
352     {
353         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
354         switch (p)
355         {
356             case PROPERTIES:
357                 return o->setProperties(v);
358             default:
359                 break;
360         }
361     }
362     else if (k == LINK)
363     {
364         model::Link* o = static_cast<model::Link*>(getObject(uid));
365         switch (p)
366         {
367             case CONTROL_POINTS:
368                 return o->setControlPoints(v);
369             case THICK:
370                 return o->setThick(v);
371             default:
372                 break;
373         }
374     }
375     else if (k == PORT)
376     {
377         switch (p)
378         {
379             default:
380                 break;
381         }
382     }
383     return FAIL;
384 }
385
386 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<int>& v)
387 {
388
389     if (k == ANNOTATION)
390     {
391         switch (p)
392         {
393             default:
394                 break;
395         }
396     }
397     else if (k == BLOCK)
398     {
399         model::Block* o = static_cast<model::Block*>(getObject(uid));
400         switch (p)
401         {
402             case SIM_DEP_UT:
403                 return o->setSimDepUT(v);
404             case IPAR:
405                 return o->setIpar(v);
406             default:
407                 break;
408         }
409     }
410     else if (k == DIAGRAM)
411     {
412         switch (p)
413         {
414             default:
415                 break;
416         }
417     }
418     else if (k == LINK)
419     {
420         switch (p)
421         {
422             default:
423                 break;
424         }
425     }
426     else if (k == PORT)
427     {
428         model::Port* o = static_cast<model::Port*>(getObject(uid));
429         switch (p)
430         {
431             case DATATYPE:
432                 return o->setDataType(this, v);
433             default:
434                 break;
435         }
436     }
437     return FAIL;
438 }
439
440 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<std::string>& v)
441 {
442
443     if (k == ANNOTATION)
444     {
445         switch (p)
446         {
447             default:
448                 break;
449         }
450     }
451     else if (k == BLOCK)
452     {
453         model::Block* o = static_cast<model::Block*>(getObject(uid));
454         switch (p)
455         {
456             case EXPRS:
457                 return o->setExprs(v);
458             default:
459                 break;
460         }
461     }
462     else if (k == DIAGRAM)
463     {
464         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
465         switch (p)
466         {
467             case DIAGRAM_CONTEXT:
468                 return o->setContext(v);
469             default:
470                 break;
471         }
472     }
473     else if (k == LINK)
474     {
475         switch (p)
476         {
477             default:
478                 break;
479         }
480     }
481     else if (k == PORT)
482     {
483         switch (p)
484         {
485             default:
486                 break;
487         }
488     }
489     return FAIL;
490 }
491
492 update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properties_t p, const std::vector<ScicosID>& v)
493 {
494
495     if (k == ANNOTATION)
496     {
497         switch (p)
498         {
499             default:
500                 break;
501         }
502     }
503     else if (k == BLOCK)
504     {
505         model::Block* o = static_cast<model::Block*>(getObject(uid));
506         switch (p)
507         {
508             case INPUTS:
509                 return o->setIn(v);
510             case OUTPUTS:
511                 return o->setOut(v);
512             case EVENT_INPUTS:
513                 return o->setEin(v);
514             case EVENT_OUTPUTS:
515                 return o->setEout(v);
516             default:
517                 break;
518         }
519     }
520     else if (k == DIAGRAM)
521     {
522         model::Diagram* o = static_cast<model::Diagram*>(getObject(uid));
523         switch (p)
524         {
525             case CHILDREN:
526                 return o->setChildren(v);
527             default:
528                 break;
529         }
530     }
531     else if (k == LINK)
532     {
533         switch (p)
534         {
535             default:
536                 break;
537         }
538     }
539     else if (k == PORT)
540     {
541         model::Port* o = static_cast<model::Port*>(getObject(uid));
542         switch (p)
543         {
544             case CONNECTED_SIGNALS:
545                 return o->setConnectedSignals(v);
546             default:
547                 break;
548         }
549     }
550     return FAIL;
551 }
552
553 } /* namespace org_scilab_modules_scicos */
554
555