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