Xcos MVC: Fixed objects content for compatibility between Scicos and Xcos 19/17119/8
Paul Bignier [Tue, 25 Aug 2015 13:15:55 +0000 (15:15 +0200)]
 * A superblock still contains children information but not the whole diargam anymore: it is regenerated on demand

 * Example to show that all model elements are cleared (here with SuperBlock):
 grep "objectCreated" tests/unit_tests/model/SuperBlock.dia.ref | wc -l
  = 83
 grep "objectDeleted" tests/unit_tests/model/SuperBlock.dia.ref | wc -l
  = 83

Change-Id: I89c82e65d05cc838b0e270b87d9ba90717ae6878

26 files changed:
scilab/modules/scicos/src/cpp/Model_getObjectProperties.cpp
scilab/modules/scicos/src/cpp/Model_setObjectProperties.cpp
scilab/modules/scicos/src/cpp/model/Block.hxx
scilab/modules/scicos/src/cpp/model/Block.hxx.orig [new file with mode: 0644]
scilab/modules/scicos/src/cpp/view_scilab/BlockAdapter.cpp
scilab/modules/scicos/src/cpp/view_scilab/BlockAdapter.hxx
scilab/modules/scicos/src/cpp/view_scilab/DiagramAdapter.cpp
scilab/modules/scicos/src/cpp/view_scilab/DiagramAdapter.hxx
scilab/modules/scicos/src/cpp/view_scilab/LinkAdapter.cpp
scilab/modules/scicos/src/cpp/view_scilab/ModelAdapter.cpp
scilab/modules/scicos/src/cpp/view_scilab/ModelAdapter.cpp.orig [new file with mode: 0644]
scilab/modules/scicos/src/cpp/view_scilab/ports_management.hxx
scilab/modules/scicos/tests/unit_tests/model/Block.dia.ref
scilab/modules/scicos/tests/unit_tests/model/Block_copy_list.dia.ref
scilab/modules/scicos/tests/unit_tests/model/Consecutive_init.dia.ref
scilab/modules/scicos/tests/unit_tests/model/Deep_cloning.dia.ref
scilab/modules/scicos/tests/unit_tests/model/Delete_objects.dia.ref
scilab/modules/scicos/tests/unit_tests/model/Diagram.dia.ref
scilab/modules/scicos/tests/unit_tests/model/SubDiagram_context.dia.ref [new file with mode: 0644]
scilab/modules/scicos/tests/unit_tests/model/SubDiagram_context.tst [new file with mode: 0644]
scilab/modules/scicos/tests/unit_tests/model/SuperBlock.dia.ref
scilab/modules/scicos/tests/unit_tests/model/SuperBlock_in_SuperBlock.dia.ref
scilab/modules/scicos/tests/unit_tests/model/clone_extract.dia.ref
scilab/modules/scicos/tests/unit_tests/model/from_mlist.dia.ref
scilab/modules/scicos/tests/unit_tests/model/link_preservation.dia.ref
scilab/modules/scicos/tests/unit_tests/model/simple_delete.dia.ref

index 4c7d480..a8584bb 100644 (file)
@@ -643,6 +643,9 @@ bool Model::getObjectProperty(ScicosID uid, kind_t k, object_properties_t p, std
             case EQUATIONS:
                 o->getEquations(v);
                 return true;
+            case DIAGRAM_CONTEXT:
+                o->getContext(v);
+                return true;
             default:
                 break;
         }
index 34b84f4..8749734 100644 (file)
@@ -588,6 +588,8 @@ update_status_t Model::setObjectProperty(ScicosID uid, kind_t k, object_properti
         {
             case EQUATIONS:
                 return o->setEquations(v);
+            case DIAGRAM_CONTEXT:
+                return o->setContext(v);
             default:
                 break;
         }
index bd9e2c5..9ee22d5 100644 (file)
@@ -127,7 +127,7 @@ class Block: public BaseObject
 public:
     Block() : BaseObject(BLOCK), m_parentDiagram(ScicosID()), m_interfaceFunction(), m_geometry(), m_angle(),
         m_label(), m_style(), m_equations(), m_uid(), m_sim(), m_in(), m_out(), m_ein(), m_eout(),
-        m_parameter(), m_state(), m_parentBlock(ScicosID()), m_children(), m_portReference(ScicosID())
+        m_parameter(), m_state(), m_parentBlock(ScicosID()), m_children(), m_childrenColor(), m_context(), m_portReference(ScicosID())
     {
         // m_exprs default value is an empty matrix encoded by var2vec()
         m_exprs = {1, 2, 0, 0, 0};
@@ -138,7 +138,7 @@ public:
     Block(const Block& o) : BaseObject(BLOCK), m_parentDiagram(o.m_parentDiagram), m_interfaceFunction(o.m_interfaceFunction), m_geometry(o.m_geometry),
         m_angle(o.m_angle), m_exprs(o.m_exprs), m_label(o.m_label), m_style(o.m_style), m_nzcross(o.m_nzcross), m_nmode(o.m_nmode), m_equations(o.m_equations), m_uid(o.m_uid),
         m_sim(o.m_sim), m_in(o.m_in), m_out(o.m_out), m_ein(o.m_ein), m_eout(o.m_eout), m_parameter(o.m_parameter), m_state(o.m_state), m_parentBlock(o.m_parentBlock),
-        m_children(o.m_children), m_childrenColor(o.m_childrenColor), m_portReference(o.m_portReference) {}
+        m_children(o.m_children), m_childrenColor(o.m_childrenColor), m_context(o.m_context), m_portReference(o.m_portReference) {}
     ~Block() = default;
 
 private:
@@ -699,6 +699,22 @@ private:
         return SUCCESS;
     }
 
+    void getContext(std::vector<std::string>& data) const
+    {
+        data = m_context;
+    }
+
+    update_status_t setContext(const std::vector<std::string>& data)
+    {
+        if (data == m_context)
+        {
+            return NO_CHANGES;
+        }
+
+        m_context = data;
+        return SUCCESS;
+    }
+
 private:
     ScicosID m_parentDiagram;
     std::string m_interfaceFunction;
@@ -728,6 +744,7 @@ private:
     ScicosID m_parentBlock;
     std::vector<ScicosID> m_children;
     std::vector<int> m_childrenColor;
+    std::vector<std::string> m_context;
 
     /**
      * I/O Blocks: the corresponding parent port
diff --git a/scilab/modules/scicos/src/cpp/model/Block.hxx.orig b/scilab/modules/scicos/src/cpp/model/Block.hxx.orig
new file mode 100644 (file)
index 0000000..893bd00
--- /dev/null
@@ -0,0 +1,776 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2014-2014 - Scilab Enterprises - Clement DAVID
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+ *
+ */
+
+#ifndef BLOCK_HXX_
+#define BLOCK_HXX_
+
+#include <string>
+#include <vector>
+
+#include "utilities.hxx"
+#include "Model.hxx"
+#include "model/BaseObject.hxx"
+
+namespace org_scilab_modules_scicos
+{
+namespace model
+{
+
+struct Parameter
+{
+    std::vector<double> rpar;
+    std::vector<int> ipar;
+    std::vector<double> opar;
+
+    // opar default value is an empty list encoded by var2vec()
+    Parameter() : rpar(), ipar()
+    {
+        opar = {15, 0};
+    }
+};
+
+struct State
+{
+    std::vector<double> state;
+    std::vector<double> dstate;
+    std::vector<double> odstate;
+
+    // odstate default value is an empty list encoded by var2vec()
+    State() : state(), dstate()
+    {
+        odstate = {15, 0};
+    }
+};
+
+/**
+ * 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)
+};
+
+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 contain a state.
+    BLOCKTYPE_Z = 'z', //!< zero-crossing block ; see the Scicos original paper.
+};
+
+struct Descriptor
+{
+    std::string functionName;
+    int functionApi;
+
+    char dep_ut;            //!< dep_ut_t masked value
+    char blocktype;         //!< one of blocktype_t value
+
+    Descriptor() : functionName(), functionApi(0), dep_ut(0), blocktype(BLOCKTYPE_C) {}
+};
+
+/*
+ * Flip and theta
+ */
+struct Angle
+{
+    bool flip;
+    bool mirror;
+    double theta;
+
+    Angle() : flip(false), mirror(false), theta(0) {};
+    Angle(const Angle& a) : flip(a.flip), mirror(a.mirror), theta(a.theta) {};
+    Angle(const std::vector<double>& a) :
+        flip(  ((static_cast<int>(a[0]) & 0x0001) == 0) ? false : true),
+        mirror(((static_cast<int>(a[0]) & 0x0002) == 0) ? false : true),
+        theta(a[1])
+    {};
+
+    void fill(std::vector<double>& a) const
+    {
+        a.resize(2);
+
+        int mirrorAndFlip = static_cast<int>(a[0]);
+        (flip == false) ?   mirrorAndFlip &= ~(1 << 0) : mirrorAndFlip |= 1 << 0;
+        (mirror == false) ? mirrorAndFlip &= ~(1 << 1) : mirrorAndFlip |= 1 << 1;
+
+        a[0] = mirrorAndFlip;
+        a[1] = theta;
+    }
+    bool operator==(const Angle& a) const
+    {
+        return flip == a.flip && mirror == a.mirror && theta == a.theta;
+    }
+};
+
+class Block: public BaseObject
+{
+public:
+<<<<<<< HEAD
+    Block() : BaseObject(BLOCK), m_parentDiagram(ScicosID()), m_interfaceFunction(), m_geometry(), m_angle(),
+        m_label(), m_style(), m_equations(), m_uid(), m_sim(), m_in(), m_out(), m_ein(), m_eout(),
+        m_parameter(), m_state(), m_parentBlock(ScicosID()), m_children(), m_portReference(ScicosID())
+    {
+        // m_exprs default value is an empty matrix encoded by var2vec()
+        m_exprs = {1, 2, 0, 0, 0};
+        m_nmode = {0};
+        m_nzcross = {0};
+        m_childrenColor = { -1, 1};
+    }
+    Block(const Block& o) : BaseObject(BLOCK), m_parentDiagram(o.m_parentDiagram), m_interfaceFunction(o.m_interfaceFunction), m_geometry(o.m_geometry),
+        m_angle(o.m_angle), m_exprs(o.m_exprs), m_label(o.m_label), m_style(o.m_style), m_nzcross(o.m_nzcross), m_nmode(o.m_nmode), m_equations(o.m_equations), m_uid(o.m_uid),
+        m_sim(o.m_sim), m_in(o.m_in), m_out(o.m_out), m_ein(o.m_ein), m_eout(o.m_eout), m_parameter(o.m_parameter), m_state(o.m_state), m_parentBlock(o.m_parentBlock),
+        m_children(o.m_children), m_childrenColor(o.m_childrenColor), m_portReference(o.m_portReference) {}
+=======
+    Block() : BaseObject(BLOCK), m_parentDiagram(0), m_interfaceFunction(), m_geometry(), m_angle(),
+        m_exprs(std::vector<double> (5, 0)), m_label(), m_style(), m_nzcross(std::vector<int> (1, 0)), m_nmode(std::vector<int> (1, 0)), m_equations(), m_uid(), m_sim(), m_in(), m_out(), m_ein(), m_eout(),
+        m_parameter(), m_state(), m_parentBlock(0), m_children(), m_context(), m_portReference(0)
+    {
+        // By default, 'm_exprs' takes the value of vec2var([]), which is {12, 2, 0, 0, 0}
+        m_exprs[0] = 12;
+        m_exprs[1] = 2;
+    };
+    Block(const Block& o) : BaseObject(BLOCK), m_parentDiagram(o.m_parentDiagram), m_interfaceFunction(o.m_interfaceFunction), m_geometry(o.m_geometry),
+        m_angle(o.m_angle), m_exprs(o.m_exprs), m_label(o.m_label), m_style(o.m_style), m_nzcross(o.m_nzcross), m_nmode(o.m_nmode), m_equations(o.m_equations), m_uid(o.m_uid),
+        m_sim(o.m_sim), m_in(o.m_in), m_out(o.m_out), m_ein(o.m_ein), m_eout(o.m_eout), m_parameter(o.m_parameter), m_state(o.m_state), m_parentBlock(o.m_parentBlock),
+        m_children(o.m_children), m_context(o.m_context), m_portReference(o.m_portReference) {};
+>>>>>>> f7b3897... Xcos MVC: Fixed objects content for compatibility between Scicos and Xcos
+    ~Block() = default;
+
+private:
+    friend class ::org_scilab_modules_scicos::Model;
+
+    void getChildren(std::vector<ScicosID>& v) const
+    {
+        v = this->m_children;
+    }
+
+    update_status_t setChildren(const std::vector<ScicosID>& children)
+    {
+        if (children == this->m_children)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_children = children;
+        return SUCCESS;
+    }
+
+    void getChildrenColor(std::vector<int>& data) const
+    {
+        data = this->m_childrenColor;
+    }
+
+    update_status_t setChildrenColor(const std::vector<int>& data)
+    {
+        if (data == this->m_childrenColor)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_childrenColor = data;
+        return SUCCESS;
+    }
+
+    void getGeometry(std::vector<double>& v) const
+    {
+        m_geometry.fill(v);
+    }
+
+    update_status_t setGeometry(const std::vector<double>& v)
+    {
+        if (v.size() != 4)
+        {
+            return FAIL;
+        }
+
+        Geometry g = Geometry(v);
+        if (g == m_geometry)
+        {
+            return NO_CHANGES;
+        }
+
+        m_geometry = g;
+        return SUCCESS;
+    }
+
+    void getAngle(std::vector<double>& data) const
+    {
+        m_angle.fill(data);
+    }
+
+    update_status_t setAngle(const std::vector<double>& data)
+    {
+        if (data.size() != 2)
+        {
+            return FAIL;
+        }
+
+        Angle a = Angle(data);
+        if (a == m_angle)
+        {
+            return NO_CHANGES;
+        }
+
+        m_angle = a;
+        return SUCCESS;
+    }
+
+    void getExprs(std::vector<double>& data) const
+    {
+        data = m_exprs;
+    }
+
+    update_status_t setExprs(const std::vector<double>& data)
+    {
+        if (data == m_exprs)
+        {
+            return NO_CHANGES;
+        }
+
+        m_exprs = data;
+        return SUCCESS;
+    }
+
+    void getLabel(std::string& data) const
+    {
+        data = m_label;
+    }
+
+    update_status_t setLabel(const std::string& data)
+    {
+        if (data == m_label)
+        {
+            return NO_CHANGES;
+        }
+
+        m_label = data;
+        return SUCCESS;
+    }
+
+    void getIn(std::vector<ScicosID>& v) const
+    {
+        v = m_in;
+    }
+
+    update_status_t setIn(const std::vector<ScicosID>& in)
+    {
+        if (in == this->m_in)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_in = in;
+        return SUCCESS;
+    }
+
+    void getInterfaceFunction(std::string& fun) const
+    {
+        fun = m_interfaceFunction;
+    }
+
+    update_status_t setInterfaceFunction(const std::string& fun)
+    {
+        if (fun == m_interfaceFunction)
+        {
+            return NO_CHANGES;
+        }
+
+        m_interfaceFunction = fun;
+        return SUCCESS;
+    }
+
+    void getOut(std::vector<ScicosID>& v) const
+    {
+        v = m_out;
+    }
+
+    update_status_t setOut(const std::vector<ScicosID>& out)
+    {
+        if (out == this->m_out)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_out = out;
+        return SUCCESS;
+    }
+
+    void getEin(std::vector<ScicosID>& v) const
+    {
+        v = m_ein;
+    }
+
+    update_status_t setEin(const std::vector<ScicosID>& ein)
+    {
+        if (ein == this->m_ein)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_ein = ein;
+        return SUCCESS;
+    }
+
+    void getEout(std::vector<ScicosID>& v) const
+    {
+        v = m_eout;
+    }
+
+    update_status_t setEout(const std::vector<ScicosID>& eout)
+    {
+        if (eout == this->m_eout)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_eout = eout;
+        return SUCCESS;
+    }
+
+    const Parameter& getParameter() const
+    {
+        return m_parameter;
+    }
+
+    void setParameter(const Parameter& parameter)
+    {
+        this->m_parameter = parameter;
+    }
+
+    void getParentBlock(ScicosID& v) const
+    {
+        v = m_parentBlock;
+    }
+
+    update_status_t setParentBlock(ScicosID parentBlock)
+    {
+        if (parentBlock == this->m_parentBlock)
+        {
+            return NO_CHANGES;
+        }
+
+        this->m_parentBlock = parentBlock;
+        return SUCCESS;
+    }
+
+    void getParentDiagram(ScicosID& v) const
+    {
+        v = m_parentDiagram;
+    }
+
+    update_status_t setParentDiagram(const ScicosID v)
+    {
+        if (v == m_parentDiagram)
+        {
+            return NO_CHANGES;
+        }
+
+        m_parentDiagram = v;
+        return SUCCESS;
+    }
+
+    void getPortReference(ScicosID& v) const
+    {
+        v = m_portReference;
+    }
+
+    update_status_t setPortReference(const ScicosID v)
+    {
+        if (v == m_portReference)
+        {
+            return NO_CHANGES;
+        }
+
+        m_portReference = v;
+        return SUCCESS;
+    }
+
+    const Descriptor& getSim() const
+    {
+        return m_sim;
+    }
+
+    void setSim(const Descriptor& sim)
+    {
+        this->m_sim = sim;
+    }
+
+    void getStyle(std::string& data) const
+    {
+        data = m_style;
+    }
+
+    update_status_t setStyle(const std::string& data)
+    {
+        if (data == m_style)
+        {
+            return NO_CHANGES;
+        }
+
+        m_style = data;
+        return SUCCESS;
+    }
+
+    void getNZcross(std::vector<int>& data) const
+    {
+        data = m_nzcross;
+    }
+
+    update_status_t setNZcross(const std::vector<int>& data)
+    {
+        if (data == m_nzcross)
+        {
+            return NO_CHANGES;
+        }
+
+        m_nzcross = data;
+        return SUCCESS;
+    }
+
+    void getNMode(std::vector<int>& data) const
+    {
+        data = m_nmode;
+    }
+
+    update_status_t setNMode(const std::vector<int>& data)
+    {
+        if (data == m_nmode)
+        {
+            return NO_CHANGES;
+        }
+
+        m_nmode = data;
+        return SUCCESS;
+    }
+
+    void getEquations(std::vector<std::string>& data) const
+    {
+        data = m_equations;
+    }
+
+    update_status_t setEquations(const std::vector<std::string>& data)
+    {
+        if (data == m_equations)
+        {
+            return NO_CHANGES;
+        }
+
+        m_equations = data;
+        return SUCCESS;
+    }
+
+    void getUID(std::string& data) const
+    {
+        data = m_uid;
+    }
+
+    update_status_t setUID(const std::string& data)
+    {
+        if (data == m_uid)
+        {
+            return NO_CHANGES;
+        }
+
+        m_uid = data;
+        return SUCCESS;
+    }
+
+    void getRpar(std::vector<double>& data) const
+    {
+        data = m_parameter.rpar;
+    }
+
+    update_status_t setRpar(const std::vector<double>& data)
+    {
+        if (data == m_parameter.rpar)
+        {
+            return NO_CHANGES;
+        }
+
+        m_parameter.rpar = data;
+        return SUCCESS;
+    }
+
+    void getIpar(std::vector<int>& data) const
+    {
+        data = m_parameter.ipar;
+    }
+
+    update_status_t setIpar(const std::vector<int>& data)
+    {
+        if (data == m_parameter.ipar)
+        {
+            return NO_CHANGES;
+        }
+
+        m_parameter.ipar = data;
+        return SUCCESS;
+    }
+
+    void getOpar(std::vector<double>& data) const
+    {
+        data = m_parameter.opar;
+    }
+
+    update_status_t setOpar(const std::vector<double>& data)
+    {
+        if (data == m_parameter.opar)
+        {
+            return NO_CHANGES;
+        }
+
+        m_parameter.opar = data;
+        return SUCCESS;
+    }
+
+    void getSimFunctionName(std::string& data) const
+    {
+        data = m_sim.functionName;
+    }
+
+    update_status_t setSimFunctionName(const std::string& data)
+    {
+        if (data == m_sim.functionName)
+        {
+            return NO_CHANGES;
+        }
+
+        m_sim.functionName = data;
+        return SUCCESS;
+    }
+
+    void getSimFunctionApi(int& data) const
+    {
+        data = m_sim.functionApi;
+    }
+
+    update_status_t setSimFunctionApi(const int data)
+    {
+        if (data == m_sim.functionApi)
+        {
+            return NO_CHANGES;
+        }
+
+        m_sim.functionApi = data;
+        return SUCCESS;
+    }
+
+    void getSimBlocktype(std::string& data) const
+    {
+        data = std::string(1, m_sim.blocktype);
+    }
+
+    update_status_t setSimBlocktype(const std::string data)
+    {
+        if (data.size() != 1)
+        {
+            return FAIL;
+        }
+
+        char c = *(data.c_str());
+
+        if (c == m_sim.blocktype)
+        {
+            return NO_CHANGES;
+        }
+
+        switch (c)
+        {
+            case BLOCKTYPE_C:
+            case BLOCKTYPE_D:
+            case BLOCKTYPE_H:
+            case BLOCKTYPE_L:
+            case BLOCKTYPE_M:
+            case BLOCKTYPE_X:
+            case BLOCKTYPE_Z:
+                m_sim.blocktype = c;
+                return SUCCESS;
+            default:
+                return FAIL;
+        }
+    }
+
+    void getSimDepUT(std::vector<int>& data) const
+    {
+        data.resize(2, 0);
+        switch (m_sim.dep_ut)
+        {
+            case DEP_U & DEP_T:
+                // data is already set to [0 0] here.
+                break;
+            case DEP_U:
+                data[0] = 1;
+                break;
+            case DEP_T:
+                data[1] = 1;
+                break;
+            case DEP_U | DEP_T:
+                data[0] = 1;
+                data[1] = 1;
+                break;
+            default:
+                break;
+        }
+    }
+
+    update_status_t setSimDepUT(const std::vector<int>& data)
+    {
+        if (data.size() != 2)
+        {
+            return FAIL;
+        }
+
+        int dep = DEP_U & DEP_T;
+        if (data[0])
+        {
+            if (data[1])
+            {
+                dep = DEP_U | DEP_T;
+            }
+            else
+            {
+                dep = DEP_U;
+            }
+        }
+        else if (data[1])
+        {
+            dep = DEP_T;
+        }
+
+        if (dep == m_sim.dep_ut)
+        {
+            return NO_CHANGES;
+        }
+
+        m_sim.dep_ut = dep;
+        return SUCCESS;
+    }
+
+    void getState(std::vector<double>& data) const
+    {
+        data = m_state.state;
+    }
+
+    update_status_t setState(const std::vector<double>& data)
+    {
+        if (data == m_state.state)
+        {
+            return NO_CHANGES;
+        }
+
+        m_state.state = data;
+        return SUCCESS;
+    }
+
+    void getDState(std::vector<double>& data) const
+    {
+        data = m_state.dstate;
+    }
+
+    update_status_t setDState(const std::vector<double>& data)
+    {
+        if (data == m_state.dstate)
+        {
+            return NO_CHANGES;
+        }
+
+        m_state.dstate = data;
+        return SUCCESS;
+    }
+
+    void getODState(std::vector<double>& data) const
+    {
+        data = m_state.odstate;
+    }
+
+    update_status_t setODState(const std::vector<double>& data)
+    {
+        if (data == m_state.odstate)
+        {
+            return NO_CHANGES;
+        }
+
+        m_state.odstate = data;
+        return SUCCESS;
+    }
+
+    void getContext(std::vector<std::string>& data) const
+    {
+        data = m_context;
+    }
+
+    update_status_t setContext(const std::vector<std::string>& data)
+    {
+        if (data == m_context)
+        {
+            return NO_CHANGES;
+        }
+
+        m_context = data;
+        return SUCCESS;
+    }
+
+private:
+    ScicosID m_parentDiagram;
+    std::string m_interfaceFunction;
+    Geometry m_geometry;
+    Angle m_angle;
+    std::vector<double> m_exprs;
+    std::string m_label;
+    std::string m_style;
+    std::vector<int> m_nzcross;
+    std::vector<int> m_nmode;
+    std::vector<std::string> m_equations;
+    std::string m_uid;
+
+    Descriptor m_sim;
+
+    std::vector<ScicosID> m_in;
+    std::vector<ScicosID> m_out;
+    std::vector<ScicosID> m_ein;
+    std::vector<ScicosID> m_eout;
+
+    Parameter m_parameter;
+    State m_state;
+
+    /**
+     * SuperBlock: the blocks, links and so on contained into this block
+     */
+    ScicosID m_parentBlock;
+    std::vector<ScicosID> m_children;
+<<<<<<< HEAD
+    std::vector<int> m_childrenColor;
+=======
+    std::vector<std::string> m_context;
+>>>>>>> f7b3897... Xcos MVC: Fixed objects content for compatibility between Scicos and Xcos
+
+    /**
+     * I/O Blocks: the corresponding parent port
+     */
+    ScicosID m_portReference;
+};
+
+} /* namespace model */
+} /* namespace org_scilab_modules_scicos */
+
+#endif /* BLOCK_HXX_ */
index c7ddebc..37f758b 100644 (file)
@@ -64,22 +64,63 @@ struct model
 {
     static types::InternalType* get(const BlockAdapter& adaptor, const Controller& controller)
     {
-        ModelAdapter localAdaptor(controller, controller.referenceObject(adaptor.getAdaptee()), adaptor.getDiagram());
+        // If we are in a Superblock (has children) then reconstruct a DiagramAdapter, referencing the children
+        DiagramAdapter* subDiagram = nullptr;
+        std::vector<ScicosID> children;
+        controller.getObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, children);
+        if (!children.empty())
+        {
+            Controller neededController = const_cast<Controller&>(controller);
+            ScicosID newDiag = neededController.createObject(DIAGRAM);
+            subDiagram = new DiagramAdapter(controller, static_cast<org_scilab_modules_scicos::model::Diagram*>(controller.getObject(newDiag)));
+            neededController.setObjectProperty(newDiag, DIAGRAM, CHILDREN, children);
+
+            for (const ScicosID id : children)
+            {
+                auto o = controller.getObject(id);
+                neededController.setObjectProperty(o->id(), o->kind(), PARENT_DIAGRAM, newDiag);
+                neededController.referenceObject(o->id());
+            }
+            subDiagram->setFrom(adaptor.getFrom());
+            subDiagram->setTo(adaptor.getTo());
+            subDiagram->setListObjects(adaptor.getListObjects());
+            subDiagram->setContribContent(adaptor.getContribContent());
+
+            std::vector<std::string> context;
+            controller.getObjectProperty(adaptor.getAdaptee()->id(), BLOCK, DIAGRAM_CONTEXT, context);
+            neededController.setObjectProperty(newDiag, DIAGRAM, DIAGRAM_CONTEXT, context);
+        }
+
+        ModelAdapter localAdaptor(controller, controller.referenceObject(adaptor.getAdaptee()), subDiagram);
         types::InternalType* mlist = localAdaptor.getAsTList(new types::MList(), controller)->getAs<types::MList>();
 
-        const_cast<BlockAdapter&>(adaptor).setDiagram(localAdaptor.getDiagram());
+        if (localAdaptor.getDiagram() != nullptr)
+        {
+            // To handle the copy constructor case calling model::set
+            const_cast<BlockAdapter&>(adaptor).setFrom(localAdaptor.getDiagram()->getFrom());
+            const_cast<BlockAdapter&>(adaptor).setTo(localAdaptor.getDiagram()->getTo());
+            const_cast<BlockAdapter&>(adaptor).setListObjects(localAdaptor.getDiagram()->getListObjects());
+            const_cast<BlockAdapter&>(adaptor).setContribContent(localAdaptor.getDiagram()->getContribContent());
+        }
+
         return mlist;
     }
 
     static bool set(BlockAdapter& adaptor, types::InternalType* v, Controller& controller)
     {
-        ModelAdapter localAdaptor(controller, controller.referenceObject(adaptor.getAdaptee()), adaptor.getDiagram());
+        ModelAdapter localAdaptor(controller, controller.referenceObject(adaptor.getAdaptee()), nullptr);
         if (!localAdaptor.setAsTList(v, controller))
         {
             return false;
         }
 
-        adaptor.setDiagram(localAdaptor.getDiagram());
+        if (localAdaptor.getDiagram() != nullptr)
+        {
+            adaptor.setFrom(localAdaptor.getDiagram()->getFrom());
+            adaptor.setTo(localAdaptor.getDiagram()->getTo());
+            adaptor.setListObjects(localAdaptor.getDiagram()->getListObjects());
+            adaptor.setContribContent(localAdaptor.getDiagram()->getContribContent());
+        }
         return true;
     }
 };
