Debug

[modules/smesh.git] / src / SMESH_SWIG / smeshDC.py

diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py
index 4789415c96b2ac875e48a97c99d1d6f60d907771..559aa22ea86216551ebff68c2f3b65a6f34b2ca3 100644 (file)
--- a/src/SMESH_SWIG/smeshDC.py
+++ b/src/SMESH_SWIG/smeshDC.py
@@ -199,9 +199,6 @@ def DegreesToRadians(AngleInDegrees):
     from math import pi
     return AngleInDegrees * pi / 180.0
 
-# Salome notebook variable separator
-var_separator = ":"
-
 # Parametrized substitute for PointStruct
 class PointStructStr:
 
@@ -331,55 +328,89 @@ class DirStructStr:
     def __init__(self, pointStruct):
         self.pointStruct = pointStruct
 
+# Returns value of the parameter
+def ParseValue(Parameter, ConvertToRadians = False):
+    Result = Parameter
+    if isinstance(Parameter, str):
+        p = notebook.get(Parameter)
+        if p == None:
+            notebook.getNotebook().AddExpression(Parameter)
+            p = notebook.get(Parameter)
+        if ConvertToRadians:
+            p = DegreesToRadians(p)
+        Result = p
+    return Result
+
+# Returns the input parameter unchanged if it is a string or empty string otherwise
+def ParseString(Parameter):
+    Result = ""
+    if isinstance(Parameter, str):
+        Result = Parameter
+    return Result    
+
 # Returns list of variable values from salome notebook
 def ParsePointStruct(Point):
-    Parameters = 2*var_separator
+    Parameters = []
     if isinstance(Point, PointStructStr):
-        Parameters = str(Point.xStr) + var_separator + str(Point.yStr) + var_separator + str(Point.zStr)
-        Point = PointStruct(Point.x, Point.y, Point.z)
+        Parameters.append(ParseString(Point.xStr))
+        Parameters.append(ParseString(Point.yStr))
+        Parameters.append(ParseString(Point.zStr))
+        Point = PointStruct(ParseValue(Point.x),
+                            ParseValue(Point.y),
+                            ParseValue(Point.z))
     return Point, Parameters
 
 # Returns list of variable values from salome notebook
 def ParseDirStruct(Dir):
-    Parameters = 2*var_separator
+    Parameters = []
     if isinstance(Dir, DirStructStr):
         pntStr = Dir.pointStruct
         if isinstance(pntStr, PointStructStr6):
-            Parameters = str(pntStr.x1Str) + var_separator + str(pntStr.x2Str) + var_separator
-            Parameters += str(pntStr.y1Str) + var_separator + str(pntStr.y2Str) + var_separator 
-            Parameters += str(pntStr.z1Str) + var_separator + str(pntStr.z2Str)
-            Point = PointStruct(pntStr.x2 - pntStr.x1, pntStr.y2 - pntStr.y1, pntStr.z2 - pntStr.z1)
+            Parameters.append(ParseString(pntStr.x1Str))
+            Parameters.append(ParseString(pntStr.x2Str))
+            Parameters.append(ParseString(pntStr.y1Str))
+            Parameters.append(ParseString(pntStr.y2Str))
+            Parameters.append(ParseString(pntStr.z1Str))
+            Parameters.append(ParseString(pntStr.z2Str))
+            Point = PointStruct(ParseValue(pntStr.x2) - ParseValue(pntStr.x1),
+                                ParseValue(pntStr.y2) - ParseValue(pntStr.y1),
+                                ParseValue(pntStr.z2) - ParseValue(pntStr.z1))
         else:
-            Parameters = str(pntStr.xStr) + var_separator + str(pntStr.yStr) + var_separator + str(pntStr.zStr)
-            Point = PointStruct(pntStr.x, pntStr.y, pntStr.z)
+            Parameters.append(ParseString(pntStr.xStr))
+            Parameters.append(ParseString(pntStr.yStr))
+            Parameters.append(ParseString(pntStr.zStr))
+            Point = PointStruct(ParseValue(pntStr.x),
+                                ParseValue(pntStr.y),
+                                ParseValue(pntStr.z))
         Dir = DirStruct(Point)
     return Dir, Parameters
 
 # Returns list of variable values from salome notebook
 def ParseAxisStruct(Axis):
