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