@@ -139,8 +180,11 @@ template<> property<BlockAdapter>::props_t property<BlockAdapter>::fields = prop
 
 BlockAdapter::BlockAdapter(const Controller& c, org_scilab_modules_scicos::model::Block* adaptee) :
     BaseAdapter<BlockAdapter, org_scilab_modules_scicos::model::Block>(c, adaptee),
-    diagramAdapter(nullptr),
-    doc_content(nullptr)
+    doc_content(nullptr),
+    from_vec(),
+    to_vec(),
+    list_objects(nullptr),
+    contrib_content(nullptr)
 {
     if (property<BlockAdapter>::properties_have_not_been_set())
     {
@@ -151,22 +195,32 @@ BlockAdapter::BlockAdapter(const Controller& c, org_scilab_modules_scicos::model
         property<BlockAdapter>::add_property(L"doc", &doc::get, &doc::set);
     }
 
+    setListObjects(new types::List());
+    setContribContent(new types::List());
     setDocContent(new types::List());
 }
 
 BlockAdapter::BlockAdapter(const BlockAdapter& adapter) :
     BaseAdapter<BlockAdapter, org_scilab_modules_scicos::model::Block>(adapter, false),
-    diagramAdapter(nullptr),
-    doc_content(nullptr)
+    doc_content(nullptr),
+    from_vec(),
+    to_vec(),
+    list_objects(nullptr),
+    contrib_content(nullptr)
 {
     Controller controller;
 
-    if (adapter.getDiagram() != nullptr)
+    if (adapter.getListObjects()->getSize() > 0)
     {
         types::InternalType* model = model::get(adapter, controller);
         model::set(*this, model, controller);
         model->killMe();
     }
+    else
+    {
+        setListObjects(new types::List());
+        setContribContent(new types::List());
+    }
 
     setDocContent(adapter.getDocContent());
 }
@@ -175,10 +229,16 @@ BlockAdapter::~BlockAdapter()
 {
     // CHILDREN will be unreferenced on Controller::deleteObject
 
-    if (diagramAdapter != nullptr)
+    if (list_objects != nullptr)
+    {
+        list_objects->DecreaseRef();
+        list_objects->killMe();
+    }
+
+    if (contrib_content != nullptr)
     {
-        diagramAdapter->DecreaseRef();
-        diagramAdapter->killMe();
+        contrib_content->DecreaseRef();
+        contrib_content->killMe();
     }
 
     doc_content->DecreaseRef();
@@ -195,21 +255,57 @@ std::wstring BlockAdapter::getShortTypeStr()
     return getSharedTypeStr();
 }
 
-DiagramAdapter* BlockAdapter::getDiagram() const
+types::InternalType* BlockAdapter::getDocContent() const
 {
-    return diagramAdapter;
+    return doc_content;
 }
 
-void BlockAdapter::setDiagram(DiagramAdapter* v)
+void BlockAdapter::setDocContent(types::InternalType* v)
 {
-    // The old 'diagramAdapter' needs to be freed after setting it to 'v'
-    DiagramAdapter* temp = diagramAdapter;
+    types::InternalType* temp = doc_content;
+
+    v->IncreaseRef();
+    doc_content = v;
 
-    if (v != nullptr)
+    if (temp != nullptr)
     {
-        v->IncreaseRef();
-        diagramAdapter = v;
+        temp->DecreaseRef();
+        temp->killMe();
     }
+}
+
+std::vector<link_t> BlockAdapter::getFrom() const
+{
+    return from_vec;
+}
+
+void BlockAdapter::setFrom(const std::vector<link_t>& from)
+{
+    from_vec = from;
+}
+
+std::vector<link_t> BlockAdapter::getTo() const
+{
+    return to_vec;
+}
+
+void BlockAdapter::setTo(const std::vector<link_t>& to)
+{
+    to_vec = to;
+}
+
+types::List* BlockAdapter::getListObjects() const
+{
+    return list_objects;
+}
+
+void BlockAdapter::setListObjects(types::List* v)
+{
+    types::InternalType* temp = list_objects;
+
+    // Do not check if v is nullptr on purpose ; it *should* not
+    v->IncreaseRef();
+    list_objects = v;
 
     if (temp != nullptr)
     {
@@ -218,17 +314,18 @@ void BlockAdapter::setDiagram(DiagramAdapter* v)
     }
 }
 
-types::InternalType* BlockAdapter::getDocContent() const
+types::InternalType* BlockAdapter::getContribContent() const
 {
-    return doc_content;
+    return contrib_content;
 }
 
-void BlockAdapter::setDocContent(types::InternalType* v)
+void BlockAdapter::setContribContent(types::InternalType* v)
 {
-    types::InternalType* temp = doc_content;
+    types::InternalType* temp = contrib_content;
 
+    // do not check if v is nullptr on purpose ; it *should* not
     v->IncreaseRef();
-    doc_content = v;
+    contrib_content = v;
 
     if (temp != nullptr)
     {
index 08520e6..af148ce 100644 (file)
 #define BLOCKADAPTER_HXX_
 
 #include <string>
+#include <vector>
 
 #include "internal.hxx"
+#include "list.hxx"
 
 #include "BaseAdapter.hxx"
-#include "DiagramAdapter.hxx"
+#include "adapters_utilities.hxx"
 #include "model/Block.hxx"
 
 namespace org_scilab_modules_scicos
@@ -41,16 +43,32 @@ public:
     std::wstring getTypeStr();
     std::wstring getShortTypeStr();
 
-    DiagramAdapter* getDiagram() const;
-    void setDiagram(DiagramAdapter* newDiagram);
-
     types::InternalType* getDocContent() const;
     void setDocContent(types::InternalType* v);
 
-private:
-    DiagramAdapter* diagramAdapter;
+    types::List* getListObjects() const;
+    void setListObjects(types::List* blocks);
+
+    std::vector<link_t> getFrom() const;
+    void setFrom(const std::vector<link_t>& from);
+    std::vector<link_t> getTo() const;
+    void setTo(const std::vector<link_t>& to);
+
+    types::InternalType* getContribContent() const;
+    void setContribContent(types::InternalType* contrib);
 
+private:
     types::InternalType* doc_content;
+
+    // The following content represents the child diagram (in 'model.rpar')
+    // Child elements info
+    types::List* list_objects;
+
+    // Child links info
+    std::vector<link_t> from_vec;
+    std::vector<link_t> to_vec;
+    // child diagram info
+    types::InternalType* contrib_content;
 };
 
 } /* namespace view_scilab */
index 5fdbba5..f069e15 100644 (file)
 #include <sstream>
 #include <algorithm>
 
+#include "types.hxx"
 #include "internal.hxx"
 #include "double.hxx"
+#include "string.hxx"
 #include "list.hxx"
 #include "mlist.hxx"
 #include "tlist.hxx"
-#include "string.hxx"
-#include "types.hxx"
 #include "user.hxx"
 
 #include "utilities.hxx"
@@ -74,24 +74,63 @@ struct props
 struct objs
 {
 
-    static types::InternalType* get(const DiagramAdapter& adaptor, const Controller& /*controller*/)
+    static types::InternalType* get(const DiagramAdapter& adaptor, const Controller& controller)
     {
-        // FIXME: reconstruct the list of objects accordingly to the CHILDREN content to manage xcos modification
-        return adaptor.getListObjects();
+        model::Diagram* adaptee = adaptor.getAdaptee();
+
+        std::vector<ScicosID> children;
+        controller.getObjectProperty(adaptee->id(), DIAGRAM, CHILDREN, children);
+        types::List* ret = new types::List();
+        int link_i = 0;
+        for (int i = 0; i < static_cast<int>(children.size()); ++i)
+        {
+            if (children[i] == 0ll)
+            {
+                // Deleted adapter
+                types::MList* deleted = new types::MList();
+                deleted->set(0, new types::String(Deleted.data()));
+                ret->append(deleted);
+                continue;
+            }
+
+            auto o = controller.getObject(children[i]);
+            controller.referenceObject(o);
+
+            switch (o->kind())
+            {
+                case ANNOTATION :
+                    ret->append(new TextAdapter(controller, static_cast<model::Annotation*>(o)));
+                    break;
+                case BLOCK :
+                {
+                    BlockAdapter* block = new BlockAdapter(controller, static_cast<model::Block*>(o));
+                    BlockAdapter* oldBlock = adaptor.getListObjects()->get(i)->getAs<BlockAdapter>();
+                    block->setFrom(oldBlock->getFrom());
+                    block->setTo(oldBlock->getTo());
+                    block->setListObjects(oldBlock->getListObjects());
+                    block->setContribContent(oldBlock->getContribContent());
+                    ret->append(block);
+                    break;
+                }
+                default : // LINK
+                    LinkAdapter* link = new LinkAdapter(controller, static_cast<model::Link*>(o));
+                    link->setFrom(adaptor.getFrom()[link_i]);
+                    link->setTo(adaptor.getTo()[link_i]);
+                    link_i++;
+                    ret->append(link);
+                    break;
+            }
+        }
+
+        return ret;
     }
 
     /**
-     * Clone the object if it is owned by something else than the list
+     * Clone the object if it is owned by something else
      */
-    static types::InternalType* cloneIfNeeded(types::InternalType* v, const std::vector<types::InternalType*>& oldChildren)
+    static types::InternalType* cloneIfNeeded(types::InternalType* v)
     {
-        if (v->getRef() == 0)
-        {
-            return v;
-        }
-
-        // avoid a copy, if v is already in the previous children list and will be cleanup later
-        if (v->getRef() == 1 && std::binary_search(oldChildren.begin(), oldChildren.end(), v))
+        if (v->getRef() == 0 || v->getRef() == 1)
         {
             return v;
         }
@@ -134,7 +173,6 @@ struct objs
 
         types::List* argumentList = v->getAs<types::List>();
         types::List* list = new types::List();
-        std::vector<types::InternalType*> oldChildren = extractAndSort(adaptor.getListObjects());
 
         std::vector<ScicosID> oldDiagramChildren;
         controller.getObjectProperty(adaptee->id(), DIAGRAM, CHILDREN, oldDiagramChildren);
@@ -169,7 +207,7 @@ struct objs
                 {
                     case Adapters::BLOCK_ADAPTER:
                     {
-                        BlockAdapter* modelElement = cloneIfNeeded(argumentList->get(i), oldChildren)->getAs<BlockAdapter>();
+                        BlockAdapter* modelElement = cloneIfNeeded(argumentList->get(i))->getAs<BlockAdapter>();
                         id = modelElement->getAdaptee()->id();
                         kind = modelElement->getAdaptee()->kind();
                         adapter = modelElement;
@@ -177,7 +215,7 @@ struct objs
                     }
                     case Adapters::LINK_ADAPTER:
                     {
-                        LinkAdapter* modelElement = cloneIfNeeded(argumentList->get(i), oldChildren)->getAs<LinkAdapter>();
+                        LinkAdapter* modelElement = cloneIfNeeded(argumentList->get(i))->getAs<LinkAdapter>();
                         id = modelElement->getAdaptee()->id();
                         kind = modelElement->getAdaptee()->kind();
                         adapter = modelElement;
@@ -188,7 +226,7 @@ struct objs
                     }
                     case Adapters::TEXT_ADAPTER:
                     {
-                        TextAdapter* modelElement = cloneIfNeeded(argumentList->get(i), oldChildren)->getAs<TextAdapter>();
+                        TextAdapter* modelElement = cloneIfNeeded(argumentList->get(i))->getAs<TextAdapter>();
                         id = modelElement->getAdaptee()->id();
                         kind = modelElement->getAdaptee()->kind();
                         adapter = modelElement;
@@ -290,11 +328,10 @@ struct objs
             TextAdapter* localAdaptor = new TextAdapter(controller, controller.getObject<model::Annotation>(localAdaptee));
             if (!localAdaptor->setAsTList(argumentList->get(index), controller))
             {
-                // do not return there ; the annotation will be empty
+                // Do not return there ; the annotation will be empty
             }
 
             diagramChildren[index] = localAdaptee;
-            list->set(index, localAdaptor);
         }
 
         /*
@@ -339,7 +376,7 @@ struct objs
         }
 
         /*
-         * Store the children to the local adaptor, avoiding the deletion of argument
+         * Store the children in the local adaptor, avoiding the deletion of argument
          */
         v->IncreaseRef();
         adaptor.setListObjects(list);
@@ -442,9 +479,9 @@ template<> property<DiagramAdapter>::props_t property<DiagramAdapter>::fields =
 
 DiagramAdapter::DiagramAdapter(const Controller& c, org_scilab_modules_scicos::model::Diagram* adaptee) :
     BaseAdapter<DiagramAdapter, org_scilab_modules_scicos::model::Diagram>(c, adaptee),
-    list_objects(nullptr),
     from_vec(),
     to_vec(),
+    list_objects(nullptr),
     contrib_content(nullptr)
 {
     if (property<DiagramAdapter>::properties_have_not_been_set())
@@ -462,9 +499,9 @@ DiagramAdapter::DiagramAdapter(const Controller& c, org_scilab_modules_scicos::m
 
 DiagramAdapter::DiagramAdapter(const DiagramAdapter& adapter) :
     BaseAdapter<DiagramAdapter, org_scilab_modules_scicos::model::Diagram>(adapter, false),
-    list_objects(nullptr),
     from_vec(),
     to_vec(),
+    list_objects(nullptr),
     contrib_content(nullptr)
 {
     Controller controller;
@@ -479,8 +516,11 @@ DiagramAdapter::~DiagramAdapter()
 {
     // CHILDREN will be unreferenced on Controller::deleteObject
 
-    list_objects->DecreaseRef();
-    list_objects->killMe();
+    if (list_objects != nullptr)
+    {
+        list_objects->DecreaseRef();
+        list_objects->killMe();
+    }
 
     contrib_content->DecreaseRef();
     contrib_content->killMe();
@@ -495,28 +535,6 @@ std::wstring DiagramAdapter::getShortTypeStr()
     return getSharedTypeStr();
 }
 
-types::InternalType* DiagramAdapter::getContribContent() const
-{
-    return contrib_content;
-}
-
-void DiagramAdapter::setContribContent(types::InternalType* v)
-{
-    types::InternalType* temp = contrib_content;
-
-    // do not check if v is nullptr on purpose ; it *should* not
-    v->IncreaseRef();
-    contrib_content = v;
-
-    if (temp != nullptr)
-    {
-        temp->DecreaseRef();
-        temp->killMe();
-    }
-
-
-}
-
 types::List* DiagramAdapter::getListObjects() const
 {
     return list_objects;
@@ -526,7 +544,7 @@ void DiagramAdapter::setListObjects(types::List* v)
 {
     types::InternalType* temp = list_objects;
 
-    // do not check if v is nullptr on purpose ; it *should* not
+    // Do not check if v is nullptr on purpose ; it *should* not
     v->IncreaseRef();
     list_objects = v;
 
@@ -557,5 +575,25 @@ void DiagramAdapter::setTo(const std::vector<link_t>& to)
     to_vec = to;
 }
 
+types::InternalType* DiagramAdapter::getContribContent() const
+{
+    return contrib_content;
+}
+
+void DiagramAdapter::setContribContent(types::InternalType* v)
+{
+    types::InternalType* temp = contrib_content;
+
+    // do not check if v is nullptr on purpose ; it *should* not
+    v->IncreaseRef();
+    contrib_content = v;
+
+    if (temp != nullptr)
+    {
+        temp->DecreaseRef();
+        temp->killMe();
+    }
+}
+
 } /* namespace view_scilab */
 } /* namespace org_scilab_modules_scicos */
index 3de9a44..32fdb2a 100644 (file)
@@ -55,8 +55,10 @@ public:
     void setContribContent(types::InternalType* v);
 
 private:
+    // Infos for the child elements
     types::List* list_objects;
 
+    // Infos for the child links
     std::vector<link_t> from_vec;
     std::vector<link_t> to_vec;
 
index ad825ca..0e4464c 100644 (file)
@@ -319,13 +319,25 @@ link_t getLinkEnd(const LinkAdapter& adaptor, const Controller& controller, cons
 
         // Looking for the block number among the block IDs
         ScicosID parentDiagram;
-        controller.getObjectProperty(adaptee, BLOCK, PARENT_DIAGRAM, parentDiagram);
+        controller.getObjectProperty(adaptee, LINK, PARENT_DIAGRAM, parentDiagram);
         std::vector<ScicosID> children;
         if (parentDiagram == 0)
         {
-            return ret;
+            ScicosID parentBlock;
+            controller.getObjectProperty(adaptee, LINK, PARENT_BLOCK, parentBlock);
+            if (parentBlock == 0)
+            {
+                return ret;
+            }
+            // Added to a superblock
+            controller.getObjectProperty(parentBlock, BLOCK, CHILDREN, children);
         }
-        controller.getObjectProperty(parentDiagram, DIAGRAM, CHILDREN, children);
+        else
+        {
+            // Added to a diagram
+            controller.getObjectProperty(parentDiagram, DIAGRAM, CHILDREN, children);
+        }
+
         ret.block = static_cast<int>(std::distance(children.begin(), std::find(children.begin(), children.end(), sourceBlock)) + 1);
 
         // To find the port index from its 'endID' ID, search through all the block's ports lists
@@ -449,8 +461,19 @@ void setLinkEnd(const ScicosID id, Controller& controller, const object_properti
     std::vector<ScicosID> children;
     if (parentDiagram != 0)
     {
+        // Adding to a diagram
         controller.getObjectProperty(parentDiagram, DIAGRAM, CHILDREN, children);
     }
+    else
+    {
+        ScicosID parentBlock;
+        controller.getObjectProperty(id, LINK, PARENT_BLOCK, parentBlock);
+        if (parentBlock != 0)
+        {
+            // Adding to a superblock
+            controller.getObjectProperty(parentBlock, BLOCK, CHILDREN, children);
+        }
+    }
 
     // Connect the new one
 
@@ -874,8 +897,10 @@ void LinkAdapter::setFromInModel(const link_t& v, Controller& controller)
 
     ScicosID parentDiagram;
     controller.getObjectProperty(getAdaptee()->id(), LINK, PARENT_DIAGRAM, parentDiagram);
+    ScicosID parentBlock;
+    controller.getObjectProperty(getAdaptee()->id(), LINK, PARENT_BLOCK, parentBlock);
 
-    if (parentDiagram != 0)
+    if (parentDiagram != 0 || parentBlock != 0)
     {
         // If the Link has been added to a diagram, do the linking at model-level
         // If the provided values are wrong, the model is not updated but the info is stored in the Adapter for future attempts
@@ -899,8 +924,10 @@ void LinkAdapter::setToInModel(const link_t& v, Controller& controller)
 
     ScicosID parentDiagram;
     controller.getObjectProperty(getAdaptee()->id(), LINK, PARENT_DIAGRAM, parentDiagram);
+    ScicosID parentBlock;
+    controller.getObjectProperty(getAdaptee()->id(), LINK, PARENT_BLOCK, parentBlock);
 
-    if (parentDiagram != 0)
+    if (parentDiagram != 0 || parentBlock != 0)
     {
         // If the Link has been added to a diagram, do the linking at model-level
         // If the provided values are wrong, the model is not updated but the info is stored in the Adapter for future attempts
index 285ca9d..f836533 100644 (file)
 
 #include "Controller.hxx"
 #include "ModelAdapter.hxx"
+#include "LinkAdapter.hxx"
+#include "DiagramAdapter.hxx"
 
 #include "view_scilab/Adapters.hxx"
-#include "DiagramAdapter.hxx"
 #include "ports_management.hxx"
 #include "utilities.hxx"
 #include "controller_helpers.hxx"
@@ -97,7 +98,7 @@ struct sim
             types::String* current = v->getAs<types::String>();
             if (current->getSize() != 1)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "sim", 1, 1);
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : %d-by-%d expected.\n"), "model", "sim", 1, 1);
                 return false;
             }
 
@@ -117,19 +118,19 @@ struct sim
             types::List* current = v->getAs<types::List>();
             if (current->getSize() != 2)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong length for field %s.%s: %d expected.\n"), "model", "sim", 2);
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong length for field %s.%s : %d expected.\n"), "model", "sim", 2);
                 return false;
             }
             if (current->get(0)->getType() != types::InternalType::ScilabString || current->get(1)->getType() != types::InternalType::ScilabDouble)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : string expected.\n"), "model", "sim");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : String matrix expected.\n"), "model", "sim");
                 return false;
             }
 
             types::String* Name = current->get(0)->getAs<types::String>();
             if (Name->getSize() != 1)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "sim(1)", 1, 1);
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : %d-by-%d expected.\n"), "model", "sim(1)", 1, 1);
                 return false;
             }
             char* c_str = wide_string_to_UTF8(Name->get(0));
@@ -139,13 +140,13 @@ struct sim
             types::Double* Api = current->get(1)->getAs<types::Double>();
             if (Api->getSize() != 1)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "sim(2)", 1, 1);
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : %d-by-%d expected.\n"), "model", "sim(2)", 1, 1);
                 return false;
             }
             double api = Api->get(0);
             if (floor(api) != api)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Round number expected.\n"), "model", "sim(2)");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : Round number expected.\n"), "model", "sim(2)");
                 return false;
             }
             int api_int = static_cast<int>(api);