-    Parameters = 5*var_separator
+    Parameters = []
     if isinstance(Axis, AxisStructStr):
-        Parameters = str(Axis.xStr) + var_separator + str(Axis.yStr) + var_separator + str(Axis.zStr) + var_separator
-        Parameters += str(Axis.dxStr) + var_separator + str(Axis.dyStr) + var_separator + str(Axis.dzStr)
-        Axis = AxisStruct(Axis.x, Axis.y, Axis.z, Axis.dx, Axis.dy, Axis.dz)
+        Parameters.append(ParseString(Axis.xStr))
+        Parameters.append(ParseString(Axis.yStr))
+        Parameters.append(ParseString(Axis.zStr))
+        Parameters.append(ParseString(Axis.dxStr))
+        Parameters.append(ParseString(Axis.dyStr))
+        Parameters.append(ParseString(Axis.dzStr))
+        Axis = AxisStruct(ParseValue(Axis.x),
+                          ParseValue(Axis.y),
+                          ParseValue(Axis.z),
+                          ParseValue(Axis.dx),
+                          ParseValue(Axis.dy),
+                          ParseValue(Axis.dz))
     return Axis, Parameters
 
 ## Return list of variable values from salome notebook
 def ParseAngles(list):
     Result = []
-    Parameters = ""
+    Parameters = []
     for parameter in list:
-        if isinstance(parameter,str) and notebook.isVariable(parameter):
-            Result.append(DegreesToRadians(notebook.get(parameter)))
-            pass
-        else:
-            Result.append(parameter)
-            pass
-        
-        Parameters = Parameters + str(parameter)
-        Parameters = Parameters + var_separator
+        Result.append(ParseValue(parameter, True))
+        Parameters.append(ParseString(parameter))
         pass
-    Parameters = Parameters[:len(Parameters)-1]
     return Result, Parameters
     
 def IsEqual(val1, val2, tol=PrecisionConfusion):
@@ -651,7 +682,7 @@ class smeshDC(SMESH._objref_SMESH_Gen):
         else:
             aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
-        aSmeshMesh.SetParameters(Parameters)
+        geompyDC.SetParameters(aSmeshMesh, Parameters)
         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
         return aMesh
 
@@ -2039,7 +2070,7 @@ class Mesh:
     #  @ingroup l2_modif_add
     def AddNode(self, x, y, z):
         x,y,z,Parameters = geompyDC.ParseParameters(x,y,z)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         return self.editor.AddNode( x, y, z)
 
     ## Creates a 0D element on a node with given number.
@@ -2203,7 +2234,7 @@ class Mesh:
     #  @ingroup l2_modif_movenode
     def MoveNode(self, NodeID, x, y, z):
         x,y,z,Parameters = geompyDC.ParseParameters(x,y,z)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         return self.editor.MoveNode(NodeID, x, y, z)
 
     ## Finds the node closest to a point and moves it to a point location
@@ -2216,7 +2247,7 @@ class Mesh:
     #  @ingroup l2_modif_throughp
     def MoveClosestNodeToPoint(self, x, y, z, NodeID):
         x,y,z,Parameters = geompyDC.ParseParameters(x,y,z)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         return self.editor.MoveClosestNodeToPoint(x, y, z, NodeID)
 
     ## Finds the node closest to a point
@@ -2304,7 +2335,7 @@ class Mesh:
             MaxAngle = DegreesToRadians(MaxAngle)
         if IDsOfElements == []:
             IDsOfElements = self.GetElementsId()
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         Functor = 0
        if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ):
             Functor = theCriterion
@@ -2529,7 +2560,7 @@ class Mesh:
         if IDsOfElements == []:
             IDsOfElements = self.GetElementsId()
         MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes,
                                   MaxNbOfIterations, MaxAspectRatio, Method)
 
@@ -2563,7 +2594,7 @@ class Mesh:
         if IDsOfElements == []:
             IDsOfElements = self.GetElementsId()
         MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes,
                                             MaxNbOfIterations, MaxAspectRatio, Method)
 
