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