@@ -155,7 +156,7 @@ struct sim
         }
         else
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : string expected.\n"), "model", "sim");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : String matrix expected.\n"), "model", "sim");
             return false;
         }
         return true;
@@ -300,7 +301,7 @@ struct state
 
         if (v->getType() != types::InternalType::ScilabDouble)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "state");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "state");
             return false;
         }
 
@@ -308,7 +309,7 @@ struct state
         // Only allow vectors and empty matrices
         if (!current->isVector() && current->getSize() != 0)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong size for field %s.%s: %d-by-%d expected.\n"), "model", "state");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong size for field %s.%s : %d-by-%d expected.\n"), "model", "state");
             return false;
         }
 
@@ -356,7 +357,7 @@ struct dstate
             types::String* current = v->getAs<types::String>();
             if (current->getSize() != 1)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "dstate");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "dstate");
                 return false;
             }
 
@@ -367,14 +368,14 @@ struct dstate
 
         if (v->getType() != types::InternalType::ScilabDouble)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "dstate");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "dstate");
             return false;
         }
         types::Double* current = v->getAs<types::Double>();
         // Only allow vectors and empty matrices
         if (!current->isVector() && current->getSize() != 0)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 expected.\n"), "model", "dstate");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : m-by-1 expected.\n"), "model", "dstate");
             return false;
         }
 
@@ -671,7 +672,7 @@ bool encode(std::vector<int>& prop_content, types::List* list)
                 encode(prop_content, list->get(i)->getAs<types::Bool>());
                 break;
             default:
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: List expected.\n"), "model", "props");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : List expected.\n"), "model", "props");
                 return false;
         }
     }
@@ -750,7 +751,7 @@ bool setInnerBlocksRefs(ModelAdapter& adaptor, const std::vector<ScicosID>& chil
 
     for (std::vector<ScicosID>::const_iterator it = children.begin(); it != children.end(); ++it)
     {
-        if (*it == ScicosID())
+        if (*it == 0ll)
         {
             continue; // Rule out mlists (Deleted or Annotations)
         }
@@ -769,7 +770,7 @@ bool setInnerBlocksRefs(ModelAdapter& adaptor, const std::vector<ScicosID>& chil
                 {
                     std::string uid;
                     controller.getObjectProperty(*it, BLOCK, UID, uid);
-                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid port number.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : %s (%s) has an invalid port number.\n"), "model", "rpar", name.c_str(), uid.c_str());
                     return false;
                 }
                 int portIndex = ipar[0];
@@ -815,7 +816,7 @@ bool setInnerBlocksRefs(ModelAdapter& adaptor, const std::vector<ScicosID>& chil
                     {
                         std::string uid;
                         controller.getObjectProperty(*it, BLOCK, UID, uid);
-                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid port number.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : %s (%s) has an invalid port number.\n"), "model", "rpar", name.c_str(), uid.c_str());
                         return false;
                     }
                 }
@@ -831,7 +832,7 @@ bool setInnerBlocksRefs(ModelAdapter& adaptor, const std::vector<ScicosID>& chil
                     {
                         std::string uid;
                         controller.getObjectProperty(*it, BLOCK, UID, uid);
-                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid implicit port.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : %s (%s) has an invalid implicit port.\n"), "model", "rpar", name.c_str(), uid.c_str());
                         return false;
                     }
                 }
@@ -841,7 +842,7 @@ bool setInnerBlocksRefs(ModelAdapter& adaptor, const std::vector<ScicosID>& chil
                     {
                         std::string uid;
                         controller.getObjectProperty(*it, BLOCK, UID, uid);
-                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid explicit port.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : %s (%s) has an invalid explicit port.\n"), "model", "rpar", name.c_str(), uid.c_str());
                         return false;
                     }
                 }
@@ -917,23 +918,16 @@ struct rpar
             const Adapters::adapters_index_t adapter_index = Adapters::instance().lookup_by_typename(v->getShortTypeStr());
             if (adapter_index != Adapters::DIAGRAM_ADAPTER)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Diagram expected.\n"), "model", "rpar");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Diagram expected.\n"), "model", "rpar");
                 return false;
             }
 
-            // Translate 'v' to an DiagramAdapter ; copy if needed
-            DiagramAdapter* diagram;
-            if (v->getRef() > 1)
-            {
-                diagram = v->clone()->getAs<DiagramAdapter>();
-            }
-            else
-            {
-                diagram = v->getAs<DiagramAdapter>();
-            }
+            // Translate 'v' to an DiagramAdapter
+            DiagramAdapter* diagram = v->getAs<DiagramAdapter>();
+
             adaptor.setDiagram(diagram);
 
-            // set the diagram children as block children ; referencing them
+            // Set the diagram children as block children
             std::vector<ScicosID> diagramChildren;
             controller.getObjectProperty(diagram->getAdaptee()->id(), DIAGRAM, CHILDREN, diagramChildren);
             if (diagramChildren.empty())
@@ -944,33 +938,52 @@ struct rpar
             std::vector<ScicosID> oldDiagramChildren;
             controller.getObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, oldDiagramChildren);
 
-            controller.setObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, diagramChildren);
+            std::sort(oldDiagramChildren.begin(), oldDiagramChildren.end());
+            std::vector<ScicosID> clonedChildren;
+            std::vector<ScicosID> clonedLinks;
+            for (const ScicosID & id : diagramChildren)
             {
-                std::sort(oldDiagramChildren.begin(), oldDiagramChildren.end());
-                for (const ScicosID id : diagramChildren)
+                if (id != 0 && !std::binary_search(oldDiagramChildren.begin(), oldDiagramChildren.end(), id))
                 {
-                    if (id != 0 && !std::binary_search(oldDiagramChildren.begin(), oldDiagramChildren.end(), id))
-                    {
-                        auto o = controller.getObject(id);
-                        controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, adaptor.getAdaptee()->id());
+                    ScicosID cloneID = controller.cloneObject(id, true, true);
+                    auto o = controller.getObject(cloneID);
+                    controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, adaptor.getAdaptee()->id());
 
-                        controller.referenceObject(id);
+                    clonedChildren.push_back(cloneID);
+                    if (o->kind() == LINK)
+                    {
+                        clonedLinks.push_back(cloneID);
                     }
                 }
+            }
+            controller.setObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, clonedChildren);
 
-                std::sort(diagramChildren.begin(), diagramChildren.end());
-                for (const ScicosID id : oldDiagramChildren)
+            std::sort(diagramChildren.begin(), diagramChildren.end());
+            for (const ScicosID & id : oldDiagramChildren)
+            {
+                if (id != 0 && !std::binary_search(diagramChildren.begin(), diagramChildren.end(), id))
                 {
-                    if (id != 0 && !std::binary_search(diagramChildren.begin(), diagramChildren.end(), id))
-                    {
-                        auto o = controller.getObject(id);
-                        controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, ScicosID());
+                    auto o = controller.getObject(id);
+                    controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, ScicosID());
 
-                        controller.deleteObject(id);
-                    }
+                    controller.deleteObject(id);
                 }
             }
 
+            // After cloning the diagram elements, re-sync the link information
+            for (int i = 0; i < static_cast<int>(clonedLinks.size()); ++i)
+            {
+                auto o = controller.getObject(clonedLinks[i]);
+                LinkAdapter* newLink = new LinkAdapter(controller, static_cast<model::Link*>(o));
+                newLink->setFromInModel(diagram->getFrom()[i], controller);
+                newLink->setToInModel(diagram->getTo()[i], controller);
+            }
+
+            // Save the context
+            std::vector<std::string> context;
+            controller.getObjectProperty(diagram->getAdaptee()->id(), DIAGRAM, DIAGRAM_CONTEXT, context);
+            controller.setObjectProperty(adaptor.getAdaptee()->id(), BLOCK, DIAGRAM_CONTEXT, context);
+
             // Link the Superblock ports to their inner "port blocks"
             return setInnerBlocksRefs(adaptor, diagramChildren, controller);
         }
@@ -1029,7 +1042,7 @@ struct rpar
         }
         else
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "rpar");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "rpar");
             return false;
         }
     }
@@ -1069,21 +1082,21 @@ struct ipar
         {
             std::vector<int> ipar;
             controller.setObjectProperty(adaptee, BLOCK, IPAR, ipar);
-            get_or_allocate_logger()->log(LOG_TRACE, _("Wrong type for field %s.%s: List clear previous value.\n"), "model", "ipar");
+            get_or_allocate_logger()->log(LOG_TRACE, _("Wrong type for field %s.%s : List clear previous value.\n"), "model", "ipar");
             return true;
         }
 
         // FIXME: ScilabInts should be managed there
         if (v->getType() != types::InternalType::ScilabDouble)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "ipar");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "ipar");
             return false;
         }
         types::Double* current = v->getAs<types::Double>();
         // Only allow vectors and empty matrices
         if (!current->isVector() && current->getSize() != 0)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 matrix expected.\n"), "model", "ipar");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : m-by-1 matrix expected.\n"), "model", "ipar");
             return false;
         }
 
@@ -1092,7 +1105,7 @@ struct ipar
         {
             if (floor(current->get(i)) != current->get(i))
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Integer values expected.\n"), "model", "ipar");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : Integer values expected.\n"), "model", "ipar");
                 return false;
             }
             ipar[i] = static_cast<int>(current->get(i));
@@ -1179,14 +1192,14 @@ struct blocktype
 
         if (v->getType() != types::InternalType::ScilabString)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: String expected.\n"), "model", "blocktype");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : String expected.\n"), "model", "blocktype");
             return false;
         }
 
         types::String* current = v->getAs<types::String>();
         if (current->getSize() != 1)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: String expected.\n"), "model", "blocktype");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : String expected.\n"), "model", "blocktype");
             return false;
         }
 
@@ -1238,14 +1251,14 @@ struct dep_ut
 
         if (v->getType() != types::InternalType::ScilabBool)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Boolean matrix expected.\n"), "model", "dep_ut");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Boolean matrix expected.\n"), "model", "dep_ut");
             return false;
         }
 
         types::Bool* current = v->getAs<types::Bool>();
         if (current->getSize() != 2)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "dep_ut", 1, 2);
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : %d-by-%d expected.\n"), "model", "dep_ut", 1, 2);
             return false;
         }
 
@@ -1278,14 +1291,14 @@ struct label
     {
         if (v->getType() != types::InternalType::ScilabString)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: String expected.\n"), "model", "label");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : String expected.\n"), "model", "label");
             return false;
         }
 
         types::String* current = v->getAs<types::String>();
         if (current->getSize() != 1)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: String expected.\n"), "model", "label");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : String expected.\n"), "model", "label");
             return false;
         }
 
@@ -1327,7 +1340,7 @@ struct nzcross
 
         if (v->getType() != types::InternalType::ScilabDouble)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "nzcross");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "nzcross");
             return false;
         }
 
@@ -1335,7 +1348,7 @@ struct nzcross
         // Only allow vectors and empty matrices
         if (!current->isVector() && current->getSize() != 0)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 expected.\n"), "model", "nzcross");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : m-by-1 expected.\n"), "model", "nzcross");
             return false;
         }
 
@@ -1344,7 +1357,7 @@ struct nzcross
         {
             if (floor(current->get(i)) != current->get(i))
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Integer values expected.\n"), "model", "nzcross");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : Integer values expected.\n"), "model", "nzcross");
                 return false;
             }
             nzcross[i] = static_cast<int>(current->get(i));
@@ -1382,7 +1395,7 @@ struct nmode
 
         if (v->getType() != types::InternalType::ScilabDouble)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "nmode");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Real matrix expected.\n"), "model", "nmode");
             return false;
         }
 
@@ -1390,7 +1403,7 @@ struct nmode
         // Only allow vectors and empty matrices
         if (!current->isVector() && current->getSize() != 0)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 expected.\n"), "model", "nzcross");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : m-by-1 expected.\n"), "model", "nzcross");
             return false;
         }
 
@@ -1399,7 +1412,7 @@ struct nmode
         {
             if (floor(current->get(i)) != current->get(i))
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Integer values expected.\n"), "model", "nzcross");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s : Integer values expected.\n"), "model", "nzcross");
                 return false;
             }
             nmode[i] = static_cast<int>(current->get(i));
@@ -1452,7 +1465,7 @@ struct equations
         std::istringstream inputsSizeStr (equations[1]);
         int inputsSize;
         inputsSizeStr >> inputsSize;
-        if (inputsSize <= 0 || inputsSize > int(equations.size() - 2))
+        if (inputsSize <= 0 || inputsSize > equations.size() - 2)
         {
             types::Double* inputsField = types::Double::Empty();
             o->set(2, inputsField);
@@ -1474,7 +1487,7 @@ struct equations
         std::istringstream outputsSizeStr (equations[2 + inputsSize]);
         int outputsSize;
         outputsSizeStr >> outputsSize;
-        if (outputsSize <= 0 || outputsSize > int(equations.size() - 3 - inputsSize))
+        if (outputsSize <= 0 || outputsSize > equations.size() - 3 - inputsSize)
         {
             types::Double* outputsField = types::Double::Empty();
             o->set(3, outputsField);
@@ -1499,7 +1512,7 @@ struct equations
         std::istringstream parametersSizeStr (equations[3 + inputsSize + outputsSize]);
         int parametersSize;
         parametersSizeStr >> parametersSize;
-        if (parametersSize <= 0 || parametersSize > int(equations.size() - 4 - inputsSize - outputsSize))
+        if (parametersSize <= 0 || parametersSize > equations.size() - 4 - inputsSize - outputsSize)
         {
             types::Double* parametersNames = types::Double::Empty();
             parametersField->set(0, parametersNames);
@@ -1528,7 +1541,6 @@ struct equations
             parametersValues->set(i, parametersValue);
         }
         parametersField->set(1, parametersValues);
-        parametersValues->killMe();
 
         // 'parameters' states (optional, only check its presence if at least one parameter is present)
         if (parametersSize != 0)
@@ -1549,7 +1561,6 @@ struct equations
         }
 
         o->set(4, parametersField);
-        parametersField->killMe();
 
         return o;
     }
@@ -1563,7 +1574,7 @@ struct equations
             types::List* current = v->getAs<types::List>();
             if (current->getSize() != 0)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
             return true;
@@ -1580,32 +1591,32 @@ struct equations
         types::String* header = current->getFieldNames();
         if (header->getSize() != 5)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
         if (header->get(0) != modelica)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
         if (header->get(1) != model)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
         if (header->get(2) != inputs)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
         if (header->get(3) != outputs)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
         if (header->get(4) != parameters)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
 
@@ -1618,7 +1629,7 @@ struct equations
             types::String* modelField = current->get(1)->getAs<types::String>();
             if (modelField->getSize() != 1)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1632,7 +1643,7 @@ struct equations
             types::Double* modelFieldDouble = current->get(1)->getAs<types::Double>();
             if (modelFieldDouble->getSize() != 0)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1641,7 +1652,7 @@ struct equations
         }
         else
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
 