@@ -2640,8 +2671,8 @@ class Mesh:
         if TotalAngle and NbOfSteps:
             AngleInRadians /= NbOfSteps
         NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance)
-        Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AxisParameters + AngleParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis,
                                                        AngleInRadians, NbOfSteps, Tolerance)
@@ -2675,8 +2706,8 @@ class Mesh:
         if TotalAngle and NbOfSteps:
             AngleInRadians /= NbOfSteps
         NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance)
-        Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AxisParameters + AngleParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians,
                                                              NbOfSteps, Tolerance)
@@ -2710,8 +2741,8 @@ class Mesh:
         if TotalAngle and NbOfSteps:
             AngleInRadians /= NbOfSteps
         NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance)
-        Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AxisParameters + AngleParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.RotationSweepObject1DMakeGroups(theObject, Axis, AngleInRadians,
                                                                NbOfSteps, Tolerance)
@@ -2745,8 +2776,8 @@ class Mesh:
         if TotalAngle and NbOfSteps:
             AngleInRadians /= NbOfSteps
         NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance)
-        Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AxisParameters + AngleParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.RotationSweepObject2DMakeGroups(theObject, Axis, AngleInRadians,
                                                              NbOfSteps, Tolerance)
@@ -2767,8 +2798,8 @@ class Mesh:
             StepVector = self.smeshpyD.GetDirStruct(StepVector)
         StepVector,StepVectorParameters = ParseDirStruct(StepVector)
         NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps)
-        Parameters = StepVectorParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = StepVectorParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps)
         self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)
@@ -2809,8 +2840,8 @@ class Mesh:
             StepVector = self.smeshpyD.GetDirStruct(StepVector)
         StepVector,StepVectorParameters = ParseDirStruct(StepVector)
         NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps)
-        Parameters = StepVectorParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = StepVectorParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps)
         self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps)
@@ -2830,8 +2861,8 @@ class Mesh:
             StepVector = self.smeshpyD.GetDirStruct(StepVector)
         StepVector,StepVectorParameters = ParseDirStruct(StepVector)
         NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps)
-        Parameters = StepVectorParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = StepVectorParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps)
         self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps)
@@ -2851,8 +2882,8 @@ class Mesh:
             StepVector = self.smeshpyD.GetDirStruct(StepVector)
         StepVector,StepVectorParameters = ParseDirStruct(StepVector)
         NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps)
-        Parameters = StepVectorParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = StepVectorParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps)
         self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps)
@@ -2886,8 +2917,10 @@ class Mesh:
         if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)):
             RefPoint = self.smeshpyD.GetPointStruct(RefPoint)
             pass
-        Parameters = AnglesParameters + var_separator + RefPointParameters
-        self.mesh.SetParameters(Parameters)
+        if ( isinstance( Path, Mesh )):
+            Path = Path.GetMesh()
+        Parameters = AnglesParameters + RefPointParameters
+        geompyDC.SetParameters(self.mesh, Parameters)
 
         if isinstance(Base,list):
             IDsOfElements = []
@@ -2898,6 +2931,7 @@ class Mesh:
                                                    HasRefPoint, RefPoint, MakeGroups, ElemType)
         else:
             if isinstance(Base,Mesh):
+                Base = Base.GetMesh()
                 return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart,
                                                           HasAngles, Angles, LinearVariation,
                                                           HasRefPoint, RefPoint, MakeGroups, ElemType)
@@ -2938,8 +2972,8 @@ class Mesh:
         if HasAngles and Angles and LinearVariation:
             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
             pass
-        Parameters = AnglesParameters + var_separator + RefPointParameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AnglesParameters + RefPointParameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh,
                                                             PathShape, NodeStart, HasAngles,
@@ -2979,8 +3013,8 @@ class Mesh:
         if HasAngles and Angles and LinearVariation:
             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
             pass
-        Parameters = AnglesParameters + var_separator + RefPointParameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AnglesParameters + RefPointParameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh,
                                                                   PathShape, NodeStart, HasAngles,
