Xcos MVC: implement graphics.flip, theta, exprs, pin, pout
[scilab.git] / scilab / modules / scicos / src / cpp / model / Block.hxx
index 20d0ca6..b1579b8 100644 (file)
@@ -27,27 +27,91 @@ namespace org_scilab_modules_scicos
 namespace model
 {
 
+/**
+ * Scilab data that can be passed to the simulator and simulation functions.
+ *
+ * This used the raw scicos-sim encoding to avoid any conversion out of the model.
+ */
+struct list_t
+{
+    // re-use the scicos sim encoding
+    int n;
+    int* sz;
+    int* typ;
+    void** data;
+};
+
 struct Parameter
 {
-    // FIXME: list the possible parameters kind, name, and so on
-    double foo;
+    std::vector<double> rpar;
+    std::vector<int> ipar;
+    list_t opar;
 };
 
-// FIXME add more values there
-enum SchedulingProperties
+struct State
+{
+    std::vector<double> state;
+    std::vector<int> dstate;
+    list_t odstate;
+};
+
+/**
+ * Mask list for all possible block scheduling descriptor from the simulator point of view.
+ *
+ * Examples:
+ *  * CONST_m == 0
+ *  * SUMMATION == DEP_U
+ *  * CLR == DEP_T
+ *  * SWITCH_f == DEP_U & DEP_T
+ */
+enum dep_ut_t
 {
     DEP_U       = 1 << 0, //!< y=f(u)
     DEP_T       = 1 << 1, //!< y=f(x)
-    BLOCKTYPE_H = 1 << 2, //!< y=f(u) but depends on t (if then else block)
+};
+
+enum blocktype_t
+{
+    BLOCKTYPE_C = 'c', //!< N/A ; dummy value used to represent a 'c' blocktype (eg. not 'd')
+    BLOCKTYPE_D = 'd', //!< N/A ; dummy value used to represent a 'd' blocktype (eg. not 'c')
+    BLOCKTYPE_H = 'h', //!< N/A ; used to represent blocks composed by blocks
+    BLOCKTYPE_L = 'l', //!< synchronization block ; ifthenelse and eselect
+    BLOCKTYPE_M = 'm', //!< memorization block ; see the Scicos original paper
+    BLOCKTYPE_X = 'x', //!< derivable block without state ; these blocks will be treated as if they contains a state.
+    BLOCKTYPE_Z = 'z', //!< zero-crossing block ; see the Scicos original paper.
 };
 
 struct Descriptor
 {
     std::string functionName;
-    int functionApi;
+    char functionApi;
 
-    // FIXME: should encode all possible values for dep_ut and blocktype
-    int schedulingProperties;
+    char dep_ut;            //!< dep_ut_t masked value
+    char blocktype;         //!< one of blocktype_t value
+};
+
+/*
+ * Flip and theta
+ */
+struct Angle
+{
+    bool flip;
+    double theta;
+
+    Angle() : flip(0), theta(0) {};
+    Angle(const Angle& a) : flip(a.flip), theta(a.theta) {};
+    Angle(const std::vector<double>& a) : flip((a[0] == 0) ? false : true), theta(a[1]) {};
+
+    void fill(std::vector<double>& a) const
+    {
+        a.resize(2);
+        a[0] = (flip == false) ? 0 : 1;
+        a[1] = theta;
+    }
+    bool operator==(const Angle& a) const
+    {
+        return flip == a.flip && theta == a.theta;
+    }
 };
 
 class Block: public BaseObject
@@ -90,20 +154,19 @@ private:
         this->eout = eout;
     }
 
-    void getGeometry(size_t* len, double** data) const
+    void getGeometry(std::vector<double>& v) const
     {
-        *len = 4;
-        *data = geometry.copy();
+        geometry.fill(v);
     }
 
-    update_status_t setGeometry(size_t len, double* data)
+    update_status_t setGeometry(const std::vector<double>& v)
     {
-        if (len != 4)
+        if (v.size() != 4)
         {
             return FAIL;
         }
 
-        Geometry g = Geometry(data);
+        Geometry g = Geometry(v);
         if (g == geometry)
         {
             return NO_CHANGES;
@@ -113,6 +176,44 @@ private:
         return SUCCESS;
     }
 
+    void getAngle(std::vector<double>& data) const
+    {
+        angle.fill(data);
+    }
+
+    update_status_t setAngle(const std::vector<double>& data)
+    {
+        if (data.size() != 2)
+        {
+            return FAIL;
+        }
+
+        Angle a = Angle(data);
+        if (a == angle)
+        {
+            return NO_CHANGES;
+        }
+
+        angle = a;
+        return SUCCESS;
+    }
+
+    void getExprs(std::vector<std::string>& data) const
+    {
+        data = exprs;
+    }
+
+    update_status_t setExprs(const std::vector<std::string>& data)
+    {
+        if (data == exprs)
+        {
+            return NO_CHANGES;
+        }
+
+        exprs = data;
+        return SUCCESS;
+    }
+
     const std::vector<ScicosID>& getIn() const
     {
         return in;
@@ -143,14 +244,14 @@ private:
         this->out = out;
     }
 
-    const Parameter& getParameters() const
+    const Parameter& getParameter() const
     {
-        return parameters;
+        return parameter;
     }
 
-    void setParameters(const Parameter& parameters)
+    void setParameter(const Parameter& parameter)
     {
-        this->parameters = parameters;
+        this->parameter = parameter;
     }
 
     ScicosID getParentBlock() const
@@ -206,6 +307,8 @@ private:
     ScicosID parentDiagram;
     std::string interfaceFunction;
     Geometry geometry;
+    Angle angle;
+    std::vector<std::string> exprs;
     std::string style;
 
     Descriptor sim;
@@ -215,7 +318,8 @@ private:
     std::vector<ScicosID> ein;
     std::vector<ScicosID> eout;
 
-    Parameter parameters;
+    Parameter parameter;
+    State state;
 
     /**
      * SuperBlock: the blocks, links and so on contained into this block