Xcos MVC: implement params wpar / title / tol / tf / context
[scilab.git] / scilab / modules / scicos / src / cpp / model / Diagram.hxx
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 #ifndef DIAGRAM_HXX_
14 #define DIAGRAM_HXX_
15
16 #include <string>
17 #include <vector>
18
19 #include "Model.hxx"
20 #include "model/BaseObject.hxx"
21
22 namespace org_scilab_modules_scicos
23 {
24 namespace model
25 {
26
27 struct SimulationConfig
28 {
29     double final_time;          //!< Final simulation time.
30     double absolute_tolerance;  //!< Integrator absolute tolerance for the numerical solver.
31     double relative_tolerance;  //!< Integrator relative tolerance for the numerical solver.
32     double time_tolerance;      //!< Tolerance on time.
33     double delta_t;             //!< Maximum integration time interval.
34     double delta_h;             //!< Maximum step interval.
35     double realtime_scale;      //!< Real-time scaling; the value 0 corresponds to no real-time scaling.
36     double solver;              //!< Current numerical solver.
37
38     SimulationConfig() : final_time(100000), absolute_tolerance(1e-6), relative_tolerance(1e-6),
39         time_tolerance(1e-10), delta_t(final_time + 1), delta_h(0), realtime_scale(1), solver(0) {};
40
41     SimulationConfig(const SimulationConfig& p) :  final_time(p.final_time), absolute_tolerance(p.absolute_tolerance),
42         relative_tolerance(p.relative_tolerance), time_tolerance(p.time_tolerance), delta_t(p.delta_t),
43         delta_h(p.delta_h), realtime_scale(p.realtime_scale), solver(p.solver) {};
44
45     SimulationConfig(const std::vector<double>& p) : final_time(p[0]), absolute_tolerance(p[1]), relative_tolerance(p[2]),
46         time_tolerance(p[3]), delta_t(p[4]), delta_h(p[5]), realtime_scale(p[6]), solver(p[7]) {};
47
48     void fill(std::vector<double>& p) const
49     {
50         p.resize(8);
51         p[0] = final_time;
52         p[1] = absolute_tolerance;
53         p[2] = relative_tolerance;
54         p[3] = time_tolerance;
55         p[4] = delta_t;
56         p[5] = delta_h;
57         p[6] = realtime_scale;
58         p[7] = solver;
59     }
60     bool operator==(const SimulationConfig& p) const
61     {
62         return final_time == p.final_time && absolute_tolerance == p.absolute_tolerance &&
63                relative_tolerance == p.relative_tolerance && time_tolerance == p.time_tolerance &&
64                delta_t == p.delta_t && delta_h == p.delta_h && realtime_scale == p.realtime_scale && solver == p.solver;
65     }
66 };
67
68 class Diagram: public BaseObject
69 {
70 private:
71     friend class ::org_scilab_modules_scicos::Model;
72
73     Diagram() : BaseObject(DIAGRAM), title(), path(), properties(), context() {};
74     Diagram(const Diagram& o)  : BaseObject(DIAGRAM), title(o.title), path(o.path), properties(o.properties), context(o.context) {};
75     ~Diagram() {}
76
77     const std::vector<ScicosID>& getChildren() const
78     {
79         return children;
80     }
81
82     void setChildren(const std::vector<ScicosID>& children)
83     {
84         this->children = children;
85     }
86
87     void getContext(std::vector<std::string>& data) const
88     {
89         data = context;
90     }
91
92     update_status_t setContext(const std::vector<std::string>& data)
93     {
94         if (data == context)
95         {
96             return NO_CHANGES;
97         }
98
99         context = data;
100         return SUCCESS;
101     }
102
103     const std::vector<Datatype*>& getDatatypes() const
104     {
105         return datatypes;
106     }
107
108     void setDatatypes(const std::vector<Datatype*>& datatypes)
109     {
110         this->datatypes = datatypes;
111     }
112
113     void getProperties(std::vector<double>& v) const
114     {
115         properties.fill(v);
116     }
117
118     update_status_t setProperties(const std::vector<double>& v)
119     {
120         if (v.size() != 8)
121         {
122             return FAIL;
123         }
124
125         SimulationConfig p = SimulationConfig(v);
126         if (p == properties)
127         {
128             return NO_CHANGES;
129         }
130
131         properties = p;
132         return SUCCESS;
133     }
134
135     void getTitle(std::string& data) const
136     {
137         data = title;
138     }
139
140     update_status_t setTitle(const std::string& data)
141     {
142         if (data == title)
143         {
144             return NO_CHANGES;
145         }
146
147         title = data;
148         return SUCCESS;
149     }
150
151     void getPath(std::string& data) const
152     {
153         data = path;
154     }
155
156     update_status_t setPath(const std::string& data)
157     {
158         if (data == path)
159         {
160             return NO_CHANGES;
161         }
162
163         path = data;
164         return SUCCESS;
165     }
166
167     const std::string& getVersion() const
168     {
169         return version;
170     }
171
172     void setVersion(const std::string& version)
173     {
174         this->version = version;
175     }
176
177 private:
178     std::string title;
179     std::string path;
180     SimulationConfig properties;
181     std::vector<std::string> context;
182
183     std::vector<ScicosID> children;
184     std::vector<Datatype*> datatypes;
185
186     std::string version;
187 };
188
189 } /* namespace model */
190 } /* namespace org_scilab_modules_scicos */
191
192 #endif /* DIAGRAM_HXX_ */