@@ -3021,8 +3055,8 @@ class Mesh:
         if HasAngles and Angles and LinearVariation:
             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
             pass
-        Parameters = AnglesParameters + var_separator + RefPointParameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AnglesParameters + RefPointParameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionAlongPathObject1DMakeGroups(theObject, PathMesh,
                                                                     PathShape, NodeStart, HasAngles,
@@ -3063,8 +3097,8 @@ class Mesh:
         if HasAngles and Angles and LinearVariation:
             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
             pass
-        Parameters = AnglesParameters + var_separator + RefPointParameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AnglesParameters + RefPointParameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if MakeGroups:
             return self.editor.ExtrusionAlongPathObject2DMakeGroups(theObject, PathMesh,
                                                                     PathShape, NodeStart, HasAngles,
@@ -3088,7 +3122,7 @@ class Mesh:
         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
         Mirror,Parameters = ParseAxisStruct(Mirror)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         if Copy and MakeGroups:
             return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType)
         self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)
@@ -3111,7 +3145,7 @@ class Mesh:
         Mirror,Parameters = ParseAxisStruct(Mirror)
         mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType,
                                           MakeGroups, NewMeshName)
-        mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(mesh, Parameters)
         return Mesh(self.smeshpyD,self.geompyD,mesh)
 
     ## Creates a symmetrical copy of the object
@@ -3129,7 +3163,7 @@ class Mesh:
         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
         Mirror,Parameters = ParseAxisStruct(Mirror)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         if Copy and MakeGroups:
             return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType)
         self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy)
@@ -3152,7 +3186,7 @@ class Mesh:
         Mirror,Parameters = ParseAxisStruct(Mirror)
         mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType,
                                                 MakeGroups, NewMeshName)
-        mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(mesh, Parameters)
         return Mesh( self.smeshpyD,self.geompyD,mesh )
 
     ## Translates the elements
@@ -3168,7 +3202,7 @@ class Mesh:
         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
             Vector = self.smeshpyD.GetDirStruct(Vector)
         Vector,Parameters = ParseDirStruct(Vector)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         if Copy and MakeGroups:
             return self.editor.TranslateMakeGroups(IDsOfElements, Vector)
         self.editor.Translate(IDsOfElements, Vector, Copy)
@@ -3188,7 +3222,7 @@ class Mesh:
             Vector = self.smeshpyD.GetDirStruct(Vector)
         Vector,Parameters = ParseDirStruct(Vector)
         mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName)
-        mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(mesh, Parameters)
         return Mesh ( self.smeshpyD, self.geompyD, mesh )
 
     ## Translates the object
@@ -3204,7 +3238,7 @@ class Mesh:
         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
             Vector = self.smeshpyD.GetDirStruct(Vector)
         Vector,Parameters = ParseDirStruct(Vector)
-        self.mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(self.mesh, Parameters)
         if Copy and MakeGroups:
             return self.editor.TranslateObjectMakeGroups(theObject, Vector)
         self.editor.TranslateObject(theObject, Vector, Copy)
@@ -3224,7 +3258,7 @@ class Mesh:
             Vector = self.smeshpyD.GetDirStruct(Vector)
         Vector,Parameters = ParseDirStruct(Vector)
         mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName)
-        mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(mesh, Parameters)
         return Mesh( self.smeshpyD, self.geompyD, mesh )
 
     ## Rotates the elements
@@ -3247,8 +3281,8 @@ class Mesh:
         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
             Axis = self.smeshpyD.GetAxisStruct(Axis)
         Axis,AxisParameters = ParseAxisStruct(Axis)
-        Parameters = AxisParameters + var_separator + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AxisParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if Copy and MakeGroups:
             return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians)
         self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy)
@@ -3274,10 +3308,10 @@ class Mesh:
         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
             Axis = self.smeshpyD.GetAxisStruct(Axis)
         Axis,AxisParameters = ParseAxisStruct(Axis)
-        Parameters = AxisParameters + var_separator + Parameters
+        Parameters = AxisParameters + Parameters
         mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians,
                                           MakeGroups, NewMeshName)