@@ -1652,7 +1663,7 @@ struct equations
             types::Double* inputsField = current->get(2)->getAs<types::Double>();
             if (inputsField->getSize() != 0)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1666,7 +1677,7 @@ struct equations
         {
             if (current->get(2)->getType() != types::InternalType::ScilabString)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1693,7 +1704,7 @@ struct equations
             types::Double* outputsField = current->get(3)->getAs<types::Double>();
             if (outputsField->getSize() != 0)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1707,7 +1718,7 @@ struct equations
         {
             if (current->get(3)->getType() != types::InternalType::ScilabString)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1735,7 +1746,7 @@ struct equations
             types::Double* emptyMatrix = current->get(parametersIndex)->getAs<types::Double>();
             if (emptyMatrix->getSize() != 0)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1744,14 +1755,14 @@ struct equations
 
         if (current->get(parametersIndex)->getType() != types::InternalType::ScilabList)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
 
         types::List* list = current->get(parametersIndex)->getAs<types::List>();
         if (list->getSize() != 2 && list->getSize() != 3)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
             return false;
         }
 
@@ -1762,7 +1773,7 @@ struct equations
             types::Double* parametersNames = list->get(0)->getAs<types::Double>();
             if (parametersNames->getSize() != 0)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1780,7 +1791,7 @@ struct equations
         {
             if (list->get(0)->getType() != types::InternalType::ScilabString)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1806,7 +1817,7 @@ struct equations
             types::Double* parameterVal = list->get(1)->getAs<types::Double>();
             if (parameterVal->getSize() != static_cast<int>(parametersSize))
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1822,14 +1833,14 @@ struct equations
         {
             if (list->get(1)->getType() != types::InternalType::ScilabList)
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
             types::List* list2 = list->get(1)->getAs<types::List>();
             if (list2->getSize() != static_cast<int>(parametersSize))
             {
-                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                 return false;
             }
 
@@ -1838,14 +1849,14 @@ struct equations
             {
                 if (list2->get(static_cast<int>(i))->getType() != types::InternalType::ScilabDouble)
                 {
-                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                     return false;
                 }
 
                 types::Double* parametersVal = list2->get(static_cast<int>(i))->getAs<types::Double>();
                 if (parametersVal->getSize() != 1)
                 {
-                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : Equation expected.\n"), "model", "equations");
                     return false;
                 }
 
@@ -1906,14 +1917,14 @@ struct uid
     {
         if (v->getType() != types::InternalType::ScilabString)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: String expected.\n"), "model", "uid");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : String expected.\n"), "model", "uid");
             return false;
         }
 
         types::String* current = v->getAs<types::String>();
         if (current->getSize() != 1)
         {
-            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: String expected.\n"), "model", "uid");
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s : String expected.\n"), "model", "uid");
             return false;
         }
 
diff --git a/scilab/modules/scicos/src/cpp/view_scilab/ModelAdapter.cpp.orig b/scilab/modules/scicos/src/cpp/view_scilab/ModelAdapter.cpp.orig
new file mode 100644 (file)
index 0000000..0a1e19d
--- /dev/null
@@ -0,0 +1,2021 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2014-2014 - Scilab Enterprises - Clement DAVID
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+ *
+ */
+
+#include <cwchar>
+#include <cstring>
+
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+
+#include "bool.hxx"
+#include "int.hxx"
+#include "double.hxx"
+#include "string.hxx"
+#include "list.hxx"
+#include "tlist.hxx"
+#include "user.hxx"
+
+#include "Controller.hxx"
+<<<<<<< HEAD
+=======
+#include "Adapters.hxx"
+#include "LinkAdapter.hxx"
+>>>>>>> f7b3897... Xcos MVC: Fixed objects content for compatibility between Scicos and Xcos
+#include "ModelAdapter.hxx"
+
+#include "view_scilab/Adapters.hxx"
+#include "DiagramAdapter.hxx"
+#include "ports_management.hxx"
+#include "utilities.hxx"
+#include "controller_helpers.hxx"
+
+#include "var2vec.hxx"
+#include "vec2var.hxx"
+
+extern "C" {
+#include "sci_malloc.h"
+#include "charEncoding.h"
+#include "localization.h"
+}
+
+namespace org_scilab_modules_scicos
+{
+namespace view_scilab
+{
+namespace
+{
+
+const std::wstring modelica (L"modelica");
+const std::wstring model (L"model");
+const std::wstring inputs (L"inputs");
+const std::wstring outputs (L"outputs");
+const std::wstring parameters (L"parameters");
+
+struct sim
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        // First, extract the function Name
+        std::string name;
+        controller.getObjectProperty(adaptee, BLOCK, SIM_FUNCTION_NAME, name);
+        types::String* Name = new types::String(1, 1);
+        Name->set(0, name.data());
+
+        // Then the Api. If it is zero, then just return the Name. Otherwise, return a list containing both.
+        int api;
+        controller.getObjectProperty(adaptee, BLOCK, SIM_FUNCTION_API, api);
+
+        if (api == 0)
+        {
+            return Name;
+        }
+        else
+        {
+            types::Double* Api = new types::Double(static_cast<double>(api));
+            types::List* o = new types::List();
+            o->set(0, Name);
+            o->set(1, Api);
+            return o;
+        }
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() == types::InternalType::ScilabString)
+        {
+            types::String* current = v->getAs<types::String>();
+            if (current->getSize() != 1)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "sim", 1, 1);
+                return false;
+            }
+
+            char* c_str = wide_string_to_UTF8(current->get(0));
+            std::string name(c_str);
+            FREE(c_str);
+
+            // If the input is a scalar string, then the functionApi is 0.
+            int api = 0;
+
+            controller.setObjectProperty(adaptee, BLOCK, SIM_FUNCTION_NAME, name);
+            controller.setObjectProperty(adaptee, BLOCK, SIM_FUNCTION_API, api);
+        }
+        else if (v->getType() == types::InternalType::ScilabList)
+        {
+            // If the input is a 2-sized list, then it must be string and positive integer.
+            types::List* current = v->getAs<types::List>();
+            if (current->getSize() != 2)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong length for field %s.%s: %d expected.\n"), "model", "sim", 2);
+                return false;
+            }
+            if (current->get(0)->getType() != types::InternalType::ScilabString || current->get(1)->getType() != types::InternalType::ScilabDouble)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : string expected.\n"), "model", "sim");
+                return false;
+            }
+
+            types::String* Name = current->get(0)->getAs<types::String>();
+            if (Name->getSize() != 1)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "sim(1)", 1, 1);
+                return false;
+            }
+            char* c_str = wide_string_to_UTF8(Name->get(0));
+            std::string name(c_str);
+            FREE(c_str);
+
+            types::Double* Api = current->get(1)->getAs<types::Double>();
+            if (Api->getSize() != 1)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "sim(2)", 1, 1);
+                return false;
+            }
+            double api = Api->get(0);
+            if (floor(api) != api)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Round number expected.\n"), "model", "sim(2)");
+                return false;
+            }
+            int api_int = static_cast<int>(api);
+
+            controller.setObjectProperty(adaptee, BLOCK, SIM_FUNCTION_NAME, name);
+            controller.setObjectProperty(adaptee, BLOCK, SIM_FUNCTION_API, api_int);
+        }
+        else
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s : string expected.\n"), "model", "sim");
+            return false;
+        }
+        return true;
+    }
+};
+
+struct in
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, INPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return update_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, INPUTS, controller, v);
+    }
+};
+
+struct in2
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_COLS>(adaptor, INPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return set_ports_property<ModelAdapter, DATATYPE_COLS>(adaptor, INPUTS, controller, v);
+    }
+};
+
+struct intyp
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_TYPE>(adaptor, INPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return set_ports_property<ModelAdapter, DATATYPE_TYPE>(adaptor, INPUTS, controller, v);
+    }
+};
+
+struct out
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, OUTPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return update_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, OUTPUTS, controller, v);
+    }
+};
+
+struct out2
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_COLS>(adaptor, OUTPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return set_ports_property<ModelAdapter, DATATYPE_COLS>(adaptor, OUTPUTS, controller, v);
+    }
+};
+
+struct outtyp
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_TYPE>(adaptor, OUTPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return set_ports_property<ModelAdapter, DATATYPE_TYPE>(adaptor, OUTPUTS, controller, v);
+    }
+};
+
+struct evtin
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, EVENT_INPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return update_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, EVENT_INPUTS, controller, v);
+    }
+};
+
+struct evtout
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, EVENT_OUTPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return update_ports_property<ModelAdapter, DATATYPE_ROWS>(adaptor, EVENT_OUTPUTS, controller, v);
+    }
+};
+
+struct state
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<double> state;
+        controller.getObjectProperty(adaptee, BLOCK, STATE, state);
+
+        double* data;
+        types::Double* o = new types::Double((int)state.size(), 1, &data);
+
+#ifdef _MSC_VER
+        std::copy(state.begin(), state.end(), stdext::checked_array_iterator<double*>(data, state.size()));
+#else
+        std::copy(state.begin(), state.end(), data);
+#endif
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+
+        if (v->getType() != types::InternalType::ScilabDouble)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "state");
+            return false;
+        }
+
+        types::Double* current = v->getAs<types::Double>();
+        // Only allow vectors and empty matrices
+        if (!current->isVector() && current->getSize() != 0)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong size for field %s.%s: %d-by-%d expected.\n"), "model", "state");
+            return false;
+        }
+
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<double> state (current->getSize());
+        std::copy(current->getReal(), current->getReal() + current->getSize(), state.begin());
+
+        controller.setObjectProperty(adaptee, BLOCK, STATE, state);
+        return true;
+    }
+};
+
+struct dstate
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<double> dstate;
+        controller.getObjectProperty(adaptee, BLOCK, DSTATE, dstate);
+
+        double* data;
+        types::Double* o = new types::Double((int)dstate.size(), 1, &data);
+
+#ifdef _MSC_VER
+        std::copy(dstate.begin(), dstate.end(), stdext::checked_array_iterator<double*>(data, dstate.size()));
+#else
+        std::copy(dstate.begin(), dstate.end(), data);
+#endif
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() == types::InternalType::ScilabString)
+        {
+            /*
+             * This seems to be a corner-case used for code generation on ScicosLab
+             */
+
+            types::String* current = v->getAs<types::String>();
+            if (current->getSize() != 1)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "dstate");
+                return false;
+            }
+
+            std::vector<double> dstate;
+            controller.setObjectProperty(adaptee, BLOCK, DSTATE, dstate);
+            return true;
+        }
+
+        if (v->getType() != types::InternalType::ScilabDouble)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "dstate");
+            return false;
+        }
+        types::Double* current = v->getAs<types::Double>();
+        // Only allow vectors and empty matrices
+        if (!current->isVector() && current->getSize() != 0)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 expected.\n"), "model", "dstate");
+            return false;
+        }
+
+        std::vector<double> dstate (current->getSize());
+        std::copy(current->getReal(), current->getReal() + current->getSize(), dstate.begin());
+
+        controller.setObjectProperty(adaptee, BLOCK, DSTATE, dstate);
+        return true;
+    }
+};
+
+void decodeDims(std::vector<int>::iterator& prop_it, std::vector<int>& dims)
+{
+    const int iDims = *prop_it++;
+    dims.resize(iDims);
+
+    memcpy(&dims[0], &(*prop_it), iDims * sizeof(int));
+    prop_it += iDims;
+}
+
+void encodeDims(std::vector<int>& prop_content, types::GenericType* v)
+{
+    const int iDims = v->getDims();
+    prop_content.push_back(iDims);
+
+    const int index = prop_content.size();
+    prop_content.resize(index + iDims);
+
+    memcpy(&prop_content[index], v->getDimsArray(), iDims * sizeof(int));
+}
+
+/**
+ * Calculate the length increment depending on the ::value_type of the buffer and the type of the Scilab type
+ *
+ * @param V buffer type which must have a ::value_type field
+ * @param T Scilab type
+ * @param v the instance on the Scilab type
+ * @return the number of V elements used to store the data
+ */
+template<typename V, typename T>
+size_t required_length(const V& /*it*/, T* v)
+{
+    const size_t sizeof_prop_value = sizeof(typename V::value_type);
+    if (sizeof(typename T::type) >= sizeof_prop_value)
+    {
+        return v->getSize() * sizeof(typename T::type) / sizeof_prop_value;
+    }
+    else
+    {
+        // increase the size to contain enough space, manage the size_t rounding issue
+        return v->getSize() * sizeof(typename T::type) + (sizeof_prop_value - 1) / sizeof_prop_value;
+    }
+}
+
+template <typename T>
+T* decode(std::vector<int>::iterator& prop_it)
+{
+    std::vector<int> dims;
+    decodeDims(prop_it, dims);
+
+    T* v = new T(static_cast<int>(dims.size()), &dims[0]);
+    memcpy(v->get(), &(*prop_it), v->getSize() * sizeof(typename T::type));
+
+    prop_it += required_length(prop_it, v);
+    return v;
+}
+
+template <typename T>
+bool encode(std::vector<int>& prop_content, T* v)
+{
+    encodeDims(prop_content, v);
+
+    const int index = prop_content.size();
+    const int len = required_length(prop_content, v);
+    prop_content.resize(index + len);
+
+    // Using contiguity of the memory, we save the input into 'prop_content'
+    memcpy(&prop_content[index], v->get(), v->getSize() * sizeof(typename T::type));
+    return true;
+}
+
+template<>
+types::Double* decode(std::vector<int>::iterator& prop_it)
+{
+    std::vector<int> dims;
+    decodeDims(prop_it, dims);
+
+    bool isComplex = *prop_it++;
+
+    types::Double* v = new types::Double(static_cast<int>(dims.size()), &dims[0], isComplex);
+    memcpy(v->getReal(), &(*prop_it), v->getSize() * sizeof(double));
+
+    if (isComplex)
+    {
+        prop_it += required_length(prop_it, v);
+        memcpy(v->getImg(), &(*prop_it), v->getSize() * sizeof(double));
+    }
+
+    prop_it += required_length(prop_it, v);
+    return v;
+}
+
+bool encode(std::vector<int>& prop_content, types::Double* v)
+{
+    encodeDims(prop_content, v);
+
+    // Flag for complex
+    prop_content.push_back(v->isComplex());
+
+    const int index = prop_content.size();
+    const int len = required_length(prop_content, v);
+    prop_content.resize(index + len);
+
+    // Using contiguity of the memory, we save the input into 'prop_content'
+    memcpy(&prop_content[index], v->get(), v->getSize() * sizeof(double));
+
+    if (v->isComplex())
+    {
+        prop_content.resize(index + 2 * len);
+        // Using contiguity of the memory, we save the input into 'prop_content'
+        memcpy(&prop_content[index + len], v->getImg(), v->getSize() * sizeof(double));
+    }
+
+    return true;
+}
+
+template<>
+types::String* decode(std::vector<int>::iterator& prop_it)
+{
+    std::vector<int> dims;
+    decodeDims(prop_it, dims);
+
+    types::String* v = new types::String(static_cast<int>(dims.size()), &dims[0]);
+    // retrieving the first value iterator
+    std::vector<int>::iterator strData = prop_it + v->getSize();
+
+    v->set(0, (char*) & (*strData));
+    strData += static_cast<size_t>(*prop_it++);
+    for (int i = 1; i < v->getSize(); i++)
+    {
+        v->set(i, (char*) & (*strData));
+
+        // increment the value iterator by the number of element
+        const size_t numberOfElem = static_cast<size_t>(*prop_it) - static_cast<size_t>(*(prop_it - 1)) ;
+        prop_it++;
+        strData += numberOfElem;
+    }
+
+    prop_it = strData;
+    return v;
+}
+
+bool encode(std::vector<int>& prop_content, types::String* v)
+{
+    encodeDims(prop_content, v);
+
+    const int index = prop_content.size();
+
+    std::vector<char*> utf8;
+    utf8.reserve(v->getSize());
+
+    std::vector<size_t> str_len;
+    str_len.reserve(v->getSize());
+
+    int offset = 0;
+    for (int i = 0; i < v->getSize(); i++)
+    {
+        char* str = wide_string_to_UTF8(v->get(i));
+        utf8.push_back(str);
+
+        // adding the '\0' byte to the len
+        const size_t len = strlen(str) + 1;
+        str_len.push_back(len);
+
+        offset += (len * sizeof(char) + sizeof(int) - 1) / sizeof(int);
+        prop_content.push_back(offset);
+    }
+
+    // reserve space for the string offsets and contents
+    prop_content.resize(index + v->getSize() + offset);
+
+    size_t len = str_len[0];
+    memcpy(&prop_content[index + v->getSize()], &(*utf8[0]), len * sizeof(char));
+    for (int i = 1; i < v->getSize(); i++)
+    {
+        len = str_len[i];
+        memcpy(&prop_content[index + v->getSize() + prop_content[index + i - 1]], &(*utf8[i]), len * sizeof(char));
+    }
+
+    // free all the string, after being copied
+    for (std::vector<char*>::iterator it = utf8.begin(); it != utf8.end(); it++)
+    {
+        FREE(*it);
+    }
+
+    return true;
+}
+
+
+template<>
+types::List* decode(std::vector<int>::iterator& prop_it)
+{
+    int length = *prop_it++;
+
+    types::List* list = new types::List();
+    for (int i = 0; i < length; i++)
+    {
+        switch (*prop_it++)
+        {
+            case types::InternalType::ScilabDouble:
+                list->set(i, decode<types::Double>(prop_it));
+                break;
+            case types::InternalType::ScilabInt8:
+                list->set(i, decode<types::Int8>(prop_it));
+                break;
+            case types::InternalType::ScilabUInt8:
+                list->set(i, decode<types::UInt8>(prop_it));
+                break;
+            case types::InternalType::ScilabInt16:
+                list->set(i, decode<types::Int16>(prop_it));
+                break;
+            case types::InternalType::ScilabUInt16:
+                list->set(i, decode<types::UInt16>(prop_it));
+                break;
+            case types::InternalType::ScilabInt32:
+                list->set(i, decode<types::Int32>(prop_it));
+                break;
+            case types::InternalType::ScilabUInt32:
+                list->set(i, decode<types::UInt32>(prop_it));
+                break;
+            case types::InternalType::ScilabInt64:
+                list->set(i, decode<types::Int64>(prop_it));
+                break;
+            case types::InternalType::ScilabUInt64:
+                list->set(i, decode<types::UInt64>(prop_it));
+                break;
+            case types::InternalType::ScilabString:
+                list->set(i, decode<types::String>(prop_it));
+                break;
+            case types::InternalType::ScilabBool:
+                list->set(i, decode<types::Bool>(prop_it));
+                break;
+            case types::InternalType::ScilabList:
+                list->set(i, decode<types::List>(prop_it));
+                break;
+        }
+    }
+    return list;
+}
+
+bool encode(std::vector<int>& prop_content, types::List* list)
+{
+    // Save the number of list elements in the first element
+    prop_content.push_back(list->getSize());
+
+    for (int i = 0; i < list->getSize(); ++i)
+    {
+        // Insert a new element and save its variable type
+        prop_content.push_back(list->get(i)->getType());
+
+        switch (list->get(i)->getType())
+        {
+            case types::InternalType::ScilabDouble:
+                encode(prop_content, list->get(i)->getAs<types::Double>());
+                break;
+            case types::InternalType::ScilabInt8:
+                encode(prop_content, list->get(i)->getAs<types::Int8>());
+                break;
+            case types::InternalType::ScilabUInt8:
+                encode(prop_content, list->get(i)->getAs<types::UInt8>());
+                break;
+            case types::InternalType::ScilabInt16:
+                encode(prop_content, list->get(i)->getAs<types::Int16>());
+                break;
+            case types::InternalType::ScilabUInt16:
+                encode(prop_content, list->get(i)->getAs<types::UInt16>());
+                break;
+            case types::InternalType::ScilabInt32:
+                encode(prop_content, list->get(i)->getAs<types::Int32>());
+                break;
+            case types::InternalType::ScilabUInt32:
+                encode(prop_content, list->get(i)->getAs<types::UInt32>());
+                break;
+            case types::InternalType::ScilabInt64:
+                encode(prop_content, list->get(i)->getAs<types::Int64>());
+                break;
+            case types::InternalType::ScilabUInt64:
+                encode(prop_content, list->get(i)->getAs<types::UInt64>());
+                break;
+            case types::InternalType::ScilabString:
+                encode(prop_content, list->get(i)->getAs<types::String>());
+                break;
+            case types::InternalType::ScilabBool:
+                encode(prop_content, list->get(i)->getAs<types::Bool>());
+                break;
+            default:
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: List expected.\n"), "model", "props");
+                return false;
+        }
+    }
+
+    return true;
+}
+
+struct odstate
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<double> prop_content;
+        controller.getObjectProperty(adaptee, BLOCK, ODSTATE, prop_content);
+
+        // Corner-case, the empty content is an empty double
+        if (prop_content.empty())
+        {
+            return types::Double::Empty();
+        }
+
+        // The returned value is a list
+        types::InternalType* res;
+        if (!vec2var(prop_content, res))
+        {
+            return 0;
+        }
+
+        return res;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        // corner-case the empty content is an empty-double
+        if (v->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* current = v->getAs<types::Double>();
+            if (current->getSize() != 0)
+            {
+                return false;
+            }
+
+            // prop_content is empty
+            std::vector<double> prop_content;
+            controller.setObjectProperty(adaptee, BLOCK, ODSTATE, prop_content);
+            return true;
+        }
+
+        std::vector<double> prop_content;
+        if (!var2vec(v, prop_content))
+        {
+            return false;
+        }
+
+        controller.setObjectProperty(adaptee, BLOCK, ODSTATE, prop_content);
+        return true;
+    }
+};
+
+/*
+ * When setting a diagram in 'rpar', the Superblock's ports must be consistent with the "port blocks" inside it.
+ * By "port blocks", we mean IN_f, OUT_f, CLKIN_f, CLKOUT_f, CLKINV_f, CLKOUTV_f, INIMPL_f and OUTIMPL_f.
+ */
+bool setInnerBlocksRefs(ModelAdapter& adaptor, const std::vector<ScicosID>& children, Controller& controller)
+{
+    const std::string input ("input");
+    const std::string output ("output");
+    const std::string inimpl ("inimpl");
+    const std::string outimpl ("outimpl");
+
+    ScicosID adaptee = adaptor.getAdaptee()->id();
+
+    for (std::vector<ScicosID>::const_iterator it = children.begin(); it != children.end(); ++it)
+    {
+        if (*it == ScicosID())
+        {
+            continue; // Rule out mlists (Deleted or Annotations)
+        }
+
+        if (controller.getObject(*it)->kind() == BLOCK) // Rule out Annotations and Links
+        {
+            std::string name;
+            controller.getObjectProperty(*it, BLOCK, SIM_FUNCTION_NAME, name);
+
+            // Find the "port blocks"
+            if (name == input || name == inimpl || name == output || name == outimpl)
+            {
+                std::vector<int> ipar;
+                controller.getObjectProperty(*it, BLOCK, IPAR, ipar);
+                if (ipar.size() != 1)
+                {
+                    std::string uid;
+                    controller.getObjectProperty(*it, BLOCK, UID, uid);
+                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid port number.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                    return false;
+                }
+                int portIndex = ipar[0];
+
+                // "name" is not enough to tell the event and data ports apart, so check the block's port.
+                object_properties_t kind;
+                std::vector<ScicosID> innerPort;
+                if (name == input || name == inimpl)
+                {
+                    controller.getObjectProperty(*it, BLOCK, OUTPUTS, innerPort);
+                    if (!innerPort.empty())
+                    {
+                        kind = INPUTS;
+                    }
+                    else
+                    {
+                        kind = EVENT_INPUTS;
+                    }
+                }
+                else
+                {
+                    controller.getObjectProperty(*it, BLOCK, INPUTS, innerPort);
+                    if (!innerPort.empty())
+                    {
+                        kind = OUTPUTS;
+                    }
+                    else
+                    {
+                        kind = EVENT_OUTPUTS;
+                    }
+                }
+
+                std::vector<ScicosID> superPorts;
+                controller.getObjectProperty(adaptee, BLOCK, kind, superPorts);
+                if (static_cast<int>(superPorts.size()) < portIndex)
+                {
+                    if (!superPorts.empty())
+                    {
+                        // Arbitrarily take the highest possible value in case the user enters a wrong number
+                        portIndex = superPorts.size();
+                    }
+                    else
+                    {
+                        std::string uid;
+                        controller.getObjectProperty(*it, BLOCK, UID, uid);
+                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid port number.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                        return false;
+                    }
+                }
+
+                ScicosID port = superPorts[portIndex - 1];
+
+                // Check consistency of the implicitness between the inner and outer ports
+                bool isImplicit;
+                controller.getObjectProperty(port, PORT, IMPLICIT, isImplicit);
+                if (name == input || name == output)
+                {
+                    if (isImplicit)
+                    {
+                        std::string uid;
+                        controller.getObjectProperty(*it, BLOCK, UID, uid);
+                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid implicit port.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                        return false;
+                    }
+                }
+                else
+                {
+                    if (!isImplicit)
+                    {
+                        std::string uid;
+                        controller.getObjectProperty(*it, BLOCK, UID, uid);
+                        get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: %s (%s) has an invalid explicit port.\n"), "model", "rpar", name.c_str(), uid.c_str());
+                        return false;
+                    }
+                }
+
+                controller.setObjectProperty(*it, BLOCK, PORT_REFERENCE, port);
+            }
+        }
+    }
+    return true;
+}
+
+struct rpar
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<ScicosID> diagramChildren;
+        controller.getObjectProperty(adaptee, BLOCK, CHILDREN, diagramChildren);
+
+        if (diagramChildren.empty())
+        {
+            std::vector<double> rpar;
+            controller.getObjectProperty(adaptee, BLOCK, RPAR, rpar);
+
+            double *data;
+            types::Double* o = new types::Double((int)rpar.size(), 1, &data);
+#ifdef _MSC_VER
+            std::copy(rpar.begin(), rpar.end(), stdext::checked_array_iterator<double*>(data, rpar.size()));
+#else
+            std::copy(rpar.begin(), rpar.end(), data);
+#endif
+            return o;
+        }
+        else // SuperBlock, return the contained diagram (allocating it on demand)
+        {
+            DiagramAdapter* diagram = adaptor.getDiagram();
+
+            /*
+             * FIXME: Sync all diagram children as the blocks might be modified by xcos
+             */
+
+            return diagram;
+        }
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* current = v->getAs<types::Double>();
+
+            std::vector<double> rpar (current->getSize());
+            for (int i = 0; i < current->getSize(); ++i)
+            {
+                rpar[i] = current->get(i);
+            }
+
+            controller.setObjectProperty(adaptee, BLOCK, RPAR, rpar);
+            return true;
+        }
+        else if (v->getType() == types::InternalType::ScilabString)
+        {
+            // Allow Text blocks to define strings in rpar
+            return true;
+        }
+        else if (v->getType() == types::InternalType::ScilabUserType)
+        {
+            // Make sure the input describes a Diagram
+            const Adapters::adapters_index_t adapter_index = Adapters::instance().lookup_by_typename(v->getShortTypeStr());
+            if (adapter_index != Adapters::DIAGRAM_ADAPTER)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Diagram expected.\n"), "model", "rpar");
+                return false;
+            }
+
+            // Translate 'v' to an DiagramAdapter
+            DiagramAdapter* diagram = v->getAs<DiagramAdapter>();
+
+            adaptor.setDiagram(diagram);
+
+            // Set the diagram children as block children
+            std::vector<ScicosID> diagramChildren;
+            controller.getObjectProperty(diagram->getAdaptee()->id(), DIAGRAM, CHILDREN, diagramChildren);
+            if (diagramChildren.empty())
+            {
+                // bug_12998: If inserting an empty diagram in 'rpar', simulate an empty object
+                diagramChildren.push_back(ScicosID());
+            }
+            std::vector<ScicosID> oldDiagramChildren;
+            controller.getObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, oldDiagramChildren);
+
+            std::sort(oldDiagramChildren.begin(), oldDiagramChildren.end());
+            std::vector<ScicosID> clonedChildren;
+            std::vector<ScicosID> clonedLinks;
+            for (const ScicosID & id : diagramChildren)
+            {
+                if (id != 0 && !std::binary_search(oldDiagramChildren.begin(), oldDiagramChildren.end(), id))
+                {
+                    ScicosID cloneID = controller.cloneObject(id, true);
+                    auto o = controller.getObject(cloneID);
+                    controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, adaptor.getAdaptee()->id());
+
+                    clonedChildren.push_back(cloneID);
+                    if (o->kind() == LINK)
+                    {
+                        clonedLinks.push_back(cloneID);
+                    }
+                }
+            }
+            controller.setObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, clonedChildren);
+
+            std::sort(diagramChildren.begin(), diagramChildren.end());
+            for (const ScicosID & id : oldDiagramChildren)
+            {
+                if (id != 0 && !std::binary_search(diagramChildren.begin(), diagramChildren.end(), id))
+                {
+                    auto o = controller.getObject(id);
+                    controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, ScicosID());
+
+                    controller.deleteObject(id);
+                }
+            }
+
+            // After cloning the diagram elements, re-sync the link information
+            for (int i = 0; i < static_cast<int>(clonedLinks.size()); ++i)
+            {
+                auto o = controller.getObject(clonedLinks[i]);
+                LinkAdapter* newLink = new LinkAdapter(controller, static_cast<model::Link*>(o));
+                newLink->setFromInModel(diagram->getFrom()[i], controller);
+                newLink->setToInModel(diagram->getTo()[i], controller);
+            }
+
+            // Save the context
+            std::vector<std::string> context;
+            controller.getObjectProperty(diagram->getAdaptee()->id(), DIAGRAM, DIAGRAM_CONTEXT, context);
+            controller.setObjectProperty(adaptor.getAdaptee()->id(), BLOCK, DIAGRAM_CONTEXT, context);
+
+            // Link the Superblock ports to their inner "port blocks"
+            return setInnerBlocksRefs(adaptor, diagramChildren, controller);
+        }
+        else if (v->getType() == types::InternalType::ScilabMList)
+        {
+            ScicosID localAdaptee = controller.createObject(DIAGRAM);
+            DiagramAdapter* diagram = new DiagramAdapter(controller, controller.getObject<model::Diagram>(localAdaptee));
+            if (!diagram->setAsTList(v, controller))
+            {
+                diagram->killMe();
+                return false;
+            }
+
+            adaptor.setDiagram(diagram);
+
+            // set the diagram children as block children ; referencing them
+            std::vector<ScicosID> diagramChildren;
+            controller.getObjectProperty(diagram->getAdaptee()->id(), DIAGRAM, CHILDREN, diagramChildren);
+            if (diagramChildren.empty())
+            {
+                // bug_12998: If inserting an empty diagram in 'rpar', simulate an empty object
+                diagramChildren.push_back(ScicosID());
+            }
+            std::vector<ScicosID> oldDiagramChildren;
+            controller.getObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, oldDiagramChildren);
+
+            controller.setObjectProperty(adaptor.getAdaptee()->id(), BLOCK, CHILDREN, diagramChildren);
+            {
+                std::sort(oldDiagramChildren.begin(), oldDiagramChildren.end());
+                for (const ScicosID id : diagramChildren)
+                {
+                    if (id != 0 && !std::binary_search(oldDiagramChildren.begin(), oldDiagramChildren.end(), id))
+                    {
+                        auto o = controller.getObject(id);
+                        controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, adaptor.getAdaptee()->id());
+
+                        controller.referenceObject(id);
+                    }
+                }
+
+                std::sort(diagramChildren.begin(), diagramChildren.end());
+                for (const ScicosID id : oldDiagramChildren)
+                {
+                    if (id != 0 && !std::binary_search(diagramChildren.begin(), diagramChildren.end(), id))
+                    {
+                        auto o = controller.getObject(id);
+                        controller.setObjectProperty(o->id(), o->kind(), PARENT_BLOCK, ScicosID());
+
+                        controller.deleteObject(id);
+                    }
+                }
+            }
+
+            // Link the Superblock ports to their inner "port blocks"
+            return setInnerBlocksRefs(adaptor, diagramChildren, controller);
+        }
+        else
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "rpar");
+            return false;
+        }
+    }
+};
+
+double toDouble(const int a)
+{
+    return static_cast<double>(a);
+}
+
+struct ipar
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<int> ipar;
+        controller.getObjectProperty(adaptee, BLOCK, IPAR, ipar);
+
+        double *data;
+        types::Double* o = new types::Double((int)ipar.size(), 1, &data);
+
+#ifdef _MSC_VER
+        std::transform(ipar.begin(), ipar.end(), stdext::checked_array_iterator<double*>(data, ipar.size()), toDouble);
+#else
+        std::transform(ipar.begin(), ipar.end(), data, toDouble);
+#endif
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() == types::InternalType::ScilabList)
+        {
+            std::vector<int> ipar;
+            controller.setObjectProperty(adaptee, BLOCK, IPAR, ipar);
+            get_or_allocate_logger()->log(LOG_TRACE, _("Wrong type for field %s.%s: List clear previous value.\n"), "model", "ipar");
+            return true;
+        }
+
+        // FIXME: ScilabInts should be managed there
+        if (v->getType() != types::InternalType::ScilabDouble)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "ipar");
+            return false;
+        }
+        types::Double* current = v->getAs<types::Double>();
+        // Only allow vectors and empty matrices
+        if (!current->isVector() && current->getSize() != 0)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 matrix expected.\n"), "model", "ipar");
+            return false;
+        }
+
+        std::vector<int> ipar (current->getSize());
+        for (int i = 0; i < current->getSize(); ++i)
+        {
+            if (floor(current->get(i)) != current->get(i))
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Integer values expected.\n"), "model", "ipar");
+                return false;
+            }
+            ipar[i] = static_cast<int>(current->get(i));
+        }
+
+        controller.setObjectProperty(adaptee, BLOCK, IPAR, ipar);
+        return true;
+    }
+};
+
+struct opar
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<double> prop_content;
+        controller.getObjectProperty(adaptee, BLOCK, OPAR, prop_content);
+
+        // Corner-case, the empty content is an empty double
+        if (prop_content.empty())
+        {
+            return types::Double::Empty();
+        }
+
+        // The returned value is a list
+        types::InternalType* res;
+        if (!vec2var(prop_content, res))
+        {
+            return 0;
+        }
+
+        return res;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        // corner-case the empty content is an empty-double
+        if (v->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* current = v->getAs<types::Double>();
+            if (current->getSize() != 0)
+            {
+                return false;
+            }
+
+            // prop_content should be empty
+            std::vector<double> prop_content;
+            controller.setObjectProperty(adaptee, BLOCK, OPAR, prop_content);
+            return true;
+        }
+
+        std::vector<double> prop_content;
+        if (!var2vec(v, prop_content))
+        {
+            return false;
+        }
+
+        controller.setObjectProperty(adaptee, BLOCK, OPAR, prop_content);
+        return true;
+    }
+};
+
+struct blocktype
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::string type;
+        controller.getObjectProperty(adaptee, BLOCK, SIM_BLOCKTYPE, type);
+
+        types::String* o = new types::String(type.c_str());
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() != types::InternalType::ScilabString)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: String expected.\n"), "model", "blocktype");
+            return false;
+        }
+
+        types::String* current = v->getAs<types::String>();
+        if (current->getSize() != 1)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: String expected.\n"), "model", "blocktype");
+            return false;
+        }
+
+        char* c_str = wide_string_to_UTF8(current->get(0));
+        std::string type (c_str);
+        FREE(c_str);
+
+        // the value validation is performed on the model
+        return controller.setObjectProperty(adaptee, BLOCK, SIM_BLOCKTYPE, type) != FAIL;
+    }
+};
+
+struct firing
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        return get_ports_property<ModelAdapter, FIRING>(adaptor, EVENT_OUTPUTS, controller);
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        return set_ports_property<ModelAdapter, FIRING>(adaptor, EVENT_OUTPUTS, controller, v);
+    }
+};
+
+struct dep_ut
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<int> dep_ut;
+        controller.getObjectProperty(adaptee, BLOCK, SIM_DEP_UT, dep_ut);
+
+        int* dep;
+        types::Bool* o = new types::Bool(1, 2, &dep);
+
+        dep[0] = dep_ut[0];
+        dep[1] = dep_ut[1];
+
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() != types::InternalType::ScilabBool)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Boolean matrix expected.\n"), "model", "dep_ut");
+            return false;
+        }
+
+        types::Bool* current = v->getAs<types::Bool>();
+        if (current->getSize() != 2)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: %d-by-%d expected.\n"), "model", "dep_ut", 1, 2);
+            return false;
+        }
+
+        std::vector<int> dep_ut (2);
+        dep_ut[0] = current->get(0);
+        dep_ut[1] = current->get(1);
+
+        controller.setObjectProperty(adaptee, BLOCK, SIM_DEP_UT, dep_ut);
+        return true;
+    }
+};
+
+struct label
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::string label;
+        controller.getObjectProperty(adaptee, BLOCK, LABEL, label);
+
+        types::String* o = new types::String(1, 1);
+        o->set(0, label.data());
+
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        if (v->getType() != types::InternalType::ScilabString)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: String expected.\n"), "model", "label");
+            return false;
+        }
+
+        types::String* current = v->getAs<types::String>();
+        if (current->getSize() != 1)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: String expected.\n"), "model", "label");
+            return false;
+        }
+
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        char* c_str = wide_string_to_UTF8(current->get(0));
+        std::string label(c_str);
+        FREE(c_str);
+
+        controller.setObjectProperty(adaptee, BLOCK, LABEL, label);
+        return true;
+    }
+};
+
+struct nzcross
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<int> nzcross;
+        controller.getObjectProperty(adaptee, BLOCK, NZCROSS, nzcross);
+
+        double *data;
+        types::Double* o = new types::Double((int)nzcross.size(), 1, &data);
+
+#ifdef _MSC_VER
+        std::transform(nzcross.begin(), nzcross.end(), stdext::checked_array_iterator<double*>(data, nzcross.size()), toDouble);
+#else
+        std::transform(nzcross.begin(), nzcross.end(), data, toDouble);
+#endif
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() != types::InternalType::ScilabDouble)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "nzcross");
+            return false;
+        }
+
+        types::Double* current = v->getAs<types::Double>();
+        // Only allow vectors and empty matrices
+        if (!current->isVector() && current->getSize() != 0)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 expected.\n"), "model", "nzcross");
+            return false;
+        }
+
+        std::vector<int> nzcross (current->getSize());
+        for (int i = 0; i < current->getSize(); ++i)
+        {
+            if (floor(current->get(i)) != current->get(i))
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Integer values expected.\n"), "model", "nzcross");
+                return false;
+            }
+            nzcross[i] = static_cast<int>(current->get(i));
+        }
+
+        controller.setObjectProperty(adaptee, BLOCK, NZCROSS, nzcross);
+        return true;
+    }
+};
+
+struct nmode
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<int> nmode;
+        controller.getObjectProperty(adaptee, BLOCK, NMODE, nmode);
+
+        double *data;
+        types::Double* o = new types::Double((int)nmode.size(), 1, &data);
+
+#ifdef _MSC_VER
+        std::transform(nmode.begin(), nmode.end(), stdext::checked_array_iterator<double*>(data, nmode.size()), toDouble);
+#else
+        std::transform(nmode.begin(), nmode.end(), data, toDouble);
+#endif
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() != types::InternalType::ScilabDouble)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Real matrix expected.\n"), "model", "nmode");
+            return false;
+        }
+
+        types::Double* current = v->getAs<types::Double>();
+        // Only allow vectors and empty matrices
+        if (!current->isVector() && current->getSize() != 0)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: m-by-1 expected.\n"), "model", "nzcross");
+            return false;
+        }
+
+        std::vector<int> nmode (current->getSize());
+        for (int i = 0; i < current->getSize(); ++i)
+        {
+            if (floor(current->get(i)) != current->get(i))
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong value for field %s.%s: Integer values expected.\n"), "model", "nzcross");
+                return false;
+            }
+            nmode[i] = static_cast<int>(current->get(i));
+        }
+
+        controller.setObjectProperty(adaptee, BLOCK, NMODE, nmode);
+        return true;
+    }
+};
+
+struct equations
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::vector<std::string> equations;
+        controller.getObjectProperty(adaptee, BLOCK, EQUATIONS, equations);
+
+        if (equations.size() == 0)
+        {
+            return new types::List();
+        }
+
+        types::TList* o = new types::TList();
+
+        // Header, starting with "modelica"
+        types::String* header = new types::String(1, 5);
+        header->set(0, modelica.c_str());
+        header->set(1, model.c_str());
+        header->set(2, inputs.c_str());
+        header->set(3, outputs.c_str());
+        header->set(4, parameters.c_str());
+        o->set(0, header);
+
+        // 'model'
+        if (equations[0].c_str() == std::string())
+        {
+            o->set(1, types::Double::Empty());
+        }
+        else
+        {
+            types::String* modelField = new types::String(1, 1);
+            modelField->set(0, equations[0].c_str());
+            o->set(1, modelField);
+        }
+
+        // 'inputs'
+        std::istringstream inputsSizeStr (equations[1]);
+        int inputsSize;
+        inputsSizeStr >> inputsSize;
+        if (inputsSize <= 0 || inputsSize > int(equations.size() - 2))
+        {
+            types::Double* inputsField = types::Double::Empty();
+            o->set(2, inputsField);
+
+            // fall back to a safe value for future indexing
+            inputsSize = 0;
+        }
+        else
+        {
+            types::String* inputsField = new types::String(inputsSize, 1);
+            for (int i = 0; i < inputsSize; ++i)
+            {
+                inputsField->set(i, equations[i + 2].c_str());
+            }
+            o->set(2, inputsField);
+        }
+
+        // 'outputs'
+        std::istringstream outputsSizeStr (equations[2 + inputsSize]);
+        int outputsSize;
+        outputsSizeStr >> outputsSize;
+        if (outputsSize <= 0 || outputsSize > int(equations.size() - 3 - inputsSize))
+        {
+            types::Double* outputsField = types::Double::Empty();
+            o->set(3, outputsField);
+
+            // fall back to a safe value for future indexing
+            outputsSize = 0;
+        }
+        else
+        {
+            types::String* outputsField = new types::String(outputsSize, 1);
+            for (int i = 0; i < outputsSize; ++i)
+            {
+                outputsField->set(i, equations[i + 3 + inputsSize].c_str());
+            }
+            o->set(3, outputsField);
+        }
+
+        // 'parameters'
+        types::List* parametersField = new types::List();
+
+        // 'parameters' names
+        std::istringstream parametersSizeStr (equations[3 + inputsSize + outputsSize]);
+        int parametersSize;
+        parametersSizeStr >> parametersSize;
+        if (parametersSize <= 0 || parametersSize > int(equations.size() - 4 - inputsSize - outputsSize))
+        {
+            types::Double* parametersNames = types::Double::Empty();
+            parametersField->set(0, parametersNames);
+
+            // fall back to a safe value for future indexing
+            parametersSize = 0;
+        }
+        else
+        {
+            types::String* parametersNames = new types::String(parametersSize, 1);
+            for (int i = 0; i < parametersSize; ++i)
+            {
+                parametersNames->set(i, equations[i + 4 + inputsSize + outputsSize].c_str());
+            }
+            parametersField->set(0, parametersNames);
+        }
+
+        // 'parameters' values
+        types::List* parametersValues = new types::List();
+        for (int i = 0; i < parametersSize; ++i)
+        {
+            std::istringstream parametersValueStr (equations[i + 4 + inputsSize + outputsSize + parametersSize]);
+            double parametersVal;
+            parametersValueStr >> parametersVal;
+            types::Double* parametersValue = new types::Double(parametersVal);
+            parametersValues->set(i, parametersValue);
+        }
+        parametersField->set(1, parametersValues);
+        parametersValues->killMe();
+
+        // 'parameters' states (optional, only check its presence if at least one parameter is present)
+        if (parametersSize != 0)
+        {
+            std::string parametersStatesBool (equations[4 + inputsSize + outputsSize + 2 * parametersSize]);
+            if (strcmp(parametersStatesBool.c_str(), "T") == 0) // Check the presence of the "states" field
+            {
+                types::Double* parametersStates = new types::Double(parametersSize, 1);
+                for (int i = 0; i < parametersSize; ++i)
+                {
+                    std::istringstream parametersStateStr (equations[i + 5 + inputsSize + outputsSize + 2 * parametersSize]);
+                    double parametersState;
+                    parametersStateStr >> parametersState;
+                    parametersStates->set(i, parametersState);
+                }
+                parametersField->set(2, parametersStates);
+            }
+        }
+
+        o->set(4, parametersField);
+        parametersField->killMe();
+
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        if (v->getType() == types::InternalType::ScilabList)
+        {
+            types::List* current = v->getAs<types::List>();
+            if (current->getSize() != 0)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+            return true;
+        }
+
+        if (v->getType() != types::InternalType::ScilabTList)
+        {
+            return false;
+        }
+
+        types::TList* current = v->getAs<types::TList>();
+
+        // Check the header
+        types::String* header = current->getFieldNames();
+        if (header->getSize() != 5)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+        if (header->get(0) != modelica)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+        if (header->get(1) != model)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+        if (header->get(2) != inputs)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+        if (header->get(3) != outputs)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+        if (header->get(4) != parameters)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+
+        char* c_str; // Temporary buffer used for conversions
+
+        // 'model'
+        std::vector<std::string> equations;
+        if (current->get(1)->getType() == types::InternalType::ScilabString)
+        {
+            types::String* modelField = current->get(1)->getAs<types::String>();
+            if (modelField->getSize() != 1)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            c_str = wide_string_to_UTF8(modelField->get(0));
+            std::string modelFieldStored(c_str);
+            FREE(c_str);
+            equations.push_back(modelFieldStored);
+        }
+        else if (current->get(1)->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* modelFieldDouble = current->get(1)->getAs<types::Double>();
+            if (modelFieldDouble->getSize() != 0)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            // An empty matrix stores an empty string, which will later be translated back to an empty matrix
+            equations.push_back(std::string());
+        }
+        else
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+
+        // 'inputs'
+        size_t inputsSize;
+        if (current->get(2)->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* inputsField = current->get(2)->getAs<types::Double>();
+            if (inputsField->getSize() != 0)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            inputsSize = 0;
+            std::ostringstream strInputs;
+            strInputs << inputsSize;
+            std::string inputsSizeStr = strInputs.str();
+            equations.push_back(inputsSizeStr); // When 'inputs'=[], just insert "0" in 'equations'
+        }
+        else
+        {
+            if (current->get(2)->getType() != types::InternalType::ScilabString)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            types::String* inputsField = current->get(2)->getAs<types::String>();
+            inputsSize = inputsField->getSize();
+            equations.resize(equations.size() + 1 + inputsSize);
+            std::ostringstream strInputs;
+            strInputs << inputsSize;
+            std::string inputsSizeStr = strInputs.str();
+            equations[1] = inputsSizeStr; // Saving the size of the 'inputs' field'
+            for (size_t i = 0; i < inputsSize; ++i)
+            {
+                c_str = wide_string_to_UTF8(inputsField->get(static_cast<int>(i)));
+                std::string inputsFieldStored(c_str);
+                FREE(c_str);
+                equations[i + 2] = inputsFieldStored;
+            }
+        }
+
+        // 'outputs'
+        size_t outputsSize;
+        if (current->get(3)->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* outputsField = current->get(3)->getAs<types::Double>();
+            if (outputsField->getSize() != 0)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            outputsSize = 0;
+            std::ostringstream strOutputs;
+            strOutputs << outputsSize;
+            std::string outputsSizeStr = strOutputs.str();
+            equations.push_back(outputsSizeStr); // When 'outputs'=[], just insert "0" in 'equations'
+        }
+        else
+        {
+            if (current->get(3)->getType() != types::InternalType::ScilabString)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            types::String* outputsField = current->get(3)->getAs<types::String>();
+            outputsSize = outputsField->getSize();
+            equations.resize(equations.size() + 1 + outputsSize);
+            std::ostringstream strOutputs;
+            strOutputs << outputsSize;
+            std::string outputsSizeStr = strOutputs.str();
+            equations[2 + inputsSize] = outputsSizeStr; // Saving the size of the 'outputs' field'
+            for (size_t i = 0; i < outputsSize; ++i)
+            {
+                c_str = wide_string_to_UTF8(outputsField->get(static_cast<int>(i)));
+                std::string outputsFieldStored(c_str);
+                FREE(c_str);
+                equations[i + 3 + inputsSize] = outputsFieldStored;
+            }
+        }
+
+        // 'parameters'
+        int parametersIndex = 4;
+        if (current->get(parametersIndex)->getType() == types::InternalType::ScilabDouble)
+        {
+            // For backward compatibility sake, allow the presence of an empty matrix here
+            types::Double* emptyMatrix = current->get(parametersIndex)->getAs<types::Double>();
+            if (emptyMatrix->getSize() != 0)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            parametersIndex++;
+        }
+
+        if (current->get(parametersIndex)->getType() != types::InternalType::ScilabList)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+
+        types::List* list = current->get(parametersIndex)->getAs<types::List>();
+        if (list->getSize() != 2 && list->getSize() != 3)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+            return false;
+        }
+
+        // 'parameters' names
+        size_t parametersSize;
+        if (list->get(0)->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* parametersNames = list->get(0)->getAs<types::Double>();
+            if (parametersNames->getSize() != 0)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            // When 'parameters(1)'=[], just insert "0" in 'equations', set in the model and return
+            parametersSize = 0;
+            std::ostringstream strParameters;
+            strParameters << parametersSize;
+            std::string parametersSizeStr = strParameters.str();
+            equations.push_back(parametersSizeStr);
+
+            controller.setObjectProperty(adaptee, BLOCK, EQUATIONS, equations);
+            return true;
+        }
+        else
+        {
+            if (list->get(0)->getType() != types::InternalType::ScilabString)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            types::String* parametersNames = list->get(0)->getAs<types::String>();
+            parametersSize = parametersNames->getSize();
+            equations.resize(equations.size() + 1 + parametersSize);
+            std::ostringstream strParameters;
+            strParameters << parametersSize;
+            std::string parametersSizeStr = strParameters.str();
+            equations[3 + inputsSize + outputsSize] = parametersSizeStr; // Saving the size of the 'parameters' field'
+            for (size_t i = 0; i < parametersSize; ++i)
+            {
+                c_str = wide_string_to_UTF8(parametersNames->get(static_cast<int>(i)));
+                std::string parametersName(c_str);
+                FREE(c_str);
+                equations[i + 4 + inputsSize + outputsSize] = parametersName;
+            }
+        }
+
+        // 'parameters' values
+        if (list->get(1)->getType() == types::InternalType::ScilabDouble)
+        {
+            types::Double* parameterVal = list->get(1)->getAs<types::Double>();
+            if (parameterVal->getSize() != static_cast<int>(parametersSize))
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            for (size_t i = 0; i < parametersSize; ++i)
+            {
+                std::ostringstream strParameterVal;
+                strParameterVal << parameterVal->get(static_cast<int>(i));
+                std::string parameterValStr = strParameterVal.str();
+                equations.push_back(parameterValStr);
+            }
+        }
+        else
+        {
+            if (list->get(1)->getType() != types::InternalType::ScilabList)
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            types::List* list2 = list->get(1)->getAs<types::List>();
+            if (list2->getSize() != static_cast<int>(parametersSize))
+            {
+                get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                return false;
+            }
+
+            equations.resize(equations.size() + parametersSize);
+            for (size_t i = 0; i < parametersSize; ++i)
+            {
+                if (list2->get(static_cast<int>(i))->getType() != types::InternalType::ScilabDouble)
+                {
+                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                    return false;
+                }
+
+                types::Double* parametersVal = list2->get(static_cast<int>(i))->getAs<types::Double>();
+                if (parametersVal->getSize() != 1)
+                {
+                    get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: Equation expected.\n"), "model", "equations");
+                    return false;
+                }
+
+                std::ostringstream strParametersVal;
+                strParametersVal << parametersVal->get(0);
+                std::string parametersValStr = strParametersVal.str();
+                equations[i + 4 + inputsSize + outputsSize + parametersSize] = parametersValStr;
+            }
+        }
+
+        // 'parameters' states (optional)
+        equations.push_back("F"); // String boolean to indicate the presence, or not, of a "states" field
+        if (list->getSize() == 3)
+        {
+            equations.back() = "T";
+            if (list->get(2)->getType() != types::InternalType::ScilabDouble)
+            {
+                return false;
+            }
+
+            types::Double* parameterStates = list->get(2)->getAs<types::Double>();
+            if (parameterStates->getSize() != static_cast<int>(parametersSize))
+            {
+                return false;
+            }
+
+            for (size_t i = 0; i < parametersSize; ++i)
+            {
+                std::ostringstream strParameterStates;
+                strParameterStates << parameterStates->get(static_cast<int>(i));
+                std::string parameterStatesStr = strParameterStates.str();
+                equations.push_back(parameterStatesStr);
+            }
+        }
+
+        controller.setObjectProperty(adaptee, BLOCK, EQUATIONS, equations);
+        return true;
+    }
+};
+
+struct uid
+{
+
+    static types::InternalType* get(const ModelAdapter& adaptor, const Controller& controller)
+    {
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        std::string uid;
+        controller.getObjectProperty(adaptee, BLOCK, UID, uid);
+
+        types::String* o = new types::String(1, 1);
+        o->set(0, uid.data());
+
+        return o;
+    }
+
+    static bool set(ModelAdapter& adaptor, types::InternalType* v, Controller& controller)
+    {
+        if (v->getType() != types::InternalType::ScilabString)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong type for field %s.%s: String expected.\n"), "model", "uid");
+            return false;
+        }
+
+        types::String* current = v->getAs<types::String>();
+        if (current->getSize() != 1)
+        {
+            get_or_allocate_logger()->log(LOG_ERROR, _("Wrong dimension for field %s.%s: String expected.\n"), "model", "uid");
+            return false;
+        }
+
+        ScicosID adaptee = adaptor.getAdaptee()->id();
+
+        char* c_str = wide_string_to_UTF8(current->get(0));
+        std::string uid(c_str);
+        FREE(c_str);
+
+        controller.setObjectProperty(adaptee, BLOCK, UID, uid);
+        return true;
+    }
+};
+
+} /* namespace */
+
+template<> property<ModelAdapter>::props_t property<ModelAdapter>::fields = property<ModelAdapter>::props_t();
+static void initialize_fields()
+{
+    if (property<ModelAdapter>::properties_have_not_been_set())
+    {
+        property<ModelAdapter>::fields.reserve(23);
+        property<ModelAdapter>::add_property(L"sim", &sim::get, &sim::set);
+        property<ModelAdapter>::add_property(L"in", &in::get, &in::set);
+        property<ModelAdapter>::add_property(L"in2", &in2::get, &in2::set);
+        property<ModelAdapter>::add_property(L"intyp", &intyp::get, &intyp::set);
+        property<ModelAdapter>::add_property(L"out", &out::get, &out::set);
+        property<ModelAdapter>::add_property(L"out2", &out2::get, &out2::set);
+        property<ModelAdapter>::add_property(L"outtyp", &outtyp::get, &outtyp::set);
+        property<ModelAdapter>::add_property(L"evtin", &evtin::get, &evtin::set);
+        property<ModelAdapter>::add_property(L"evtout", &evtout::get, &evtout::set);
+        property<ModelAdapter>::add_property(L"state", &state::get, &state::set);
+        property<ModelAdapter>::add_property(L"dstate", &dstate::get, &dstate::set);
+        property<ModelAdapter>::add_property(L"odstate", &odstate::get, &odstate::set);
+        property<ModelAdapter>::add_property(L"rpar", &rpar::get, &rpar::set);
+        property<ModelAdapter>::add_property(L"ipar", &ipar::get, &ipar::set);
+        property<ModelAdapter>::add_property(L"opar", &opar::get, &opar::set);
+        property<ModelAdapter>::add_property(L"blocktype", &blocktype::get, &blocktype::set);
+        property<ModelAdapter>::add_property(L"firing", &firing::get, &firing::set);
+        property<ModelAdapter>::add_property(L"dep_ut", &dep_ut::get, &dep_ut::set);
+        property<ModelAdapter>::add_property(L"label", &label::get, &label::set);
+        property<ModelAdapter>::add_property(L"nzcross", &nzcross::get, &nzcross::set);
+        property<ModelAdapter>::add_property(L"nmode", &nmode::get, &nmode::set);
+        property<ModelAdapter>::add_property(L"equations", &equations::get, &equations::set);
+        property<ModelAdapter>::add_property(L"uid", &uid::get, &uid::set);
+    }
+}
+
+ModelAdapter::ModelAdapter() :
+    BaseAdapter<ModelAdapter, org_scilab_modules_scicos::model::Block>(),
+    m_diagramAdapter(nullptr)
+{
+    initialize_fields();
+}
+ModelAdapter::ModelAdapter(const Controller& c, model::Block* adaptee, DiagramAdapter* diagramAdapter) :
+    BaseAdapter<ModelAdapter, org_scilab_modules_scicos::model::Block>(c, adaptee),
+    m_diagramAdapter(diagramAdapter)
+{
+    initialize_fields();
+}
+
+ModelAdapter::~ModelAdapter()
+{
+}
+
+std::wstring ModelAdapter::getTypeStr()
+{
+    return getSharedTypeStr();
+}
+
+std::wstring ModelAdapter::getShortTypeStr()
+{
+    return getSharedTypeStr();
+}
+
+DiagramAdapter* ModelAdapter::getDiagram() const
+{
+    return m_diagramAdapter;
+}
+
+void ModelAdapter::setDiagram(DiagramAdapter* diagramAdapter)
+{
+    // Does not increment reference as this adapter does not own the DiagramAdapter
+    m_diagramAdapter = diagramAdapter;
+}
+
+} /* namespace view_scilab */
+} /* namespace org_scilab_modules_scicos */
index 4abb122..281a91a 100644 (file)
@@ -223,13 +223,24 @@ types::InternalType* get_ports_property(const Adaptor& adaptor, const object_pro
             double* v;
             types::Double* o = new types::Double((int)ids.size(), 1, &v);
 
-            ScicosID diagram;
-            controller.getObjectProperty(adaptee, BLOCK, PARENT_DIAGRAM, diagram);
+            ScicosID parentDiagram;
+            controller.getObjectProperty(adaptee, BLOCK, PARENT_DIAGRAM, parentDiagram);
 
             std::vector<ScicosID> children;
-            if (diagram != 0)
+            if (parentDiagram != 0)
             {
-                controller.getObjectProperty(diagram, DIAGRAM, CHILDREN, children);
+                // Adding to a diagram
+                controller.getObjectProperty(parentDiagram, DIAGRAM, CHILDREN, children);
+            }
+            else
+            {
+                ScicosID parentBlock;
+                controller.getObjectProperty(adaptee, BLOCK, PARENT_BLOCK, parentBlock);
+                if (parentBlock != 0)
+                {
+                    // Adding to a superblock
+                    controller.getObjectProperty(parentBlock, BLOCK, CHILDREN, children);
+                }
             }
 
             for (std::vector<ScicosID>::iterator it = ids.begin(); it != ids.end(); ++it, ++i)
@@ -646,10 +657,12 @@ bool update_ports_property(const Adaptor& adaptor, const object_properties_t por
     std::vector<ScicosID> children;
     if (parentBlock != 0)
     {
+        // Adding to a superblock
         controller.getObjectProperty(parentBlock, BLOCK, CHILDREN, children);
     }
     if (parentDiagram != 0 && children.empty())
     {
+        // Adding to a diagram
         controller.getObjectProperty(parentDiagram, DIAGRAM, CHILDREN, children);
     }
 
@@ -773,6 +786,14 @@ bool update_ports_property(const Adaptor& adaptor, const object_properties_t por
         }
         controller.setObjectProperty(parentDiagram, DIAGRAM, CHILDREN, children);
     }
+    else if (parentBlock != 0)
+    {
+        for (const ScicosID & id : children)
+        {
+            controller.referenceObject(id);
+        }
+        controller.setObjectProperty(parentBlock, BLOCK, CHILDREN, children);
+    }
     for (std::vector<ScicosID>::iterator it = deletedObjects.begin(); it != deletedObjects.end(); ++it)
     {
         controller.deleteObject(*it);
index 6a325d9..3d900a9 100644 (file)
@@ -200,6 +200,7 @@ Xcos trace: propertyUpdated( 5 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 6 , PORT )
 Xcos trace: propertyUpdated( 6 , PORT , FIRING ) : NO_CHANGES
@@ -429,6 +430,7 @@ Xcos trace: propertyUpdated( 9 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 9 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 9 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 9 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 10 , PORT )
 Xcos trace: propertyUpdated( 10 , PORT , FIRING ) : NO_CHANGES
@@ -658,6 +660,7 @@ Xcos trace: propertyUpdated( 13 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 14 , PORT )
 Xcos trace: propertyUpdated( 14 , PORT , FIRING ) : NO_CHANGES
@@ -891,6 +894,7 @@ Xcos trace: propertyUpdated( 18 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 18 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 18 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 18 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 18 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 18 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 19 , PORT )
 Xcos trace: propertyUpdated( 19 , PORT , FIRING ) : NO_CHANGES
@@ -1310,6 +1314,7 @@ Xcos trace: propertyUpdated( 26 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 26 , BLOCK , IPAR ) : SUCCESS
 Xcos trace: propertyUpdated( 26 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 26 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 26 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 26 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 27 , PORT )
 Xcos trace: propertyUpdated( 27 , PORT , FIRING ) : NO_CHANGES
index 3b127ed..65151e6 100644 (file)
@@ -115,7 +115,7 @@ Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
 clear Sum
 // Sum2's refCount must have been affected by "clear Sum"
 Sum2
-Sum2  = 
+Sum2  = (2)
 GUI     : BIGSOM_f
 Graphics: 
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
index d50a396..9fd7791 100644 (file)
@@ -98,6 +98,7 @@ Xcos trace: propertyUpdated( 4 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 4 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 4 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 4 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 4 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 4 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos trace: propertyUpdated( 4 , BLOCK , INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 4 , BLOCK , OUTPUTS ) : NO_CHANGES
@@ -116,47 +117,39 @@ Xcos trace: propertyUpdated( 1 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , STATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , DSTATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 5 , DIAGRAM )
-Xcos trace: propertyUpdated( 5 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 5 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 5 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 5 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 5 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 5 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 6 , BLOCK )
-Xcos trace: propertyUpdated( 6 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 6 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 5 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 6 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 6 , BLOCK ) : 1
+Xcos debug: objectCreated( 5 , BLOCK )
+Xcos trace: propertyUpdated( 5 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 1 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 6 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 6 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 1 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , OPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
@@ -168,24 +161,35 @@ Xcos trace: propertyUpdated( 1 , BLOCK , UID ) : NO_CHANGES
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
 // 'b' is a SuperBlock containing a Block
 sizeBeforeInsert = size(super.model.rpar.objs);
+Xcos debug: objectCreated( 6 , DIAGRAM )
+Xcos trace: propertyUpdated( 6 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 5 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 6 , DIAGRAM , CONTEXT ) : NO_CHANGES
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
+Xcos debug: objectReferenced( 5 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 5 , BLOCK ) : 1
+Xcos debug: objectDeleted( 6 , DIAGRAM )
+Xcos debug: objectUnreferenced( 5 , BLOCK ) : 0
 super.model.rpar = d;
+Xcos debug: objectCreated( 7 , DIAGRAM )
+Xcos trace: propertyUpdated( 7 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 5 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 7 , DIAGRAM , CONTEXT ) : NO_CHANGES
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 5 , BLOCK ) : 0
+Xcos debug: objectDeleted( 7 , DIAGRAM )
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
 Xcos trace: propertyUpdated( 1 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , STATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , DSTATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 7 , DIAGRAM )
-Xcos trace: propertyUpdated( 7 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 7 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 7 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 7 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 7 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 7 , DIAGRAM , CONTEXT ) : NO_CHANGES
 Xcos debug: objectCreated( 8 , BLOCK )
 Xcos trace: propertyUpdated( 8 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
@@ -208,20 +212,19 @@ Xcos trace: propertyUpdated( 8 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 8 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 7 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 8 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 1 , BLOCK , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 8 , BLOCK , CHILDREN ) : NO_CHANGES
 Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 8 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 6 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectUnreferenced( 6 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 1 , BLOCK , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectDeleted( 5 , BLOCK )
+Xcos trace: propertyUpdated( 1 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , OPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
@@ -230,128 +233,77 @@ Xcos trace: propertyUpdated( 1 , BLOCK , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , NZCROSS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 6 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 6 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectDeleted( 6 , BLOCK )
-Xcos debug: objectDeleted( 5 , DIAGRAM )
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
 sizeAfterInsert  = size(super.model.rpar.objs);
+Xcos debug: objectCreated( 9 , DIAGRAM )
+Xcos trace: propertyUpdated( 9 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 8 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 9 , DIAGRAM , CONTEXT ) : NO_CHANGES
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
+Xcos debug: objectReferenced( 8 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 8 , BLOCK ) : 1
+Xcos debug: objectDeleted( 9 , DIAGRAM )
+Xcos debug: objectUnreferenced( 8 , BLOCK ) : 0
 assert_checkequal(sizeBeforeInsert, 1);
 assert_checkequal(sizeAfterInsert,  1);
 // Check consecutive initialization of a SuperBlock in a diagram
 superD = scicos_diagram();
-Xcos debug: objectCreated( 9 , DIAGRAM )
-Xcos debug: objectReferenced( 9 , DIAGRAM ) : 1
-Xcos trace: propertyUpdated( 9 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 9 , DIAGRAM ) : 0
-Xcos trace: propertyUpdated( 9 , DIAGRAM , CHILDREN ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
+Xcos debug: objectCreated( 10 , DIAGRAM )
+Xcos debug: objectReferenced( 10 , DIAGRAM ) : 1
+Xcos trace: propertyUpdated( 10 , DIAGRAM , TITLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , DIAGRAM , PATH ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 10 , DIAGRAM ) : 0
+Xcos trace: propertyUpdated( 10 , DIAGRAM , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
 superD.objs(1) = super;
-Xcos debug: objectCreated( 10 , BLOCK )
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos debug: objectCreated( 11 , BLOCK )
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos debug: objectCreated( 12 , DIAGRAM )
+Xcos trace: propertyUpdated( 12 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 8 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 12 , DIAGRAM , CONTEXT ) : NO_CHANGES
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
-Xcos debug: objectReferenced( 10 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 11 , DIAGRAM )
-Xcos trace: propertyUpdated( 11 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 11 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 11 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 11 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 11 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 11 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 12 , BLOCK )
-Xcos trace: propertyUpdated( 12 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 11 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 12 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 12 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 10 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 12 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 12 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 10 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 10 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 9 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 10 , BLOCK ) : 1
-// 'superD' is a diagram containing a SuperBlock
-sBeforeInsert = size(superD.objs(1).model.rpar.objs);
-Xcos debug: objectReferenced( 10 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 10 , BLOCK ) : 1
-superD.objs(1) = super;
-Xcos debug: objectUnreferenced( 12 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 12 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectUnreferenced( 12 , BLOCK ) : 0
-Xcos debug: objectDeleted( 11 , DIAGRAM )
-Xcos debug: objectUnreferenced( 10 , BLOCK ) : 0
+Xcos debug: objectReferenced( 11 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , ODSTATE ) : NO_CHANGES
 Xcos debug: objectCreated( 13 , BLOCK )
 Xcos trace: propertyUpdated( 13 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
@@ -374,27 +326,51 @@ Xcos trace: propertyUpdated( 13 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectReferenced( 1 , BLOCK ) : 1
-Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
-Xcos debug: objectReferenced( 13 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 13 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 11 , BLOCK , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 11 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 11 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 11 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 8 , BLOCK ) : 0
+Xcos debug: objectDeleted( 12 , DIAGRAM )
+Xcos trace: propertyUpdated( 10 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 11 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 11 , BLOCK ) : 1
+// 'superD' is a diagram containing a SuperBlock
+sBeforeInsert = size(superD.objs(1).model.rpar.objs);
+Xcos debug: objectReferenced( 11 , BLOCK ) : 2
 Xcos debug: objectCreated( 14 , DIAGRAM )
-Xcos trace: propertyUpdated( 14 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 13 , BLOCK ) : 1
 Xcos trace: propertyUpdated( 14 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 11 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 11 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 11 , BLOCK ) : 1
+Xcos debug: objectReferenced( 13 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 13 , BLOCK ) : 1
+Xcos debug: objectDeleted( 14 , DIAGRAM )
+Xcos debug: objectUnreferenced( 13 , BLOCK ) : 0
+superD.objs(1) = super;
+Xcos debug: objectReferenced( 11 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 11 , BLOCK ) : 1
 Xcos debug: objectCreated( 15 , BLOCK )
 Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
@@ -417,60 +393,109 @@ Xcos trace: propertyUpdated( 15 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos debug: objectCreated( 16 , DIAGRAM )
+Xcos trace: propertyUpdated( 16 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 8 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 16 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 1 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
+Xcos debug: objectReferenced( 15 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos debug: objectCreated( 17 , BLOCK )
+Xcos trace: propertyUpdated( 17 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 15 , BLOCK , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 15 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 15 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 15 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 8 , BLOCK ) : 0
+Xcos debug: objectDeleted( 16 , DIAGRAM )
+Xcos trace: propertyUpdated( 10 , DIAGRAM , CHILDREN ) : SUCCESS
 Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
 Xcos debug: objectReferenced( 15 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 13 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 15 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 13 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 13 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 9 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 13 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 12 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectDeleted( 12 , BLOCK )
-Xcos debug: objectDeleted( 10 , BLOCK )
+Xcos trace: propertyUpdated( 11 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 11 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectDeleted( 13 , BLOCK )
+Xcos debug: objectDeleted( 11 , BLOCK )
 sAfterInsert  = size(superD.objs(1).model.rpar.objs);
-Xcos debug: objectReferenced( 13 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 13 , BLOCK ) : 1
+Xcos debug: objectReferenced( 15 , BLOCK ) : 2
+Xcos debug: objectCreated( 18 , DIAGRAM )
+Xcos trace: propertyUpdated( 18 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 17 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 18 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 15 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 15 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 15 , BLOCK ) : 1
+Xcos debug: objectReferenced( 17 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 17 , BLOCK ) : 1
+Xcos debug: objectDeleted( 18 , DIAGRAM )
+Xcos debug: objectUnreferenced( 17 , BLOCK ) : 0
 assert_checkequal(sizeBeforeInsert, 1);
 assert_checkequal(sizeAfterInsert,  1);
 // Check that all the model items are freed
 clear
-Xcos debug: objectUnreferenced( 4 , BLOCK ) : 0
 Xcos trace: propertyUpdated( 4 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectDeleted( 4 , BLOCK )
+Xcos debug: objectUnreferenced( 4 , BLOCK ) : 0
 Xcos debug: objectDeleted( 2 , DIAGRAM )
 Xcos debug: objectDeleted( 3 , BLOCK )
-Xcos debug: objectUnreferenced( 8 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectUnreferenced( 8 , BLOCK ) : 0
-Xcos debug: objectDeleted( 7 , DIAGRAM )
 Xcos trace: propertyUpdated( 8 , BLOCK , PARENT_BLOCK ) : SUCCESS
 Xcos debug: objectDeleted( 8 , BLOCK )
 Xcos debug: objectDeleted( 1 , BLOCK )
-Xcos debug: objectUnreferenced( 15 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectDeleted( 4 , BLOCK )
 Xcos debug: objectUnreferenced( 15 , BLOCK ) : 0
-Xcos debug: objectDeleted( 14 , DIAGRAM )
-Xcos debug: objectUnreferenced( 13 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 13 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectDeleted( 17 , BLOCK )
 Xcos debug: objectDeleted( 15 , BLOCK )
-Xcos debug: objectDeleted( 13 , BLOCK )
-Xcos debug: objectDeleted( 9 , DIAGRAM )
+Xcos debug: objectDeleted( 10 , DIAGRAM )
index d1e7366..6994d9e 100644 (file)
@@ -110,6 +110,7 @@ Xcos trace: propertyUpdated( 5 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 5 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , OUTPUTS ) : NO_CHANGES
@@ -120,6 +121,7 @@ Xcos trace: propertyUpdated( 2 , DIAGRAM , CHILDREN ) : SUCCESS
 Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
 Xcos debug: objectReferenced( 5 , BLOCK ) : 1
 d.objs(2) = l;
+Xcos debug: objectReferenced( 5 , BLOCK ) : 2
 Xcos debug: objectCreated( 6 , LINK )
 Xcos trace: propertyUpdated( 6 , LINK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 6 , LINK , KIND ) : NO_CHANGES
@@ -134,6 +136,7 @@ Xcos trace: propertyUpdated( 6 , LINK , DESTINATION_PORT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 2 , DIAGRAM , CHILDREN ) : SUCCESS
 Xcos trace: propertyUpdated( 6 , LINK , PARENT_DIAGRAM ) : SUCCESS
 Xcos debug: objectReferenced( 6 , LINK ) : 1
+Xcos debug: objectUnreferenced( 5 , BLOCK ) : 1
 Xcos debug: objectCreated( 7 , PORT )
 Xcos trace: propertyUpdated( 7 , PORT , IMPLICIT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 7 , PORT , PORT_KIND ) : SUCCESS
@@ -161,36 +164,41 @@ Xcos trace: propertyUpdated( 1 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , STATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , DSTATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 9 , DIAGRAM )
-Xcos trace: propertyUpdated( 9 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 10 , BLOCK )
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos debug: objectCreated( 9 , BLOCK )
+Xcos trace: propertyUpdated( 9 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos debug: objectCreated( 10 , PORT )
+Xcos trace: propertyUpdated( 10 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 10 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 10 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 10 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 10 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 11 , PORT )
 Xcos trace: propertyUpdated( 11 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 11 , PORT , PORT_KIND ) : SUCCESS
@@ -201,46 +209,30 @@ Xcos trace: propertyUpdated( 11 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 11 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 11 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 11 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , INPUTS ) : SUCCESS
-Xcos debug: objectCreated( 12 , PORT )
-Xcos trace: propertyUpdated( 12 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 12 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 12 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 12 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 12 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 13 , LINK )
-Xcos trace: propertyUpdated( 13 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , DESTINATION_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 9 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 10 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 13 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 13 , LINK ) : 1
-Xcos trace: propertyUpdated( 12 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 13 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 11 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 13 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 9 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 9 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectCreated( 12 , LINK )
+Xcos trace: propertyUpdated( 12 , LINK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , KIND ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , THICK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , SOURCE_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , DESTINATION_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , PARENT_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 1 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 10 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 13 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 13 , LINK ) : 2
+Xcos trace: propertyUpdated( 11 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 12 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 10 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 12 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 1 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , OPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 1 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
@@ -252,83 +244,96 @@ Xcos trace: propertyUpdated( 1 , BLOCK , UID ) : NO_CHANGES
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
 // Main diagram
 scs_m = scicos_diagram();
-Xcos debug: objectCreated( 14 , DIAGRAM )
-Xcos debug: objectReferenced( 14 , DIAGRAM ) : 1
-Xcos trace: propertyUpdated( 14 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 14 , DIAGRAM ) : 0
-Xcos trace: propertyUpdated( 14 , DIAGRAM , CHILDREN ) : NO_CHANGES
-Xcos trace: propertyUpdated( 14 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
+Xcos debug: objectCreated( 13 , DIAGRAM )
+Xcos debug: objectReferenced( 13 , DIAGRAM ) : 1
+Xcos trace: propertyUpdated( 13 , DIAGRAM , TITLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , DIAGRAM , PATH ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 13 , DIAGRAM ) : 0
+Xcos trace: propertyUpdated( 13 , DIAGRAM , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 13 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
 scs_m.objs(1) = sb;
-Xcos debug: objectCreated( 15 , BLOCK )
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos debug: objectCreated( 14 , BLOCK )
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos debug: objectCreated( 15 , DIAGRAM )
+Xcos trace: propertyUpdated( 15 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 9 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 12 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 12 , LINK ) : 1
+Xcos trace: propertyUpdated( 15 , DIAGRAM , CONTEXT ) : NO_CHANGES
 Xcos debug: objectReferenced( 1 , BLOCK ) : 1
 Xcos debug: objectUnreferenced( 1 , BLOCK ) : 0
-Xcos debug: objectReferenced( 15 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 16 , DIAGRAM )
-Xcos trace: propertyUpdated( 16 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 16 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 16 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 16 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 16 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 16 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 17 , BLOCK )
-Xcos trace: propertyUpdated( 17 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos debug: objectCreated( 16 , BLOCK )
+Xcos trace: propertyUpdated( 16 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos debug: objectCreated( 17 , PORT )
+Xcos trace: propertyUpdated( 17 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 17 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 17 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 17 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 17 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 18 , PORT )
 Xcos trace: propertyUpdated( 18 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 18 , PORT , PORT_KIND ) : SUCCESS
@@ -339,64 +344,62 @@ Xcos trace: propertyUpdated( 18 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 18 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 18 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 18 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , INPUTS ) : SUCCESS
-Xcos debug: objectCreated( 19 , PORT )
-Xcos trace: propertyUpdated( 19 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 19 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 19 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 19 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 19 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 19 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 19 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 19 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 19 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 20 , LINK )
-Xcos trace: propertyUpdated( 20 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , DESTINATION_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 16 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 17 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 20 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 20 , LINK ) : 1
-Xcos trace: propertyUpdated( 19 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 20 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectCreated( 19 , LINK )
+Xcos trace: propertyUpdated( 19 , LINK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , KIND ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , THICK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , SOURCE_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , DESTINATION_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 14 , BLOCK , CHILDREN ) : SUCCESS
 Xcos trace: propertyUpdated( 18 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 20 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 15 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 17 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 20 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 20 , LINK ) : 2
-Xcos trace: propertyUpdated( 15 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 15 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 15 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 14 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 15 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 19 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 17 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 14 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 14 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 12 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 9 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 12 , LINK ) : 0
+Xcos debug: objectDeleted( 15 , DIAGRAM )
+Xcos trace: propertyUpdated( 13 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 14 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 14 , BLOCK ) : 1
 scs_m.objs(1).model.rpar // Checking 'sb' elements
-Xcos debug: objectReferenced( 15 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 15 , BLOCK ) : 1
+Xcos debug: objectReferenced( 14 , BLOCK ) : 2
+Xcos debug: objectCreated( 20 , DIAGRAM )
+Xcos trace: propertyUpdated( 20 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 1
+Xcos trace: propertyUpdated( 20 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 1
  ans  =
-Xcos debug: objectReferenced( 16 , DIAGRAM ) : 1
-Xcos debug: objectUnreferenced( 16 , DIAGRAM ) : 0
+Xcos debug: objectReferenced( 20 , DIAGRAM ) : 1
+Xcos debug: objectUnreferenced( 20 , DIAGRAM ) : 0
 wpar = [600,450,0,0,600,450]
 title = ["Untitled";""]
 tol = [0.000001,0.000001,1.000D-10,100001,0,1,0]
@@ -407,16 +410,39 @@ options = tlist(["scsopt","3D","Background","Link","ID","Cmap"],list(%t,33),[8,1
 void2 = []
 void3 = []
 doc = list()
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectReferenced( 19 , LINK ) : 2
 1     
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
 scs_m.objs(1).model.rpar.objs // "
-Xcos debug: objectReferenced( 15 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 15 , BLOCK ) : 1
+Xcos debug: objectReferenced( 14 , BLOCK ) : 2
+Xcos debug: objectCreated( 21 , DIAGRAM )
+Xcos trace: propertyUpdated( 21 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 21 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 1
+Xcos debug: objectReferenced( 16 , BLOCK ) : 3
+Xcos debug: objectReferenced( 19 , LINK ) : 3
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 19 , LINK ) : 2
+Xcos debug: objectDeleted( 21 , DIAGRAM )
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectDeleted( 20 , DIAGRAM )
  ans  =
        ans(1)
 GUI     : 
 Graphics: 
-Xcos debug: objectReferenced( 17 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 17 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
           orig = [0,0]
           sz = [20,20]
           flip = %t
@@ -436,8 +462,8 @@ Xcos debug: objectUnreferenced( 17 , BLOCK ) : 2
           out_label = ""
           style = ""
 Model   : 
-Xcos debug: objectReferenced( 17 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 17 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
            type: 0
           in = -1
           in2 = 1
@@ -472,144 +498,30 @@ Link    :
           to: 1 1 1
 l = list(1); l(1) = scs_m; // Cloning 'scs_m'
 Xcos debug: objectDeleted( 4 , LINK )
-Xcos debug: objectCreated( 21 , DIAGRAM )
-Xcos trace: propertyUpdated( 21 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 21 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 21 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 21 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 21 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 21 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 22 , BLOCK )
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectReferenced( 15 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 15 , BLOCK ) : 1
-Xcos debug: objectReferenced( 22 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos debug: objectCreated( 22 , DIAGRAM )
+Xcos trace: propertyUpdated( 22 , DIAGRAM , TITLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 22 , DIAGRAM , PATH ) : NO_CHANGES
+Xcos trace: propertyUpdated( 22 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
+Xcos trace: propertyUpdated( 22 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 22 , DIAGRAM , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 22 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 22 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 14 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 14 , BLOCK ) : 2
+l(1).objs(1).model.rpar
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
 Xcos debug: objectCreated( 23 , DIAGRAM )
-Xcos trace: propertyUpdated( 23 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 23 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 23 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 23 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 23 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 23 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 24 , BLOCK )
-Xcos trace: propertyUpdated( 24 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 25 , PORT )
-Xcos trace: propertyUpdated( 25 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 25 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 25 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 25 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 25 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 25 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 25 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 25 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 25 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , INPUTS ) : SUCCESS
-Xcos debug: objectCreated( 26 , PORT )
-Xcos trace: propertyUpdated( 26 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 26 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 26 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 26 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 26 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 26 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 26 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 26 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 26 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 27 , LINK )
-Xcos trace: propertyUpdated( 27 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , DESTINATION_PORT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 23 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 24 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 27 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 27 , LINK ) : 1
-Xcos trace: propertyUpdated( 26 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 27 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 25 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 27 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 22 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 24 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 27 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 27 , LINK ) : 2
-Xcos trace: propertyUpdated( 22 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 22 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 21 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 22 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 22 , BLOCK ) : 1
-l(1).objs(1).model.rpar
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 23 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
  ans  =
 Xcos debug: objectReferenced( 23 , DIAGRAM ) : 1
 Xcos debug: objectUnreferenced( 23 , DIAGRAM ) : 0
@@ -623,16 +535,39 @@ options = tlist(["scsopt","3D","Background","Link","ID","Cmap"],list(%t,33),[8,1
 void2 = []
 void3 = []
 doc = list()
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectReferenced( 19 , LINK ) : 2
 1     
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
 l(1).objs(1).model.rpar.objs
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectCreated( 24 , DIAGRAM )
+Xcos trace: propertyUpdated( 24 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 24 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 3
+Xcos debug: objectReferenced( 19 , LINK ) : 3
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 19 , LINK ) : 2
+Xcos debug: objectDeleted( 24 , DIAGRAM )
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectDeleted( 23 , DIAGRAM )
  ans  =
        ans(1)
 GUI     : 
 Graphics: 
-Xcos debug: objectReferenced( 24 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 24 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
           orig = [0,0]
           sz = [20,20]
           flip = %t
@@ -652,8 +587,8 @@ Xcos debug: objectUnreferenced( 24 , BLOCK ) : 2
           out_label = ""
           style = ""
 Model   : 
-Xcos debug: objectReferenced( 24 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 24 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
            type: 0
           in = -1
           in2 = 1
@@ -687,32 +622,145 @@ Link    :
           from: 1 1 0
           to: 1 1 1
 assert_checkequal(size(l(1).objs(1).model.rpar.objs), 2);
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectCreated( 25 , DIAGRAM )
+Xcos trace: propertyUpdated( 25 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 25 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 3
+Xcos debug: objectReferenced( 19 , LINK ) : 3
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 19 , LINK ) : 2
+Xcos debug: objectDeleted( 25 , DIAGRAM )
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 19 , LINK ) : 0
 // Check connections
 assert_checkequal(l(1).objs(1).model.rpar.objs(1).graphics.pout, 2);
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
-Xcos debug: objectReferenced( 24 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 24 , BLOCK ) : 2
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectCreated( 26 , DIAGRAM )
+Xcos trace: propertyUpdated( 26 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 1
+Xcos trace: propertyUpdated( 26 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectDeleted( 26 , DIAGRAM )
+Xcos debug: objectUnreferenced( 19 , LINK ) : 0
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(1).graphics.pin,  2);
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
-Xcos debug: objectReferenced( 24 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 24 , BLOCK ) : 2
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectCreated( 27 , DIAGRAM )
+Xcos trace: propertyUpdated( 27 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 1
+Xcos trace: propertyUpdated( 27 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectDeleted( 27 , DIAGRAM )
+Xcos debug: objectUnreferenced( 19 , LINK ) : 0
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(2).from, [1 1 0]);
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectCreated( 28 , DIAGRAM )
+Xcos trace: propertyUpdated( 28 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 1
+Xcos trace: propertyUpdated( 28 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectDeleted( 28 , DIAGRAM )
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 19 , LINK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(2).to,   [1 1 1]);
-Xcos debug: objectReferenced( 22 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 1
+Xcos debug: objectReferenced( 14 , BLOCK ) : 3
+Xcos debug: objectCreated( 29 , DIAGRAM )
+Xcos trace: propertyUpdated( 29 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 16 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 19 , LINK ) : 1
+Xcos trace: propertyUpdated( 29 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 14 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 2
+Xcos debug: objectReferenced( 16 , BLOCK ) : 2
+Xcos debug: objectReferenced( 19 , LINK ) : 2
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 19 , LINK ) : 1
+Xcos debug: objectDeleted( 29 , DIAGRAM )
+Xcos debug: objectUnreferenced( 16 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 19 , LINK ) : 0
 // Check that all the model items are freed
 clear
 Xcos debug: objectDeleted( 3 , BLOCK )
-Xcos debug: objectUnreferenced( 5 , BLOCK ) : 0
-Xcos debug: objectUnreferenced( 6 , LINK ) : 0
 Xcos trace: propertyUpdated( 5 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
 Xcos trace: propertyUpdated( 6 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 5 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 6 , LINK ) : 0
+Xcos debug: objectDeleted( 2 , DIAGRAM )
+Xcos trace: propertyUpdated( 14 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 1
+Xcos debug: objectDeleted( 22 , DIAGRAM )
+Xcos trace: propertyUpdated( 9 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 12 , LINK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 9 , BLOCK , INPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 9 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos debug: objectDeleted( 10 , PORT )
+Xcos trace: propertyUpdated( 9 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 9 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 9 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 12 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos debug: objectDeleted( 11 , PORT )
+Xcos debug: objectDeleted( 9 , BLOCK )
+Xcos debug: objectDeleted( 12 , LINK )
+Xcos debug: objectDeleted( 1 , BLOCK )
 Xcos trace: propertyUpdated( 5 , BLOCK , INPUTS ) : SUCCESS
 Xcos trace: propertyUpdated( 5 , BLOCK , OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 5 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
@@ -727,287 +775,207 @@ Xcos trace: propertyUpdated( 6 , LINK , SOURCE_PORT ) : SUCCESS
 Xcos debug: objectDeleted( 7 , PORT )
 Xcos debug: objectDeleted( 5 , BLOCK )
 Xcos debug: objectDeleted( 6 , LINK )
-Xcos debug: objectDeleted( 2 , DIAGRAM )
-Xcos debug: objectUnreferenced( 24 , BLOCK ) : 1
-Xcos debug: objectUnreferenced( 27 , LINK ) : 1
-Xcos trace: propertyUpdated( 24 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 27 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectUnreferenced( 24 , BLOCK ) : 0
-Xcos debug: objectUnreferenced( 27 , LINK ) : 0
-Xcos debug: objectDeleted( 23 , DIAGRAM )
-Xcos debug: objectUnreferenced( 22 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 22 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 27 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , INPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos debug: objectDeleted( 25 , PORT )
-Xcos trace: propertyUpdated( 24 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 24 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 24 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 27 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos debug: objectDeleted( 26 , PORT )
-Xcos debug: objectDeleted( 24 , BLOCK )
-Xcos debug: objectDeleted( 27 , LINK )
-Xcos debug: objectDeleted( 22 , BLOCK )
-Xcos debug: objectDeleted( 21 , DIAGRAM )
-Xcos debug: objectUnreferenced( 10 , BLOCK ) : 1
-Xcos debug: objectUnreferenced( 13 , LINK ) : 1
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 13 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectUnreferenced( 10 , BLOCK ) : 0
-Xcos debug: objectUnreferenced( 13 , LINK ) : 0
-Xcos debug: objectDeleted( 9 , DIAGRAM )
-Xcos trace: propertyUpdated( 10 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 13 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , INPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos debug: objectDeleted( 11 , PORT )
-Xcos trace: propertyUpdated( 10 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 10 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 13 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos debug: objectDeleted( 12 , PORT )
-Xcos debug: objectDeleted( 10 , BLOCK )
-Xcos debug: objectDeleted( 13 , LINK )
-Xcos debug: objectDeleted( 1 , BLOCK )
-Xcos debug: objectUnreferenced( 17 , BLOCK ) : 1
-Xcos debug: objectUnreferenced( 20 , LINK ) : 1
-Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 20 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectUnreferenced( 17 , BLOCK ) : 0
-Xcos debug: objectUnreferenced( 20 , LINK ) : 0
-Xcos debug: objectDeleted( 16 , DIAGRAM )
-Xcos debug: objectUnreferenced( 15 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 15 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 20 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , INPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos debug: objectUnreferenced( 14 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 16 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 19 , LINK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , INPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos debug: objectDeleted( 17 , PORT )
+Xcos trace: propertyUpdated( 16 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 16 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 16 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 19 , LINK , SOURCE_PORT ) : SUCCESS
 Xcos debug: objectDeleted( 18 , PORT )
-Xcos trace: propertyUpdated( 17 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 17 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 20 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos debug: objectDeleted( 19 , PORT )
-Xcos debug: objectDeleted( 17 , BLOCK )
-Xcos debug: objectDeleted( 20 , LINK )
-Xcos debug: objectDeleted( 15 , BLOCK )
-Xcos debug: objectDeleted( 14 , DIAGRAM )
+Xcos debug: objectDeleted( 16 , BLOCK )
+Xcos debug: objectDeleted( 19 , LINK )
+Xcos debug: objectDeleted( 14 , BLOCK )
+Xcos debug: objectDeleted( 13 , DIAGRAM )
 // Relaunch Xcos librairy
 loadXcosLibs();
 scicos_log("TRACE");
 // Try with two "BIGSOM_f" blocks connected together
 // The SuperBlock, containing a Block and a Link
 sb = scicos_block();
-Xcos debug: objectCreated( 28 , BLOCK )
-Xcos debug: objectReferenced( 28 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 28 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , STYLE ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 28 , BLOCK ) : 0
-Xcos debug: objectReferenced( 28 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 28 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 28 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-// Sub-Diagram of 'sb'
-d = scicos_diagram();
-Xcos debug: objectCreated( 29 , DIAGRAM )
-Xcos debug: objectReferenced( 29 , DIAGRAM ) : 1
-Xcos trace: propertyUpdated( 29 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 29 , DIAGRAM ) : 0
-Xcos trace: propertyUpdated( 29 , DIAGRAM , CHILDREN ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-// Block & Link
-Sum1 = BIGSOM_f("define");
 Xcos debug: objectCreated( 30 , BLOCK )
 Xcos debug: objectReferenced( 30 , BLOCK ) : 1
 Xcos trace: propertyUpdated( 30 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 30 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , GEOMETRY ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , ANGLE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 30 , BLOCK , EXPRS ) : SUCCESS
-Xcos debug: objectCreated( 31 , PORT )
-Xcos trace: propertyUpdated( 31 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 31 , PORT , PORT_KIND ) : SUCCESS
-Xcos debug: objectCreated( 32 , PORT )
-Xcos trace: propertyUpdated( 32 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 32 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 30 , BLOCK , INPUTS ) : SUCCESS
-Xcos debug: objectCreated( 33 , PORT )
-Xcos trace: propertyUpdated( 33 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 33 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 30 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , EXPRS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 31 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 32 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 33 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 31 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 32 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 33 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 31 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 32 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 33 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , STYLE ) : NO_CHANGES
 Xcos debug: objectUnreferenced( 30 , BLOCK ) : 0
 Xcos debug: objectReferenced( 30 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 30 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 30 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 31 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 32 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 33 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , STATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , DSTATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 30 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , RPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , OPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 30 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , NZCROSS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 30 , BLOCK , UID ) : NO_CHANGES
 Xcos debug: objectUnreferenced( 30 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 30 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Sum2 = BIGSOM_f("define");
-Xcos debug: objectCreated( 34 , BLOCK )
-Xcos debug: objectReferenced( 34 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 34 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+// Sub-Diagram of 'sb'
+d = scicos_diagram();
+Xcos debug: objectCreated( 31 , DIAGRAM )
+Xcos debug: objectReferenced( 31 , DIAGRAM ) : 1
+Xcos trace: propertyUpdated( 31 , DIAGRAM , TITLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , PATH ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 31 , DIAGRAM ) : 0
+Xcos trace: propertyUpdated( 31 , DIAGRAM , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
+// Block & Link
+Sum1 = BIGSOM_f("define");
+Xcos debug: objectCreated( 32 , BLOCK )
+Xcos debug: objectReferenced( 32 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 32 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , EXPRS ) : SUCCESS
+Xcos debug: objectCreated( 33 , PORT )
+Xcos trace: propertyUpdated( 33 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 33 , PORT , PORT_KIND ) : SUCCESS
+Xcos debug: objectCreated( 34 , PORT )
+Xcos trace: propertyUpdated( 34 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 34 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 35 , PORT )
 Xcos trace: propertyUpdated( 35 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 35 , PORT , PORT_KIND ) : SUCCESS
-Xcos debug: objectCreated( 36 , PORT )
-Xcos trace: propertyUpdated( 36 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 36 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , INPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 33 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 34 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 35 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 33 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 34 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 35 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 33 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 34 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 35 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , STYLE ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 32 , BLOCK ) : 0
+Xcos debug: objectReferenced( 32 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 32 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 33 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 34 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 35 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 32 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 32 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 32 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 32 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Sum2 = BIGSOM_f("define");
+Xcos debug: objectCreated( 36 , BLOCK )
+Xcos debug: objectReferenced( 36 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 36 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , EXPRS ) : SUCCESS
 Xcos debug: objectCreated( 37 , PORT )
 Xcos trace: propertyUpdated( 37 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 37 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 35 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 36 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos debug: objectCreated( 38 , PORT )
+Xcos trace: propertyUpdated( 38 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 38 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 39 , PORT )
+Xcos trace: propertyUpdated( 39 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 39 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 37 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 35 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 36 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 38 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 39 , PORT , IMPLICIT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 37 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 35 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 36 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 38 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 39 , PORT , STYLE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 37 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , STYLE ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 34 , BLOCK ) : 0
-Xcos debug: objectReferenced( 34 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 34 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 35 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 36 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 38 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 39 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , STYLE ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 36 , BLOCK ) : 0
+Xcos debug: objectReferenced( 36 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 36 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
 Xcos trace: propertyUpdated( 37 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 34 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 34 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 34 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 34 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 38 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 39 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 36 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 36 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 36 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 36 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
 l = scicos_link( from=[1 1 0],to=[2 1 1] ); // Connecting 'Sum1' to 'Sum2'
-Xcos debug: objectCreated( 38 , LINK )
-Xcos trace: propertyUpdated( 38 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 38 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 38 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 38 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 38 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 38 , LINK , KIND ) : NO_CHANGES
+Xcos debug: objectCreated( 40 , LINK )
+Xcos trace: propertyUpdated( 40 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 40 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 40 , LINK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 40 , LINK , THICK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 40 , LINK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 40 , LINK , KIND ) : NO_CHANGES
 // Assembling the elements, making 'sb' a SuperBlock
 d.objs(1) = Sum1;
-Xcos debug: objectCreated( 39 , BLOCK )
-Xcos trace: propertyUpdated( 39 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 40 , PORT )
-Xcos trace: propertyUpdated( 40 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 40 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 40 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 40 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 40 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 40 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 40 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 40 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 40 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos debug: objectCreated( 41 , PORT )
-Xcos trace: propertyUpdated( 41 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 41 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 41 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 41 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 41 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 41 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 41 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 41 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 41 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 41 , BLOCK )
+Xcos trace: propertyUpdated( 41 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 42 , PORT )
 Xcos trace: propertyUpdated( 42 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 42 , PORT , PORT_KIND ) : SUCCESS
@@ -1018,37 +986,17 @@ Xcos trace: propertyUpdated( 42 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 42 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 42 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 42 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 39 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 39 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 39 , BLOCK ) : 1
-d.objs(2) = Sum2;
-Xcos debug: objectCreated( 43 , BLOCK )
-Xcos trace: propertyUpdated( 43 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos debug: objectCreated( 43 , PORT )
+Xcos trace: propertyUpdated( 43 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 43 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 43 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 43 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 43 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 43 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 43 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 43 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 43 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 44 , PORT )
 Xcos trace: propertyUpdated( 44 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 44 , PORT , PORT_KIND ) : SUCCESS
@@ -1059,17 +1007,39 @@ Xcos trace: propertyUpdated( 44 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 44 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 44 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 44 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos debug: objectCreated( 45 , PORT )
-Xcos trace: propertyUpdated( 45 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 45 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 45 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 45 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 45 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 45 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 45 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 45 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 45 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , INPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 41 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 41 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 41 , BLOCK ) : 1
+d.objs(2) = Sum2;
+Xcos debug: objectReferenced( 41 , BLOCK ) : 2
+Xcos debug: objectCreated( 45 , BLOCK )
+Xcos trace: propertyUpdated( 45 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 46 , PORT )
 Xcos trace: propertyUpdated( 46 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 46 , PORT , PORT_KIND ) : SUCCESS
@@ -1080,81 +1050,91 @@ Xcos trace: propertyUpdated( 46 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 46 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 46 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 46 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 43 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 43 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 43 , BLOCK ) : 1
+Xcos debug: objectCreated( 47 , PORT )
+Xcos trace: propertyUpdated( 47 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 47 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 47 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 47 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 47 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 47 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 47 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 47 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 47 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 48 , PORT )
+Xcos trace: propertyUpdated( 48 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 48 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 48 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 48 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 48 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 48 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 48 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 48 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 48 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 45 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 45 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 45 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 41 , BLOCK ) : 1
 d.objs(3) = l;
-Xcos debug: objectCreated( 47 , LINK )
-Xcos trace: propertyUpdated( 47 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 47 , LINK , DESTINATION_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 29 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 47 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 47 , LINK ) : 1
-Xcos trace: propertyUpdated( 42 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 47 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos debug: objectReferenced( 41 , BLOCK ) : 2
+Xcos debug: objectReferenced( 45 , BLOCK ) : 2
+Xcos debug: objectCreated( 49 , LINK )
+Xcos trace: propertyUpdated( 49 , LINK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , KIND ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , THICK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , SOURCE_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 49 , LINK , DESTINATION_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 31 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 49 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 49 , LINK ) : 1
+Xcos debug: objectUnreferenced( 41 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 45 , BLOCK ) : 1
 Xcos trace: propertyUpdated( 44 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 47 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 49 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 46 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 49 , LINK , DESTINATION_PORT ) : SUCCESS
 sb.model.rpar = d;
-Xcos debug: objectReferenced( 28 , BLOCK ) : 1
-Xcos debug: objectUnreferenced( 28 , BLOCK ) : 0
-Xcos debug: objectReferenced( 28 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 48 , DIAGRAM )
-Xcos trace: propertyUpdated( 48 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 48 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 48 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 48 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 48 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 48 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 49 , BLOCK )
-Xcos trace: propertyUpdated( 49 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 50 , PORT )
-Xcos trace: propertyUpdated( 50 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 50 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 50 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 50 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 50 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 50 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 50 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 50 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 50 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos debug: objectReferenced( 30 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 30 , BLOCK ) : 0
+Xcos debug: objectReferenced( 30 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos debug: objectCreated( 50 , BLOCK )
+Xcos trace: propertyUpdated( 50 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 51 , PORT )
 Xcos trace: propertyUpdated( 51 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 51 , PORT , PORT_KIND ) : SUCCESS
@@ -1165,7 +1145,6 @@ Xcos trace: propertyUpdated( 51 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 51 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 51 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 51 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 52 , PORT )
 Xcos trace: propertyUpdated( 52 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 52 , PORT , PORT_KIND ) : SUCCESS
@@ -1176,43 +1155,47 @@ Xcos trace: propertyUpdated( 52 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 52 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 52 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 52 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 49 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 53 , BLOCK )
-Xcos trace: propertyUpdated( 53 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 54 , PORT )
-Xcos trace: propertyUpdated( 54 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 54 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 54 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 54 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 54 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 54 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 54 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 54 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 54 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 53 , PORT )
+Xcos trace: propertyUpdated( 53 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 53 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 53 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 53 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 53 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 53 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 53 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 53 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 53 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 50 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectCreated( 54 , BLOCK )
+Xcos trace: propertyUpdated( 54 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 55 , PORT )
 Xcos trace: propertyUpdated( 55 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 55 , PORT , PORT_KIND ) : SUCCESS
@@ -1223,7 +1206,6 @@ Xcos trace: propertyUpdated( 55 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 55 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 55 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 55 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 56 , PORT )
 Xcos trace: propertyUpdated( 56 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 56 , PORT , PORT_KIND ) : SUCCESS
@@ -1234,137 +1216,133 @@ Xcos trace: propertyUpdated( 56 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 56 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 56 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 56 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 53 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 53 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 57 , LINK )
-Xcos trace: propertyUpdated( 57 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 57 , LINK , DESTINATION_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 48 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 49 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 53 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 53 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 57 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 57 , LINK ) : 1
-Xcos trace: propertyUpdated( 52 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 57 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 54 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 57 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 28 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 49 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 49 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 53 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 53 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 57 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 57 , LINK ) : 2
-Xcos trace: propertyUpdated( 28 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 28 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 28 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 54 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 57 , PORT )
+Xcos trace: propertyUpdated( 57 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 57 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 57 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 57 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 57 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 57 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 57 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 57 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 57 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 54 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectCreated( 58 , LINK )
+Xcos trace: propertyUpdated( 58 , LINK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , KIND ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , THICK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , SOURCE_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , DESTINATION_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 58 , LINK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 53 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 58 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 55 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 58 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 30 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 30 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 30 , BLOCK ) : 0
 // Main diagram
 scs_m = scicos_diagram();
-Xcos debug: objectCreated( 58 , DIAGRAM )
-Xcos debug: objectReferenced( 58 , DIAGRAM ) : 1
-Xcos trace: propertyUpdated( 58 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 58 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 58 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 58 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 58 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 58 , DIAGRAM ) : 0
-Xcos trace: propertyUpdated( 58 , DIAGRAM , CHILDREN ) : NO_CHANGES
-Xcos trace: propertyUpdated( 58 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
+Xcos debug: objectCreated( 59 , DIAGRAM )
+Xcos debug: objectReferenced( 59 , DIAGRAM ) : 1
+Xcos trace: propertyUpdated( 59 , DIAGRAM , TITLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 59 , DIAGRAM , PATH ) : NO_CHANGES
+Xcos trace: propertyUpdated( 59 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 59 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 59 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 59 , DIAGRAM ) : 0
+Xcos trace: propertyUpdated( 59 , DIAGRAM , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 59 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
 scs_m.objs(1) = sb;
-Xcos debug: objectCreated( 59 , BLOCK )
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectReferenced( 28 , BLOCK ) : 1
-Xcos debug: objectUnreferenced( 28 , BLOCK ) : 0
-Xcos debug: objectReferenced( 59 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 60 , DIAGRAM )
-Xcos trace: propertyUpdated( 60 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 60 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 60 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 60 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 60 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 60 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 61 , BLOCK )
-Xcos trace: propertyUpdated( 61 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 62 , PORT )
-Xcos trace: propertyUpdated( 62 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 62 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 62 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 62 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 62 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 62 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 62 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 62 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 62 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos debug: objectCreated( 60 , BLOCK )
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , GEOMETRY ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , EXPRS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , RPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos debug: objectCreated( 61 , DIAGRAM )
+Xcos trace: propertyUpdated( 61 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 50 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 50 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 54 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 54 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 58 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 58 , LINK ) : 1
+Xcos trace: propertyUpdated( 61 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 30 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 30 , BLOCK ) : 0
+Xcos debug: objectReferenced( 60 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos debug: objectCreated( 62 , BLOCK )
+Xcos trace: propertyUpdated( 62 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 63 , PORT )
 Xcos trace: propertyUpdated( 63 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 63 , PORT , PORT_KIND ) : SUCCESS
@@ -1375,7 +1353,6 @@ Xcos trace: propertyUpdated( 63 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 63 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 63 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 63 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 64 , PORT )
 Xcos trace: propertyUpdated( 64 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 64 , PORT , PORT_KIND ) : SUCCESS
@@ -1386,43 +1363,47 @@ Xcos trace: propertyUpdated( 64 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 64 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 64 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 64 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 61 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 65 , BLOCK )
-Xcos trace: propertyUpdated( 65 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 66 , PORT )
-Xcos trace: propertyUpdated( 66 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 66 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 66 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 66 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 66 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 66 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 66 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 66 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 66 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 65 , PORT )
+Xcos trace: propertyUpdated( 65 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 65 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 65 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 65 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 65 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 65 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 65 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 65 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 65 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectCreated( 66 , BLOCK )
+Xcos trace: propertyUpdated( 66 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , GEOMETRY ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , ANGLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , EXPRS ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , STATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , DSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , ODSTATE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , RPAR ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , SIM_DEP_UT ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos debug: objectCreated( 67 , PORT )
 Xcos trace: propertyUpdated( 67 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 67 , PORT , PORT_KIND ) : SUCCESS
@@ -1433,7 +1414,6 @@ Xcos trace: propertyUpdated( 67 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 67 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 67 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 67 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , INPUTS ) : SUCCESS
 Xcos debug: objectCreated( 68 , PORT )
 Xcos trace: propertyUpdated( 68 , PORT , FIRING ) : NO_CHANGES
 Xcos trace: propertyUpdated( 68 , PORT , PORT_KIND ) : SUCCESS
@@ -1444,57 +1424,77 @@ Xcos trace: propertyUpdated( 68 , PORT , LABEL ) : NO_CHANGES
 Xcos trace: propertyUpdated( 68 , PORT , DATATYPE ) : SUCCESS
 Xcos trace: propertyUpdated( 68 , PORT , SOURCE_BLOCK ) : SUCCESS
 Xcos trace: propertyUpdated( 68 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 65 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 65 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 69 , LINK )
-Xcos trace: propertyUpdated( 69 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 69 , LINK , DESTINATION_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 60 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 61 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 65 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 65 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 69 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 69 , LINK ) : 1
-Xcos trace: propertyUpdated( 64 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 69 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 66 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 69 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 59 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 61 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 61 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 65 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 65 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 69 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 69 , LINK ) : 2
-Xcos trace: propertyUpdated( 59 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 59 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 59 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 58 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 59 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 59 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , INPUTS ) : SUCCESS
+Xcos debug: objectCreated( 69 , PORT )
+Xcos trace: propertyUpdated( 69 , PORT , FIRING ) : NO_CHANGES
+Xcos trace: propertyUpdated( 69 , PORT , PORT_KIND ) : SUCCESS
+Xcos trace: propertyUpdated( 69 , PORT , IMPLICIT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 69 , PORT , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 69 , PORT , STYLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 69 , PORT , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 69 , PORT , DATATYPE ) : SUCCESS
+Xcos trace: propertyUpdated( 69 , PORT , SOURCE_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 69 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , OUTPUTS ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , CHILDREN ) : NO_CHANGES
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_BLOCK ) : SUCCESS
+Xcos debug: objectCreated( 70 , LINK )
+Xcos trace: propertyUpdated( 70 , LINK , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , KIND ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , UID ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , CONTROL_POINTS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , THICK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_BLOCK ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , SOURCE_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , DESTINATION_PORT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_BLOCK ) : SUCCESS
+Xcos trace: propertyUpdated( 60 , BLOCK , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 65 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , SOURCE_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 67 , PORT , CONNECTED_SIGNALS ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , DESTINATION_PORT ) : SUCCESS
+Xcos trace: propertyUpdated( 60 , BLOCK , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , IPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , OPAR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , LABEL ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , NZCROSS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , NMODE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 60 , BLOCK , UID ) : NO_CHANGES
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 0
+Xcos trace: propertyUpdated( 50 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 54 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 58 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 50 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 54 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 58 , LINK ) : 0
+Xcos debug: objectDeleted( 61 , DIAGRAM )
+Xcos trace: propertyUpdated( 59 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 60 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 60 , BLOCK ) : 1
 scs_m.objs(1).model.rpar // Checking 'sb' elements
-Xcos debug: objectReferenced( 59 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 59 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 2
+Xcos debug: objectCreated( 71 , DIAGRAM )
+Xcos trace: propertyUpdated( 71 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 71 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 1
  ans  =
-Xcos debug: objectReferenced( 60 , DIAGRAM ) : 1
-Xcos debug: objectUnreferenced( 60 , DIAGRAM ) : 0
+Xcos debug: objectReferenced( 71 , DIAGRAM ) : 1
+Xcos debug: objectUnreferenced( 71 , DIAGRAM ) : 0
 wpar = [600,450,0,0,600,450]
 title = ["Untitled";""]
 tol = [0.000001,0.000001,1.000D-10,100001,0,1,0]
@@ -1505,17 +1505,48 @@ options = tlist(["scsopt","3D","Background","Link","ID","Cmap"],list(%t,33),[8,1
 void2 = []
 void3 = []
 doc = list()
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
 1     BIGSOM_f
 2     BIGSOM_f
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
 scs_m.objs(1).model.rpar.objs // "
-Xcos debug: objectReferenced( 59 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 59 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 2
+Xcos debug: objectCreated( 72 , DIAGRAM )
+Xcos trace: propertyUpdated( 72 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 72 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 1
+Xcos debug: objectReferenced( 62 , BLOCK ) : 3
+Xcos debug: objectReferenced( 66 , BLOCK ) : 3
+Xcos debug: objectReferenced( 70 , LINK ) : 3
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 70 , LINK ) : 2
+Xcos debug: objectDeleted( 72 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 71 , DIAGRAM )
  ans  =
        ans(1)
 GUI     : BIGSOM_f
 Graphics: 
-Xcos debug: objectReferenced( 61 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 61 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
           orig = [0,0]
           sz = [2,3]
           flip = %t
@@ -1535,8 +1566,8 @@ Xcos debug: objectUnreferenced( 61 , BLOCK ) : 2
           out_label = ""
           style = ""
 Model   : 
-Xcos debug: objectReferenced( 61 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 61 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
           sum type: 2
           in = [-1;-1]
           in2 = [1;1]
@@ -1563,8 +1594,8 @@ Xcos debug: objectUnreferenced( 61 , BLOCK ) : 2
        ans(2)
 GUI     : BIGSOM_f
 Graphics: 
-Xcos debug: objectReferenced( 65 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 65 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
           orig = [0,0]
           sz = [2,3]
           flip = %t
@@ -1584,8 +1615,8 @@ Xcos debug: objectUnreferenced( 65 , BLOCK ) : 2
           out_label = ""
           style = ""
 Model   : 
-Xcos debug: objectReferenced( 65 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 65 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
           sum type: 2
           in = [-1;-1]
           in2 = [1;1]
@@ -1619,220 +1650,37 @@ Link    :
           from: 1 1 0
           to: 2 1 1
 l = list(1); l(1) = scs_m; // Cloning 'scs_m'
-Xcos debug: objectDeleted( 38 , LINK )
-Xcos debug: objectCreated( 70 , DIAGRAM )
-Xcos trace: propertyUpdated( 70 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 70 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 70 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 70 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 70 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 70 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 71 , BLOCK )
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , INTERFACE_FUNCTION ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , GEOMETRY ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , EXPRS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , RPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectReferenced( 59 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 59 , BLOCK ) : 1
-Xcos debug: objectReferenced( 71 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 72 , DIAGRAM )
-Xcos trace: propertyUpdated( 72 , DIAGRAM , TITLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 72 , DIAGRAM , PATH ) : NO_CHANGES
-Xcos trace: propertyUpdated( 72 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
-Xcos trace: propertyUpdated( 72 , DIAGRAM , PROPERTIES ) : NO_CHANGES
-Xcos trace: propertyUpdated( 72 , DIAGRAM , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 72 , DIAGRAM , CONTEXT ) : NO_CHANGES
-Xcos debug: objectCreated( 73 , BLOCK )
-Xcos trace: propertyUpdated( 73 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 74 , PORT )
-Xcos trace: propertyUpdated( 74 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 74 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 74 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 74 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 74 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 74 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 74 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 74 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 74 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos debug: objectCreated( 75 , PORT )
-Xcos trace: propertyUpdated( 75 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 75 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 75 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 75 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 75 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 75 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 75 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 75 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 75 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , INPUTS ) : SUCCESS
-Xcos debug: objectCreated( 76 , PORT )
-Xcos trace: propertyUpdated( 76 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 76 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 76 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 76 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 76 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 76 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 76 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 76 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 76 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 73 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 77 , BLOCK )
-Xcos trace: propertyUpdated( 77 , BLOCK , SIM_FUNCTION_API ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , INTERFACE_FUNCTION ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , SIM_FUNCTION_NAME ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , GEOMETRY ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , ANGLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , EXPRS ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , STATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , DSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , RPAR ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , SIM_DEP_UT ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , EQUATIONS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos debug: objectCreated( 78 , PORT )
-Xcos trace: propertyUpdated( 78 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 78 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 78 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 78 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 78 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 78 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 78 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 78 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 78 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos debug: objectCreated( 79 , PORT )
-Xcos trace: propertyUpdated( 79 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 79 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 79 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 79 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 79 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 79 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 79 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 79 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 79 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , INPUTS ) : SUCCESS
-Xcos debug: objectCreated( 80 , PORT )
-Xcos trace: propertyUpdated( 80 , PORT , FIRING ) : NO_CHANGES
-Xcos trace: propertyUpdated( 80 , PORT , PORT_KIND ) : SUCCESS
-Xcos trace: propertyUpdated( 80 , PORT , IMPLICIT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 80 , PORT , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 80 , PORT , STYLE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 80 , PORT , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 80 , PORT , DATATYPE ) : SUCCESS
-Xcos trace: propertyUpdated( 80 , PORT , SOURCE_BLOCK ) : SUCCESS
-Xcos trace: propertyUpdated( 80 , PORT , CONNECTED_SIGNALS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , OUTPUTS ) : SUCCESS
-Xcos trace: propertyUpdated( 77 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 77 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectCreated( 81 , LINK )
-Xcos trace: propertyUpdated( 81 , LINK , COLOR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , KIND ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , UID ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , CONTROL_POINTS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , THICK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , PARENT_DIAGRAM ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , PARENT_BLOCK ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , SOURCE_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 81 , LINK , DESTINATION_PORT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 72 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 73 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 77 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 77 , BLOCK ) : 1
-Xcos trace: propertyUpdated( 81 , LINK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 81 , LINK ) : 1
-Xcos trace: propertyUpdated( 76 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 81 , LINK , SOURCE_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 78 , PORT , CONNECTED_SIGNALS ) : SUCCESS
-Xcos trace: propertyUpdated( 81 , LINK , DESTINATION_PORT ) : SUCCESS
-Xcos trace: propertyUpdated( 71 , BLOCK , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 73 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 73 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 77 , BLOCK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 77 , BLOCK ) : 2
-Xcos trace: propertyUpdated( 81 , LINK , PARENT_BLOCK ) : SUCCESS
-Xcos debug: objectReferenced( 81 , LINK ) : 2
-Xcos trace: propertyUpdated( 71 , BLOCK , IPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , OPAR ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_BLOCKTYPE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , SIM_DEP_UT ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , LABEL ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , NZCROSS ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , NMODE ) : NO_CHANGES
-Xcos trace: propertyUpdated( 71 , BLOCK , UID ) : NO_CHANGES
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 0
-Xcos trace: propertyUpdated( 70 , DIAGRAM , CHILDREN ) : SUCCESS
-Xcos trace: propertyUpdated( 71 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
-Xcos debug: objectReferenced( 71 , BLOCK ) : 1
+Xcos debug: objectDeleted( 40 , LINK )
+Xcos debug: objectCreated( 73 , DIAGRAM )
+Xcos trace: propertyUpdated( 73 , DIAGRAM , TITLE ) : NO_CHANGES
+Xcos trace: propertyUpdated( 73 , DIAGRAM , PATH ) : NO_CHANGES
+Xcos trace: propertyUpdated( 73 , DIAGRAM , VERSION_NUMBER ) : NO_CHANGES
+Xcos trace: propertyUpdated( 73 , DIAGRAM , PROPERTIES ) : NO_CHANGES
+Xcos trace: propertyUpdated( 73 , DIAGRAM , COLOR ) : NO_CHANGES
+Xcos trace: propertyUpdated( 73 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos trace: propertyUpdated( 73 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 60 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 60 , BLOCK ) : 2
 l(1).objs(1).model.rpar
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 74 , DIAGRAM )
+Xcos trace: propertyUpdated( 74 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 74 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
  ans  =
-Xcos debug: objectReferenced( 72 , DIAGRAM ) : 1
-Xcos debug: objectUnreferenced( 72 , DIAGRAM ) : 0
+Xcos debug: objectReferenced( 74 , DIAGRAM ) : 1
+Xcos debug: objectUnreferenced( 74 , DIAGRAM ) : 0
 wpar = [600,450,0,0,600,450]
 title = ["Untitled";""]
 tol = [0.000001,0.000001,1.000D-10,100001,0,1,0]
@@ -1843,17 +1691,48 @@ options = tlist(["scsopt","3D","Background","Link","ID","Cmap"],list(%t,33),[8,1
 void2 = []
 void3 = []
 doc = list()
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
 1     BIGSOM_f
 2     BIGSOM_f
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
 l(1).objs(1).model.rpar.objs
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 75 , DIAGRAM )
+Xcos trace: propertyUpdated( 75 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 75 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 3
+Xcos debug: objectReferenced( 66 , BLOCK ) : 3
+Xcos debug: objectReferenced( 70 , LINK ) : 3
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 70 , LINK ) : 2
+Xcos debug: objectDeleted( 75 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 74 , DIAGRAM )
  ans  =
        ans(1)
 GUI     : BIGSOM_f
 Graphics: 
-Xcos debug: objectReferenced( 73 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 73 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
           orig = [0,0]
           sz = [2,3]
           flip = %t
@@ -1873,8 +1752,8 @@ Xcos debug: objectUnreferenced( 73 , BLOCK ) : 2
           out_label = ""
           style = ""
 Model   : 
-Xcos debug: objectReferenced( 73 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 73 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
           sum type: 2
           in = [-1;-1]
           in2 = [1;1]
@@ -1901,8 +1780,8 @@ Xcos debug: objectUnreferenced( 73 , BLOCK ) : 2
        ans(2)
 GUI     : BIGSOM_f
 Graphics: 
-Xcos debug: objectReferenced( 77 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 77 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
           orig = [0,0]
           sz = [2,3]
           flip = %t
@@ -1922,8 +1801,8 @@ Xcos debug: objectUnreferenced( 77 , BLOCK ) : 2
           out_label = ""
           style = ""
 Model   : 
-Xcos debug: objectReferenced( 77 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 77 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
           sum type: 2
           in = [-1;-1]
           in2 = [1;1]
@@ -1957,28 +1836,175 @@ Link    :
           from: 1 1 0
           to: 2 1 1
 assert_checkequal(size(l(1).objs(1).model.rpar.objs), 3);
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 76 , DIAGRAM )
+Xcos trace: propertyUpdated( 76 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 76 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 3
+Xcos debug: objectReferenced( 66 , BLOCK ) : 3
+Xcos debug: objectReferenced( 70 , LINK ) : 3
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 70 , LINK ) : 2
+Xcos debug: objectDeleted( 76 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 70 , LINK ) : 0
 // Check connections
 assert_checkequal(l(1).objs(1).model.rpar.objs(1).graphics.pout,   3);
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
-Xcos debug: objectReferenced( 73 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 73 , BLOCK ) : 2
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 77 , DIAGRAM )
+Xcos trace: propertyUpdated( 77 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 77 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 77 , DIAGRAM )
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 70 , LINK ) : 0
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(2).graphics.pin(1), 3);
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
-Xcos debug: objectReferenced( 77 , BLOCK ) : 3
-Xcos debug: objectUnreferenced( 77 , BLOCK ) : 2
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 78 , DIAGRAM )
+Xcos trace: propertyUpdated( 78 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 78 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 78 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 70 , LINK ) : 0
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(3).from, [1 1 0]);
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 79 , DIAGRAM )
+Xcos trace: propertyUpdated( 79 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 79 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 79 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 70 , LINK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(3).from, [1 1 0]);
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 80 , DIAGRAM )
+Xcos trace: propertyUpdated( 80 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 80 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 80 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 70 , LINK ) : 0
 assert_checkequal(l(1).objs(1).model.rpar.objs(3).to,   [2 1 1]);
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectCreated( 81 , DIAGRAM )
+Xcos trace: propertyUpdated( 81 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 81 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 4
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
+Xcos debug: objectReferenced( 62 , BLOCK ) : 2
+Xcos debug: objectReferenced( 66 , BLOCK ) : 2
+Xcos debug: objectReferenced( 70 , LINK ) : 2
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 1
+Xcos debug: objectUnreferenced( 70 , LINK ) : 1
+Xcos debug: objectDeleted( 81 , DIAGRAM )
+Xcos debug: objectUnreferenced( 62 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 66 , BLOCK ) : 0
+Xcos debug: objectUnreferenced( 70 , LINK ) : 0
 // Clone a second time
 l2 = list(1); l2(1) = l(1); // Cloning 'l(1)', which is 'scs_m's clone
 Xcos debug: objectCreated( 82 , DIAGRAM )
@@ -2010,27 +2036,30 @@ Xcos trace: propertyUpdated( 83 , BLOCK , NMODE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , IPAR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , COLOR ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , EQUATIONS ) : NO_CHANGES
+Xcos trace: propertyUpdated( 83 , BLOCK , CONTEXT ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , PARENT_DIAGRAM ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , EVENT_INPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , EVENT_OUTPUTS ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , PARENT_BLOCK ) : NO_CHANGES
-Xcos debug: objectReferenced( 71 , BLOCK ) : 2
-Xcos debug: objectUnreferenced( 71 , BLOCK ) : 1
+Xcos debug: objectCreated( 84 , DIAGRAM )
+Xcos trace: propertyUpdated( 84 , DIAGRAM , CHILDREN ) : SUCCESS
+Xcos trace: propertyUpdated( 62 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 62 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 66 , BLOCK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 66 , BLOCK ) : 1
+Xcos trace: propertyUpdated( 70 , LINK , PARENT_DIAGRAM ) : SUCCESS
+Xcos debug: objectReferenced( 70 , LINK ) : 1
+Xcos trace: propertyUpdated( 84 , DIAGRAM , CONTEXT ) : NO_CHANGES
+Xcos debug: objectReferenced( 60 , BLOCK ) : 3
+Xcos debug: objectUnreferenced( 60 , BLOCK ) : 2
 Xcos debug: objectReferenced( 83 , BLOCK ) : 1
 Xcos trace: propertyUpdated( 83 , BLOCK , SIM_FUNCTION_NAME ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , SIM_FUNCTION_API ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , STATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , DSTATE ) : NO_CHANGES
 Xcos trace: propertyUpdated( 83 , BLOCK , ODSTATE ) : NO_CHANGES
-Xcos debug: objectCreated( 84 , DIAGRAM )
-Xcos trace: propertyUpdated( 84 , DIAGRAM , TITLE ) :