-        mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(mesh, Parameters)
         return Mesh( self.smeshpyD, self.geompyD, mesh )
 
     ## Rotates the object
@@ -3300,8 +3334,8 @@ class Mesh:
         if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)):
             Axis = self.smeshpyD.GetAxisStruct(Axis)
         Axis,AxisParameters = ParseAxisStruct(Axis)
-        Parameters = AxisParameters + ":" + Parameters
-        self.mesh.SetParameters(Parameters)
+        Parameters = AxisParameters + Parameters
+        geompyDC.SetParameters(self.mesh, Parameters)
         if Copy and MakeGroups:
             return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians)
         self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy)
@@ -3327,10 +3361,10 @@ class Mesh:
         if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)):
             Axis = self.smeshpyD.GetAxisStruct(Axis)
         Axis,AxisParameters = ParseAxisStruct(Axis)
-        Parameters = AxisParameters + ":" + Parameters
+        Parameters = AxisParameters + Parameters
         mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians,
                                                        MakeGroups, NewMeshName)
-        mesh.SetParameters(Parameters)
+        geompyDC.SetParameters(mesh, Parameters)
         return Mesh( self.smeshpyD, self.geompyD, mesh )
 
     ## Finds groups of ajacent nodes within Tolerance.
@@ -5098,29 +5132,21 @@ import salome_notebook
 notebook = salome_notebook.notebook
 
 ##Return values of the notebook variables
-def ParseParameters(last, nbParams,nbParam, value):
+def ParseParameters(last, nbParams, nbParam, value):
+    #print "ParseParameters", last, nbParams, nbParam, value
     result = None
-    strResult = ""
+    strResult = []
     counter = 0
     listSize = len(last)
     for n in range(0,nbParams):
         if n+1 != nbParam:
             if counter < listSize:
-                strResult = strResult + last[counter]
+                strResult.append( last[counter] )
             else:
-                strResult = strResult + ""
+                strResult = strResult
         else:
-            if isinstance(value, str):
-                if notebook.isVariable(value):
-                    result = notebook.get(value)
-                    strResult=strResult+value
-                else:
-                    raise RuntimeError, "Variable with name '" + value + "' doesn't exist!!!"
-            else:
-                strResult=strResult+str(value)
-                result = value
-        if nbParams - 1 != counter:
-            strResult=strResult+var_separator #":"
+            strResult.append(ParseString(value))
+            result = ParseValue(value)
         counter = counter+1
     return result, strResult
 
@@ -5130,15 +5156,15 @@ class LocalLength(StdMeshers._objref_StdMeshers_LocalLength):
     ## Set Length parameter value
     #  @param length numerical value or name of variable from notebook
     def SetLength(self, length):
-        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetLastParameters(self),2,1,length)
-        StdMeshers._objref_StdMeshers_LocalLength.SetParameters(self,parameters)
+        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetParameters(self),2,1,length)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_LocalLength.SetLength(self,length)
 
    ## Set Precision parameter value
    #  @param precision numerical value or name of variable from notebook
     def SetPrecision(self, precision):
-        precision,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetLastParameters(self),2,2,precision)
-        StdMeshers._objref_StdMeshers_LocalLength.SetParameters(self,parameters)
+        precision,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetParameters(self),2,2,precision)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_LocalLength.SetPrecision(self, precision)
 
 #Registering the new proxy for LocalLength
@@ -5149,21 +5175,32 @@ omniORB.registerObjref(StdMeshers._objref_StdMeshers_LocalLength._NP_RepositoryI
 class LayerDistribution(StdMeshers._objref_StdMeshers_LayerDistribution):
     
     def SetLayerDistribution(self, hypo):
-        StdMeshers._objref_StdMeshers_LayerDistribution.SetParameters(self,hypo.GetParameters())
-        hypo.ClearParameters();
+        geompyDC.SetParameters(self, hypo.GetParameters())
+        geompyDC.SetParameters(hypo, [])
         StdMeshers._objref_StdMeshers_LayerDistribution.SetLayerDistribution(self,hypo)
 
 #Registering the new proxy for LayerDistribution
 omniORB.registerObjref(StdMeshers._objref_StdMeshers_LayerDistribution._NP_RepositoryId, LayerDistribution)
 
+#Wrapper class for StdMeshers_LayerDistribution2D hypothesis
+class LayerDistribution2D(StdMeshers._objref_StdMeshers_LayerDistribution2D):
+    
+    def SetLayerDistribution(self, hypo):
+        geompyDC.SetParameters(self, hypo.GetParameters())
+        geompyDC.SetParameters(hypo, [])
+        StdMeshers._objref_StdMeshers_LayerDistribution2D.SetLayerDistribution(self,hypo)
+
+#Registering the new proxy for LayerDistribution
+omniORB.registerObjref(StdMeshers._objref_StdMeshers_LayerDistribution2D._NP_RepositoryId, LayerDistribution2D)
+
 #Wrapper class for StdMeshers_SegmentLengthAroundVertex hypothesis
 class SegmentLengthAroundVertex(StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex):
     
     ## Set Length parameter value
     #  @param length numerical value or name of variable from notebook    
     def SetLength(self, length):
-        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.GetLastParameters(self),1,1,length)
-        StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.SetParameters(self,parameters)
+        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.GetParameters(self),1,1,length)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.SetLength(self,length)
 
 #Registering the new proxy for SegmentLengthAroundVertex
@@ -5180,9 +5217,23 @@ class Arithmetic1D(StdMeshers._objref_StdMeshers_Arithmetic1D):
         nb = 2
         if isStart:
             nb = 1
-        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetLastParameters(self),2,nb,length)
-        StdMeshers._objref_StdMeshers_Arithmetic1D.SetParameters(self,parameters)
+        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetParameters(self),2,nb,length)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_Arithmetic1D.SetLength(self,length,isStart)
+
+    ## Set Start Length parameter value
+    #  @param length numerical value or name of variable from notebook
+    def SetStartLength(self, length):
+        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetParameters(self),2,1,length)
+        geompyDC.SetParameters(self, parameters)
+        StdMeshers._objref_StdMeshers_Arithmetic1D.SetStartLength(self,length)
+
+   ## Set End Length parameter value
+   #  @param length numerical value or name of variable from notebook
+    def SetEndLength(self, length):
+        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetParameters(self),2,2,length)
+        geompyDC.SetParameters(self, parameters)
+        StdMeshers._objref_StdMeshers_Arithmetic1D.SetEndLength(self,length)
         
 #Registering the new proxy for Arithmetic1D
 omniORB.registerObjref(StdMeshers._objref_StdMeshers_Arithmetic1D._NP_RepositoryId, Arithmetic1D)
@@ -5193,8 +5244,8 @@ class Deflection1D(StdMeshers._objref_StdMeshers_Deflection1D):
     ## Set Deflection parameter value
     #  @param deflection numerical value or name of variable from notebook    
     def SetDeflection(self, deflection):
-        deflection,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Deflection1D.GetLastParameters(self),1,1,deflection)
-        StdMeshers._objref_StdMeshers_Deflection1D.SetParameters(self,parameters)
+        deflection,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Deflection1D.GetParameters(self),1,1,deflection)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_Deflection1D.SetDeflection(self,deflection)
 
 #Registering the new proxy for Deflection1D
@@ -5210,8 +5261,8 @@ class StartEndLength(StdMeshers._objref_StdMeshers_StartEndLength):
         nb = 2
         if isStart:
             nb = 1
-        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_StartEndLength.GetLastParameters(self),2,nb,length)
-        StdMeshers._objref_StdMeshers_StartEndLength.SetParameters(self,parameters)
+        length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_StartEndLength.GetParameters(self),2,nb,length)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_StartEndLength.SetLength(self,length,isStart)
         
 #Registering the new proxy for StartEndLength
@@ -5223,8 +5274,8 @@ class MaxElementArea(StdMeshers._objref_StdMeshers_MaxElementArea):
     ## Set Max Element Area parameter value
     #  @param area  numerical value or name of variable from notebook
     def SetMaxElementArea(self, area):
-        area ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementArea.GetLastParameters(self),1,1,area)
-        StdMeshers._objref_StdMeshers_MaxElementArea.SetParameters(self,parameters)
+        area ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementArea.GetParameters(self),1,1,area)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_MaxElementArea.SetMaxElementArea(self,area)
         
 #Registering the new proxy for MaxElementArea
@@ -5237,8 +5288,8 @@ class MaxElementVolume(StdMeshers._objref_StdMeshers_MaxElementVolume):
     ## Set Max Element Volume parameter value
     #  @param volume numerical value or name of variable from notebook
     def SetMaxElementVolume(self, volume):
-        volume ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementVolume.GetLastParameters(self),1,1,volume)
-        StdMeshers._objref_StdMeshers_MaxElementVolume.SetParameters(self,parameters)
+        volume ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementVolume.GetParameters(self),1,1,volume)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_MaxElementVolume.SetMaxElementVolume(self,volume)
         
 #Registering the new proxy for MaxElementVolume
@@ -5251,29 +5302,42 @@ class NumberOfLayers(StdMeshers._objref_StdMeshers_NumberOfLayers):
     ## Set Number Of Layers parameter value
     #  @param nbLayers  numerical value or name of variable from notebook
     def SetNumberOfLayers(self, nbLayers):
-        nbLayers ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfLayers.GetLastParameters(self),1,1,nbLayers)
-        StdMeshers._objref_StdMeshers_NumberOfLayers.SetParameters(self,parameters)
+        nbLayers ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfLayers.GetParameters(self),1,1,nbLayers)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_NumberOfLayers.SetNumberOfLayers(self,nbLayers)
         
 #Registering the new proxy for NumberOfLayers
 omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfLayers._NP_RepositoryId, NumberOfLayers)
 
+#Wrapper class for StdMeshers_NumberOfLayers2D hypothesis
+class NumberOfLayers2D(StdMeshers._objref_StdMeshers_NumberOfLayers2D):
+    
+    ## Set Number Of Layers parameter value
+    #  @param nbLayers  numerical value or name of variable from notebook
+    def SetNumberOfLayers(self, nbLayers):
+        nbLayers ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfLayers2D.GetParameters(self),1,1,nbLayers)
+        geompyDC.SetParameters(self, parameters)
+        StdMeshers._objref_StdMeshers_NumberOfLayers2D.SetNumberOfLayers(self,nbLayers)
+        
+#Registering the new proxy for NumberOfLayers2D
+omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfLayers2D._NP_RepositoryId, NumberOfLayers2D)
+
 #Wrapper class for StdMeshers_NumberOfSegments hypothesis
 class NumberOfSegments(StdMeshers._objref_StdMeshers_NumberOfSegments):
     
     ## Set Number Of Segments parameter value
     #  @param nbSeg numerical value or name of variable from notebook
     def SetNumberOfSegments(self, nbSeg):
-        lastParameters = StdMeshers._objref_StdMeshers_NumberOfSegments.GetLastParameters(self)
+        lastParameters = StdMeshers._objref_StdMeshers_NumberOfSegments.GetParameters(self)
         nbSeg , parameters = ParseParameters(lastParameters,1,1,nbSeg)
-        StdMeshers._objref_StdMeshers_NumberOfSegments.SetParameters(self,parameters)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_NumberOfSegments.SetNumberOfSegments(self,nbSeg)
         
     ## Set Scale Factor parameter value
     #  @param factor numerical value or name of variable from notebook
     def SetScaleFactor(self, factor):
-        factor, parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfSegments.GetLastParameters(self),2,2,factor)
-        StdMeshers._objref_StdMeshers_NumberOfSegments.SetParameters(self,parameters)
+        factor, parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfSegments.GetParameters(self),2,2,factor)
+        geompyDC.SetParameters(self, parameters)
         StdMeshers._objref_StdMeshers_NumberOfSegments.SetScaleFactor(self,factor)
         
 #Registering the new proxy for NumberOfSegments
@@ -5286,33 +5350,33 @@ if not noNETGENPlugin:
         ## Set Max Size parameter value
         #  @param maxsize numerical value or name of variable from notebook
         def SetMaxSize(self, maxsize):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self)
             maxsize, parameters = ParseParameters(lastParameters,4,1,maxsize)
-            NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetMaxSize(self,maxsize)
 
         ## Set Growth Rate parameter value
         #  @param value  numerical value or name of variable from notebook
         def SetGrowthRate(self, value):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self)
             value, parameters = ParseParameters(lastParameters,4,2,value)
-            NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetGrowthRate(self,value)
 
         ## Set Number of Segments per Edge parameter value
         #  @param value  numerical value or name of variable from notebook
         def SetNbSegPerEdge(self, value):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self)
             value, parameters = ParseParameters(lastParameters,4,3,value)
-            NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerEdge(self,value)
 
         ## Set Number of Segments per Radius parameter value
         #  @param value  numerical value or name of variable from notebook
         def SetNbSegPerRadius(self, value):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self)
             value, parameters = ParseParameters(lastParameters,4,4,value)
-            NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerRadius(self,value)
 
     #Registering the new proxy for NETGENPlugin_Hypothesis
@@ -5332,32 +5396,32 @@ if not noNETGENPlugin:
         ## Set Number of Segments parameter value
         #  @param nbSeg numerical value or name of variable from notebook
         def SetNumberOfSegments(self, nbSeg):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self)
             nbSeg, parameters = ParseParameters(lastParameters,2,1,nbSeg)
-            NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetNumberOfSegments(self, nbSeg)
 
         ## Set Local Length parameter value
         #  @param length numerical value or name of variable from notebook
         def SetLocalLength(self, length):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self)
             length, parameters = ParseParameters(lastParameters,2,1,length)
-            NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetLocalLength(self, length)
 
         ## Set Max Element Area parameter value
         #  @param area numerical value or name of variable from notebook    
         def SetMaxElementArea(self, area):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self)
             area, parameters = ParseParameters(lastParameters,2,2,area)
-            NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetMaxElementArea(self, area)
 
         def LengthFromEdges(self):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self)
             value = 0;
             value, parameters = ParseParameters(lastParameters,2,2,value)
-            NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.LengthFromEdges(self)
 
     #Registering the new proxy for NETGEN_SimpleParameters_2D
@@ -5369,16 +5433,16 @@ if not noNETGENPlugin:
         ## Set Max Element Volume parameter value
         #  @param volume numerical value or name of variable from notebook    
         def SetMaxElementVolume(self, volume):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetParameters(self)
             volume, parameters = ParseParameters(lastParameters,3,3,volume)
-            NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetMaxElementVolume(self, volume)
 
         def LengthFromFaces(self):
-            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self)
+            lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetParameters(self)
             value = 0;
             value, parameters = ParseParameters(lastParameters,3,3,value)
-            NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters)
+            geompyDC.SetParameters(self, parameters)
             NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.LengthFromFaces(self)
 
     #Registering the new proxy for NETGEN_SimpleParameters_3D
@@ -5395,7 +5459,7 @@ class Pattern(SMESH._objref_SMESH_Pattern):
         theNodeIndexOnKeyPoint1,Parameters = geompyDC.ParseParameters(theNodeIndexOnKeyPoint1)
         if flag:
             theNodeIndexOnKeyPoint1 -= 1
-        theMesh.SetParameters(Parameters)
+        geompyDC.SetParameters(theMesh, Parameters)
         return SMESH._objref_SMESH_Pattern.ApplyToMeshFaces( self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse )
 
     def ApplyToHexahedrons(self, theMesh, theVolumesIDs, theNode000Index, theNode001Index):
@@ -5410,7 +5474,7 @@ class Pattern(SMESH._objref_SMESH_Pattern):
             theNode000Index -= 1
         if flag1:
             theNode001Index -= 1
-        theMesh.SetParameters(Parameters)
+        geompyDC.SetParameters(theMesh, Parameters)
         return SMESH._objref_SMESH_Pattern.ApplyToHexahedrons( self, theMesh, theVolumesIDs, theNode000Index, theNode001Index )
 
 #Registering the new proxy for Pattern