Salome HOME
Merge V9_dev branch into master
authorrnv <rnv@opencascade.com>
Thu, 14 Jun 2018 11:56:19 +0000 (14:56 +0300)
committerrnv <rnv@opencascade.com>
Thu, 14 Jun 2018 11:56:19 +0000 (14:56 +0300)
104 files changed:
1  2 
CMakeLists.txt
doc/salome/examples/defining_hypotheses_ex13.py
doc/salome/gui/SMESH/collect_mesh_methods.py
doc/salome/gui/SMESH/input/smesh_migration.rst
doc/salome/gui/SMESH/merge_mesh_class.py
idl/SMESH_Mesh.idl
src/DriverMED/CMakeLists.txt
src/DriverMED/DriverMED_Family.cxx
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_W_Field.cxx
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_W_SMESHDS_Mesh.h
src/SMESH/CMakeLists.txt
src/SMESH/SMESH_Algo.cxx
src/SMESH/SMESH_Algo.hxx
src/SMESH/SMESH_Gen.cxx
src/SMESH/SMESH_Hypothesis.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESHClient/CMakeLists.txt
src/SMESHGUI/CMakeLists.txt
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI_Add0DElemsOnAllNodesDlg.cxx
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
src/SMESHGUI/SMESHGUI_BuildCompoundDlg.cxx
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
src/SMESHGUI/SMESHGUI_CopyMeshDlg.cxx
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
src/SMESHGUI/SMESHGUI_DeleteGroupDlg.cxx
src/SMESHGUI/SMESHGUI_DisplayEntitiesDlg.cxx
src/SMESHGUI/SMESHGUI_DuplicateNodesDlg.cxx
src/SMESHGUI/SMESHGUI_ExtrusionAlongPathDlg.cxx
src/SMESHGUI/SMESHGUI_ExtrusionDlg.cxx
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
src/SMESHGUI/SMESHGUI_FindElemByPointDlg.cxx
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
src/SMESHGUI/SMESHGUI_GroupOnShapeDlg.cxx
src/SMESHGUI/SMESHGUI_GroupOpDlg.cxx
src/SMESHGUI/SMESHGUI_Hypotheses.cxx
src/SMESHGUI/SMESHGUI_Make2DFrom3DOp.cxx
src/SMESHGUI/SMESHGUI_MakeNodeAtPointDlg.cxx
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
src/SMESHGUI/SMESHGUI_MeshOp.cxx
src/SMESHGUI/SMESHGUI_MeshOrderOp.cxx
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
src/SMESHGUI/SMESHGUI_OffsetDlg.cxx
src/SMESHGUI/SMESHGUI_Operation.h
src/SMESHGUI/SMESHGUI_RemoveElementsDlg.cxx
src/SMESHGUI/SMESHGUI_RemoveNodesDlg.cxx
src/SMESHGUI/SMESHGUI_RenumberingDlg.cxx
src/SMESHGUI/SMESHGUI_ReorientFacesDlg.cxx
src/SMESHGUI/SMESHGUI_RevolutionDlg.cxx
src/SMESHGUI/SMESHGUI_RotationDlg.cxx
src/SMESHGUI/SMESHGUI_ScaleDlg.cxx
src/SMESHGUI/SMESHGUI_Selection.cxx
src/SMESHGUI/SMESHGUI_SelectionOp.cxx
src/SMESHGUI/SMESHGUI_SewingDlg.cxx
src/SMESHGUI/SMESHGUI_SingleEditDlg.cxx
src/SMESHGUI/SMESHGUI_SmoothingDlg.cxx
src/SMESHGUI/SMESHGUI_SplitBiQuad.cxx
src/SMESHGUI/SMESHGUI_SymmetryDlg.cxx
src/SMESHGUI/SMESHGUI_TranslationDlg.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.h
src/SMESHGUI/SMESH_msg_en.ts
src/SMESHGUI/SMESH_msg_fr.ts
src/SMESHGUI/SMESH_msg_ja.ts
src/SMESH_I/CMakeLists.txt
src/SMESH_I/SMESH_2smeshpy.cxx
src/SMESH_I/SMESH_Gen_i.cxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Gen_i_1.cxx
src/SMESH_I/SMESH_MeshEditor_i.cxx
src/SMESH_I/SMESH_Mesh_i.cxx
src/SMESH_I/SMESH_PreMeshInfo.cxx
src/SMESH_I/SMESH_PythonDump.hxx
src/SMESH_SWIG/StdMeshersBuilder.py
src/SMESH_SWIG/smeshBuilder.py
src/SMESH_SWIG/smesh_algorithm.py
src/SMESH_SWIG_WITHIHM/CMakeLists.txt
src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx
src/SMESH_SWIG_WITHIHM/libSMESH_Swig.h
src/SMESH_SWIG_WITHIHM/libSMESH_Swig.i
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx
src/StdMeshers/StdMeshers_Import_1D2D.cxx
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
src/StdMeshers/StdMeshers_Prism_3D.cxx
src/StdMeshers/StdMeshers_Projection_1D2D.cxx
src/StdMeshers/StdMeshers_Projection_2D.cxx
src/StdMeshers/StdMeshers_Projection_3D.cxx
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx
src/StdMeshers/StdMeshers_ViscousLayers.cxx
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
src/StdMeshersGUI/CMakeLists.txt
src/Tools/MGCleanerPlug/MGCleanerMonPlugDialog.py
src/Tools/MacMesh/MacMesh/PublishGroups.py
src/Tools/padder/spadderpy/gui/plugindialog.py

diff --cc CMakeLists.txt
Simple merge
  # variables are set properly; otherwise the script will fail.
  #
  ################################################################################
+ import inspect
  import sys
  
 -def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py"):
 +def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py", format = "doxygen"):
      plugin_module_name  = plugin_name + "Builder"
      plugin_module       = "salome.%s.%s" % (plugin_name, plugin_module_name)
      try:
          if methods:
              output = []
              if dummymeshhelp:
-               if format == "doxygen":
 -                output.append( "## @package smeshBuilder" )
 -                output.append( "#  Documentation of the methods dynamically added by the " + plugin_name + " meshing plug-in to the Mesh class." )
 -                output.append( "" )
++                if format == "doxygen":
 +                    output.append( "## @package smeshBuilder" )
 +                    output.append( "#  Documentation of the methods dynamically added by the " + plugin_name + " meshing plug-in to the Mesh class." )
 +                    output.append( "" )
 +                elif format == "sphinx":
 +                    output.append( '"""' )
 +                    output.append( 'Documentation of the methods dynamically added by the ' + plugin_name + ' meshing plug-in to the Mesh class.' )
 +                    output.append( '"""' )
 +                    output.append( '' )
                  pass
 -            output.append( "## This class allows defining and managing a mesh." )
 -            output.append( "#" )
 +            if format == "doxygen":
 +                output.append( "## This class allows defining and managing a mesh." )
 +                output.append( "#" )
 +            elif format == "sphinx":
 +                output.append( "class Mesh:" )
 +                output.append( '    """' )
 +                output.append( '    This class allows defining and managing a mesh.' )
 +                output.append( '    ' )
              if dummymeshhelp:
                  # Add dummy Mesh help
                  # This is supposed to be done when generating documentation for meshing plug-ins
 -                output.append( "#  @note The documentation below does not provide complete description of class @b %Mesh" )
 -                output.append( "#  from @b smeshBuilder package. This documentation provides only information about" )
 -                output.append( "#  the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin" )
 -                output.append( "#  For more details on the %Mesh class, please refer to the SALOME %Mesh module" )
 -                output.append( "#  documentation." )
 +                if format == "doxygen":
-                   output.append( "#  @note The documentation below does not provide complete description of class @b %Mesh" )
++                    output.append( "#  @note The documentation below does not provide complete description of class @b %Mesh" )
 +                    output.append( "#  from @b smeshBuilder package. This documentation provides only information about" )
 +                    output.append( "#  the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin" )
 +                    output.append( "#  For more details on the %Mesh class, please refer to the SALOME %Mesh module" )
 +                    output.append( "#  documentation." )
 +                elif format == "sphinx":
 +                    output.append( '    The documentation below does not provide complete description of class @b %Mesh' )
 +                    output.append( '    from @b smeshBuilder package. This documentation provides only information about' )
 +                    output.append( '    the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin' )
 +                    output.append( '    For more details on the %Mesh class, please refer to the SALOME %Mesh module' )
 +                    output.append( '    documentation.' )
 +                    output.append( '    """' )
 +                    output.append( '    ' )
                  pass
              else:
                  # Extend documentation for Mesh class with information about dynamically added methods.
                  # This is supposed to be done only when building documentation for SMESH module
 -                output.append( "#  @note Some methods are dynamically added to the @b %Mesh class in runtime by meshing " )
 -                output.append( "#  plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
 -                output.append( "#  try to look into the documentation for the meshing plug-ins." )
 +                if format ==  "doxygen":
 +                    output.append( "#  @note Some methods are dynamically added to the @b %Mesh class in runtime by meshing " )
-                   output.append( "#  plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
-                   output.append( "#  try to look into the documentation for the meshing plug-ins." )
-               elif format == "sphinx":
++                    output.append( "#  plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
++                    output.append( "#  try to look into the documentation for the meshing plug-ins." )
++                elif format == "sphinx":
 +                    output.append( "    Note:")
 +                    output.append( "        Some methods are dynamically added to the @b %Mesh class in runtime by meshing " )
-                   output.append( "        plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
-                   output.append( "        try to look into the documentation for the meshing plug-ins." )
++                    output.append( "        plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
++                    output.append( "        try to look into the documentation for the meshing plug-ins." )
 +                    output.append( '    """' )
 +                    output.append( '    ' )
                  pass
 -            output.append( "class Mesh:" )
 +            if format == "doxygen":
 +                output.append( "class Mesh:" )
              for method in methods:
                  docHelper = ""
                  for algo in methods[ method ]:
                      if docHelper: break
                      pass
                  if not docHelper: docHelper = "Creates new algorithm."
 -                output.append( "  ## %s" % docHelper )
 -                output.append( "  #" )
 -                output.append( "  #  This method is dynamically added to %Mesh class by the meshing plug-in(s). " )
 -                output.append( "  #" )
 -                output.append( "  #  If the optional @a geom_shape parameter is not set, this algorithm is global (applied to whole mesh)." )
 -                output.append( "  #  Otherwise, this algorithm defines a submesh based on @a geom_shape subshape." )
 -                output.append( "  #  @param algo_type type of algorithm to be created; allowed values are specified by classes implemented by plug-in (see below)" )
 -                output.append( "  #  @param geom_shape if defined, the subshape to be meshed (GEOM_Object)" )
 -                output.append( "  #  @return An instance of Mesh_Algorithm sub-class according to the specified @a algo_type, see " )
 -                output.append( "  #  %s" % ", ".join( [ "%s.%s" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) )
 -                output.append( "  def %s(algo_type, geom_shape=0):" % method )
 -                output.append( "    pass" )
 +                if format == "doxygen":
 +                    output.append( " ## %s" % docHelper )
 +                    output.append( " #" )
 +                    output.append( " #  This method is dynamically added to %Mesh class by the meshing plug-in(s). " )
 +                    output.append( " #" )
 +                    output.append( " #  If the optional @a geom_shape parameter is not set, this algorithm is global (applied to whole mesh)." )
 +                    output.append( " #  Otherwise, this algorithm defines a submesh based on @a geom_shape subshape." )
 +                    output.append( " #  @param algo_type type of algorithm to be created; allowed values are specified by classes implemented by plug-in" )
 +                    output.append( " #  @param geom_shape if defined, the subshape to be meshed (GEOM_Object)" )
 +                    output.append( " #  @return An instance of Mesh_Algorithm sub-class according to the specified @a algo_type, see " )
 +                    output.append( " #  %s" % ", ".join( [ "%s.%s" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) )
 +                    output.append( " def %s(algo_type, geom_shape=0):" % method )
 +                    output.append( "   pass" )
 +                elif format == "sphinx":
 +                    output.append( '    def %s(algo_type, geom_shape=0):' % method )
 +                    output.append( '        """' )
 +                    output.append( '        %s' % docHelper )
 +                    output.append( '        ' )
 +                    output.append( '        This method is dynamically added to :class:`Mesh <smeshBuilder.Mesh>` class by the meshing plug-in(s). ' )
 +                    output.append( '        ' )
 +                    output.append( '        If the optional *geom_shape* parameter is not set, this algorithm is global (applied to whole mesh).' )
 +                    output.append( '        Otherwise, this algorithm defines a submesh based on *geom_shape* subshape.' )
 +                    output.append( '        ' )
 +                    output.append( '        Parameters:' )
 +                    output.append( '            algo_type: type of algorithm to be created; allowed values are specified by classes implemented by plug-in' )
 +                    output.append( '            geom_shape (GEOM_Object): if defined, the subshape to be meshed' )
 +                    output.append( '        ' )
 +                    output.append( '        Returns:')
 +                    output.append( '            An instance of Mesh_Algorithm sub-class according to the specified *algo_type*, see ' )
 +                    output.append( '            %s' % ", ".join( [ ":class:`~%s.%s`" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) )
 +                    output.append( '        """' )
 +                    output.append( '        pass' )
                  pass
-             f = open(output_file, "w")
-             for line in output: f.write( line + "\n" )
-             f.close()
+             with open(output_file, "w", encoding='utf8') as f:
+                 f.write('\n'.join(output))
              pass
          pass
-     except Exception, e:
-         print e
+     except Exception as e:
+         print(e)
          pass
      pass
      
@@@ -180,17 -130,11 +180,20 @@@ if __name__ == "__main__"
      h  = "If this option is True, dummy help for Mesh class is added. "
      h += "This option should be False (default) when building documentation for SMESH module "
      h += "and True when building documentation for meshing plug-ins."
-     parser.add_option("-d", "--dummy-mesh-help", dest="dummymeshhelp",
+     parser.add_argument("-d", "--dummy-mesh-help", dest="dummymeshhelp",
                        action="store_true", default=False,
                        help=h)
 -    parser.add_argument("plugin", help='Name of plugin')
 +    h = "Format of the documentation strings in the output file. Possible values are: "
 +    h+= "'doxygen' - documentation strings are generated in the doxygen format, before a method defenition."
 +    h+= "'sphinx' - documentation strings are generated in the sphinx format, after a method defenition."
-     parser.add_option("-f", "--format", dest="format",
++    parser.add_argument("-f", "--format", dest="format",
 +                      action="store", default="doxygen", help=h)
 +
-     (options, args) = parser.parse_args()
++    parser.add_argument("plugin_name")
++
++
+     args = parser.parse_args()
  
-     if len( args ) < 1: sys.exit("Plugin name is not specified")
-     main( args[0], options.dummymeshhelp, options.output, options.format )
 -    main( args.plugin, args.dummymeshhelp, args.output )
++    if args.plugin_name is None : sys.exit("Plugin name is not specified")
++    main( args.plugin_name, args.dummymeshhelp, args.output, args.format )
      pass
index 5a22024,0000000..59487da
mode 100644,000000..100644
--- /dev/null
@@@ -1,105 -1,0 +1,105 @@@
- *****************************************************
- Modifing Mesh Python scripts from SALOME 6 and before
- *****************************************************
 +.. _smesh_migration_page:
 +
-       smesh =  smeshBuilder.New(salome.myStudy)
++******************************************************
++Modifying Mesh Python scripts from SALOME 6 and before
++******************************************************
 +
 +In SALOME 7.2, the Python interface for Mesh has been slightly modified to offer new functionality:
 +
 +
 +Scripts generated for SALOME 6 and older versions must be adapted to work in SALOME 7.2 with full functionality.
 +The compatibility mode allows old scripts to work in almost all cases, but with a warning.
 +
 +* **Salome initialisation** must always be done as shown below.
 +
 +  (*salome_init()* can be invoked safely several times)::
 +
 +      import salome
 +      salome.salome_init()
 +
 +* **smesh initialisation** is modified.
 +
 +  The old mode (from dump)::
 +
 +      import smesh, SMESH, SALOMEDS
 +      smesh.SetCurrentStudy(salome.myStudy)
 +
 +  The new mode::
 +
 +      import SMESH, SALOMEDS
 +      from salome.smesh import smeshBuilder
-   You have to explicitely write *smesh.some_method()*.
++      smesh =  smeshBuilder.New()
 +
 +
 +* Of course, **from smesh import** * is **no more possible.**
 +
- * If you need to **import a SMESH Plugin** explicitely, keep in mind that  they are now located in separate namespaces.
++  You have to explicitly write *smesh.some_method()*.
 +
 +* All **algorithms** have been transferred from the namespace *smesh* to the namespace *smeshBuilder*.
 +
 +  For instance::
 +
 +      MEFISTO_2D_1 = Mesh_1.Triangle(algo=smesh.MEFISTO,geom=Face_1)
 +
 +  is replaced by::
 +
 +      MEFISTO_2D_1 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_1)
 +
 +  StdMeshers algorithms concerned are *REGULAR, PYTHON, COMPOSITE, MEFISTO, Hexa, QUADRANGLE, RADIAL_QUAD*.
 +
 +  SMESH Plugins provide such algorithms as: *NETGEN, NETGEN_FULL, FULL_NETGEN, NETGEN_1D2D3D, NETGEN_1D2D, NETGEN_2D, NETGEN_3D*.
 +
 +  If you use DISTENE plugins, you also have *BLSURF, GHS3D, GHS3DPRL, Hexotic*.
 +
 +* Some **variables** were available in both namespaces *smesh* and *SMESH*. Now they are available only in namespace *SMESH*.
 +
 +  The dump function used only the namespace *SMESH*,
 +  so, if your script was built with the help of the dump function, it should be already OK in this respect.
 +
 +  The most used variables concerned are:
 +
 +  * *NODE, EDGE, FACE, VOLUME, ALL.*
 +  * *FT_xxx, geom_xxx, ADD_xxx...*
 +
 +  For instance::
 +
 +      srcFaceGroup = srcMesh.GroupOnGeom( midFace0, "src faces", smesh.FACE )
 +      mesh.MakeGroup("Tetras",smesh.VOLUME,smesh.FT_ElemGeomType,"=",smesh.Geom_TETRA)
 +      filter = smesh.GetFilter(smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 6.5)
 +
 +  is replaced by::
 +
 +      srcFaceGroup = srcMesh.GroupOnGeom( midFace0, "src faces", SMESH.FACE )
 +      mesh.MakeGroup("Tetras",SMESH.VOLUME,SMESH.FT_ElemGeomType,"=",SMESH.Geom_TETRA)
 +      filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_AspectRatio, SMESH.FT_MoreThan, 6.5)
 +
 +
 +* The namespace **smesh.smesh** does not exist any more, use **smesh** instead.
 +
 +  For instance::
 +
 +      Compound1 = smesh.smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
 +
 +  is replaced by::
 +
 +      Compound1 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
 +
++* If you need to **import a SMESH Plugin** explicitly, keep in mind that  they are now located in separate namespaces.
 +
 +  For instance::
 +
 +      import StdMeshers
 +      import NETGENPlugin
 +      import BLSURFPlugin
 +      import GHS3DPlugin
 +      import HexoticPLUGIN
 +
 +  is replaced by:: 
 +
 +      from salome.StdMeshers import StdMeshersBuilder
 +      from salome.NETGENPlugin import NETGENPluginBuilder
 +      from salome.BLSURFPlugin import BLSURFPluginBuilder
 +      from salome.GHS3DPlugin import GHS3DPluginBuilder
 +      from salome.HexoticPLUGIN import HexoticPLUGINBuilder
 +
 +
index dd9806b,0000000..19ce22f
mode 100644,000000..100644
--- /dev/null
@@@ -1,59 -1,0 +1,59 @@@
-     except Exception, e:
-         print e
 +import inspect
 +import sys
 +from types import FunctionType
 +import copy
 +
 +ORIGIN_MODULE_SUFFIX = "_origin"
 +DYNAMIC_MODULE_SUFFIX = "_dynamic"
 +
 +
 +def main(module_name, output_file = "smeshBuilder.py"):
 +    oringin_module_name = module_name + ORIGIN_MODULE_SUFFIX
 +    dynamic_module_name = module_name + DYNAMIC_MODULE_SUFFIX
 +    try:
 +        exec( "import %s" % oringin_module_name )
 +        exec( "origin_module = %s" % oringin_module_name )
 +        origin_module_lines = inspect.getsourcelines( origin_module )[0]
 +        origin_meshClass_lines = inspect.getsourcelines(origin_module.Mesh)[0]
 +        origin_module_text = "".join( origin_module_lines )
 +        origin_meshClass_text = "".join( origin_meshClass_lines )
 +        
 +        exec( "import %s" % dynamic_module_name )
 +        exec( "dynanmic_module = %s" % dynamic_module_name )
 +        dynanmic_meshClass = dynanmic_module.Mesh
 +    
 +        new_meshClass_lines = copy.copy(origin_meshClass_lines)
 +        # remove end of class 'pass'
 +        if new_meshClass_lines[-1].find("pass") > 0:
 +            new_meshClass_lines.pop()
 +            
 +        dynanmic_meshClass_methods = [x for x, y in dynanmic_meshClass.__dict__.items() if type(y) == FunctionType]
 +        for method in dynanmic_meshClass_methods:
 +            exec( "method_lines = inspect.getsourcelines(dynanmic_module.Mesh.%s)[0]"  % method)
 +            new_meshClass_lines+=method_lines
 +            pass
 +        new_meshClass_text = "".join( new_meshClass_lines )            
 +
 +        f = open( output_file, "w" )
 +        
 +        f.write( origin_module_text.replace( origin_meshClass_text, new_meshClass_text) )
 +        f.close()        
++    except Exception as e:
++        print(e)
 +        pass
 +    pass
 +
 +
 +if __name__ == "__main__":
 +    import optparse
 +    parser = optparse.OptionParser(usage="%prog [options] modulename")
 +    h  = "Output file (smeshBuilder.py by default)"
 +    parser.add_option("-o", "--output", dest="output",
 +                      action="store", default="smeshBuilder.py", metavar="file",
 +                      help=h)
 +
 +    (options, args) = parser.parse_args()
 +
 +    if len( args ) < 1: sys.exit("Module name is not specified")
 +    main( args[0], options.output )
 +    pass
Simple merge
  INCLUDE_DIRECTORIES(
    ${HDF5_INCLUDE_DIRS}
    ${KERNEL_INCLUDE_DIRS}
 -  ${CAS_INCLUDE_DIRS}
 +  ${OpenCASCADE_INCLUDE_DIR}
    ${VTK_INCLUDE_DIRS}
    ${Boost_INCLUDE_DIRS}
-   ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
-   ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Factory
+   ${PROJECT_SOURCE_DIR}/src/MEDWrapper
    ${PROJECT_SOURCE_DIR}/src/Driver
    ${PROJECT_SOURCE_DIR}/src/SMDS
    ${PROJECT_SOURCE_DIR}/src/SMESHUtils
Simple merge
Simple merge
@@@ -26,9 -26,8 +26,9 @@@ INCLUDE_DIRECTORIES
    ${VTK_INCLUDE_DIRS}
    ${Boost_INCLUDE_DIRS}
    ${HDF5_INCLUDE_DIRS}
 +  ${TBB_INCLUDE_DIRS}
    ${PROJECT_SOURCE_DIR}/src/Controls
-   ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
+   ${PROJECT_SOURCE_DIR}/src/MEDWrapper
    ${PROJECT_SOURCE_DIR}/src/Driver
    ${PROJECT_SOURCE_DIR}/src/DriverDAT
    ${PROJECT_SOURCE_DIR}/src/DriverMED
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -143,7 -142,7 +143,6 @@@ SET(_moc_HEADER
    SMESHGUI_FieldSelectorWdg.h
    SMESHGUI_DisplayEntitiesDlg.h
    SMESHGUI_SplitBiQuad.h
--  SMESHGUI_PreVisualObj.h
    SMESHGUI_IdPreview.h
  )
  
@@@ -3541,23 -3464,9 +3471,23 @@@ bool SMESHGUI::OnGUIEvent( int theComma
        break;
      }
  
-       if(checkLock(aStudy)) break;
 +  case SMESHOp::OpOffset:
 +    {
++      if(isStudyLocked()) break;
 +      if ( vtkwnd ) {
 +        EmitSignalDeactivateDialog();
 +        ( new SMESHGUI_OffsetDlg( this ) )->show();
 +      }
 +      else {
 +        SUIT_MessageBox::warning(SMESHGUI::desktop(),
 +                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
 +      }
 +      break;
 +    }
 +
    case SMESHOp::OpSewing:
      {
-       if(checkLock(aStudy)) break;
+       if(isStudyLocked()) break;
        if(vtkwnd) {
          EmitSignalDeactivateDialog();
          ( new SMESHGUI_SewingDlg( this ) )->show();
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1426,8 -1420,8 +1420,9 @@@ void SMESHGUI_GroupDlg::onObjectSelecti
            aGroupMainShape = aGeomGroup;
            aGroupMainShape->Register();
          }
-         _PTR(SObject) aGroupMainShapeSO = aStudy->FindObjectID( entry.in() );
 +        CORBA::String_var entry = aGroupMainShape->GetStudyEntry();
 -          SMESH::getStudy()->FindObjectID(aGroupMainShape->GetStudyEntry());
+         _PTR(SObject) aGroupMainShapeSO =
++          SMESH::getStudy()->FindObjectID( entry.in() );
  
          _PTR(SObject) anObj, aRef;
          bool isRefOrSubShape = false;
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index b7ded79,0000000..111a841
mode 100644,000000..100644
--- /dev/null
@@@ -1,937 -1,0 +1,937 @@@
-   if (mySMESHGUI->isActiveStudyLocked())
 +// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
 +//
 +// This library is free software; you can redistribute it and/or
 +// modify it under the terms of the GNU Lesser General Public
 +// License as published by the Free Software Foundation; either
 +// version 2.1 of the License, or (at your option) any later version.
 +//
 +// This library is distributed in the hope that it will be useful,
 +// but WITHOUT ANY WARRANTY; without even the implied warranty of
 +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 +// Lesser General Public License for more details.
 +//
 +// You should have received a copy of the GNU Lesser General Public
 +// License along with this library; if not, write to the Free Software
 +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 +//
 +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 +//
 +//  File   : SMESHGUI_OffsetDlg.cxx
 +
 +//  SMESH includes
 +
 +#include "SMESHGUI_OffsetDlg.h"
 +
 +#include "SMESHGUI.h"
 +#include "SMESHGUI_SpinBox.h"
 +#include "SMESHGUI_Utils.h"
 +#include "SMESHGUI_VTKUtils.h"
 +#include "SMESHGUI_MeshUtils.h"
 +#include "SMESHGUI_IdValidator.h"
 +#include "SMESHGUI_FilterDlg.h"
 +#include "SMESHGUI_MeshEditPreview.h"
 +
 +#include <SMESH_Actor.h>
 +#include <SMESH_TypeFilter.hxx>
 +#include <SMESH_LogicalFilter.hxx>
 +#include <SMDS_Mesh.hxx>
 +
 +// SALOME GUI includes
 +#include <LightApp_Application.h>
 +#include <LightApp_SelectionMgr.h>
 +#include <SALOME_ListIO.hxx>
 +#include <SUIT_Desktop.h>
 +#include <SUIT_MessageBox.h>
 +#include <SUIT_OverrideCursor.h>
 +#include <SUIT_ResourceMgr.h>
 +#include <SUIT_Session.h>
 +#include <SVTK_ViewModel.h>
 +#include <SVTK_ViewWindow.h>
 +#include <SalomeApp_Tools.h>
 +
 +// SALOME KERNEL includes
 +#include <SALOMEDSClient.hxx>
 +#include <SALOMEDSClient_SObject.hxx>
 +
 +// OCCT includes
 +#include <TColStd_MapOfInteger.hxx>
 +
 +// Qt includes
 +#include <QApplication>
 +#include <QButtonGroup>
 +#include <QGroupBox>
 +#include <QLabel>
 +#include <QLineEdit>
 +#include <QPushButton>
 +#include <QRadioButton>
 +#include <QCheckBox>
 +#include <QHBoxLayout>
 +#include <QVBoxLayout>
 +#include <QGridLayout>
 +#include <QSpinBox>
 +#include <QKeyEvent>
 +
 +// IDL includes
 +#include <SALOMEconfig.h>
 +#include CORBA_SERVER_HEADER(SMESH_Group)
 +#include CORBA_SERVER_HEADER(SMESH_MeshEditor)
 +
 +enum { MOVE_ELEMS_BUTTON = 0, COPY_ELEMS_BUTTON, MAKE_MESH_BUTTON }; //!< action type
 +
 +/*!
 +  \class BusyLocker
 +  \brief Simple 'busy state' flag locker.
 +  \internal
 +*/
 +class BusyLocker
 +{
 +public:
 +  //! Constructor. Sets passed boolean flag to \c true.
 +  BusyLocker( bool& busy ) : myBusy( busy ) { myBusy = true; }
 +  //! Destructor. Clear external boolean flag passed as parameter to the constructor to \c false.
 +  ~BusyLocker() { myBusy = false; }
 +private:
 +  bool& myBusy; //! External 'busy state' boolean flag
 +};
 +
 +#define SPACING 6
 +#define MARGIN  11
 +
 +//=================================================================================
 +// class    : SMESHGUI_OffsetDlg()
 +// purpose  :
 +//=================================================================================
 +SMESHGUI_OffsetDlg::SMESHGUI_OffsetDlg( SMESHGUI* theModule ) :
 +  SMESHGUI_MultiPreviewDlg( theModule ),
 +  mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
 +  myFilterDlg(0)
 +{
 +  QPixmap image0 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_DLG_MESH_OFFSET")));
 +  QPixmap image1 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_SELECT")));
 +
 +  setModal(false);
 +  setAttribute(Qt::WA_DeleteOnClose, true);
 +  setWindowTitle(tr("SMESH_OFFSET_TITLE"));
 +  setSizeGripEnabled(true);
 +
 +  QVBoxLayout* dlgLayout = new QVBoxLayout(this);
 +  dlgLayout->setSpacing(SPACING);
 +  dlgLayout->setMargin(MARGIN);
 +
 +  /***************************************************************/
 +  ConstructorsBox = new QGroupBox(tr("SMESH_OFFSET"), this);
 +  QHBoxLayout* ConstructorsBoxLayout = new QHBoxLayout(ConstructorsBox);
 +  ConstructorsBoxLayout->setSpacing(SPACING);
 +  ConstructorsBoxLayout->setMargin(MARGIN);
 +
 +  QRadioButton* RadioButton1= new QRadioButton(ConstructorsBox);
 +  RadioButton1->setIcon(image0);
 +
 +  ConstructorsBoxLayout->addWidget(RadioButton1);
 +
 +  /***************************************************************/
 +  GroupArguments = new QGroupBox(tr("SMESH_ARGUMENTS"), this);
 +  QGridLayout* GroupArgumentsLayout = new QGridLayout(GroupArguments);
 +  GroupArgumentsLayout->setSpacing(SPACING);
 +  GroupArgumentsLayout->setMargin(MARGIN);
 +
 +  myIdValidator = new SMESHGUI_IdValidator(this);
 +
 +  // Controls for elements selection
 +  TextLabelElements = new QLabel(tr("SMESH_ID_ELEMENTS"), GroupArguments);
 +  // SelectElementsButton = new QPushButton(GroupArguments);
 +  // SelectElementsButton->setIcon(image1);
 +  LineEditElements = new QLineEdit(GroupArguments);
 +  LineEditElements->setValidator(myIdValidator);
 +  LineEditElements->setMaxLength(-1);
 +  myFilterBtn = new QPushButton( tr( "SMESH_BUT_FILTER" ), GroupArguments );
 +  connect(myFilterBtn,   SIGNAL(clicked()), this, SLOT(setFilters()));
 +
 +  // Control for the whole mesh selection
 +  CheckBoxMesh = new QCheckBox(tr("SMESH_SELECT_WHOLE_MESH"), GroupArguments);
 +
 +  // offset
 +  QLabel* TextLabel1 = new QLabel(tr("OFFSET_VALUE"), GroupArguments);
 +  SpinBox = new SMESHGUI_SpinBox(GroupArguments);
 +
 +
 +  // switch of action type
 +  ActionBox = new QGroupBox(GroupArguments);
 +  ActionGroup = new QButtonGroup(GroupArguments);
 +  QVBoxLayout* ActionBoxLayout = new QVBoxLayout(ActionBox);
 +  ActionBoxLayout->addSpacing(SPACING);
 +  ActionBoxLayout->setMargin(MARGIN);
 +
 +  QRadioButton* aMoveElements = new QRadioButton(tr("SMESH_MOVE_ELEMENTS"), ActionBox);
 +  QRadioButton* aCopyElements = new QRadioButton(tr("SMESH_COPY_ELEMENTS"), ActionBox);
 +  QRadioButton* aCreateMesh   = new QRadioButton(tr("SMESH_CREATE_MESH"),   ActionBox);
 +
 +  ActionBoxLayout->addWidget(aMoveElements);
 +  ActionBoxLayout->addWidget(aCopyElements);
 +  ActionBoxLayout->addWidget(aCreateMesh);
 +  ActionGroup->addButton(aMoveElements, MOVE_ELEMS_BUTTON);
 +  ActionGroup->addButton(aCopyElements, COPY_ELEMS_BUTTON);
 +  ActionGroup->addButton(aCreateMesh,   MAKE_MESH_BUTTON);
 +
 +  // CheckBox for groups generation
 +  MakeGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
 +  MakeGroupsCheck->setChecked(false);
 +
 +  // Name of a mesh to create
 +  LineEditNewMesh = new QLineEdit(GroupArguments);
 +
 +  //Preview check box
 +  myPreviewCheckBox = new QCheckBox(tr("PREVIEW"), GroupArguments);
 +
 +  // layout
 +  GroupArgumentsLayout->addWidget(TextLabelElements,    0, 0);
 +  //GroupArgumentsLayout->addWidget(SelectElementsButton, 0, 1);
 +  GroupArgumentsLayout->addWidget(LineEditElements,     0, 2, 1, 5);
 +  GroupArgumentsLayout->addWidget(myFilterBtn,          0, 7);
 +  GroupArgumentsLayout->addWidget(CheckBoxMesh,         1, 0, 1, 8);
 +  GroupArgumentsLayout->addWidget(TextLabel1,           2, 0);
 +  GroupArgumentsLayout->addWidget(SpinBox,              2, 3);
 +  GroupArgumentsLayout->addWidget(ActionBox,            3, 0, 3, 4);
 +  GroupArgumentsLayout->addWidget(MakeGroupsCheck,      4, 5, 1, 4);
 +  GroupArgumentsLayout->addWidget(LineEditNewMesh,      5, 5, 1, 4);
 +  GroupArgumentsLayout->addWidget(myPreviewCheckBox,    6, 0);
 +
 +  /***************************************************************/
 +  GroupButtons = new QGroupBox(this);
 +  QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
 +  GroupButtonsLayout->setSpacing(SPACING);
 +  GroupButtonsLayout->setMargin(MARGIN);
 +
 +  buttonOk = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), GroupButtons);
 +  buttonOk->setAutoDefault(true);
 +  buttonOk->setDefault(true);
 +  buttonApply = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
 +  buttonApply->setAutoDefault(true);
 +  buttonCancel = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
 +  buttonCancel->setAutoDefault(true);
 +  buttonHelp = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
 +  buttonHelp->setAutoDefault(true);
 +
 +  GroupButtonsLayout->addWidget(buttonOk);
 +  GroupButtonsLayout->addSpacing(10);
 +  GroupButtonsLayout->addWidget(buttonApply);
 +  GroupButtonsLayout->addSpacing(10);
 +  GroupButtonsLayout->addStretch();
 +  GroupButtonsLayout->addWidget(buttonCancel);
 +  GroupButtonsLayout->addWidget(buttonHelp);
 +
 +  /***************************************************************/
 +  dlgLayout->addWidget(ConstructorsBox);
 +  dlgLayout->addWidget(GroupArguments);
 +  dlgLayout->addWidget(GroupButtons);
 +
 +  /* Initialisations */
 +  SpinBox->RangeStepAndValidator(COORD_MIN, COORD_MAX, 1.0, "length_precision");
 +
 +  RadioButton1->setChecked(true);
 +
 +  mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
 +
 +  mySMESHGUI->SetActiveDialogBox((QDialog*)this);
 +
 +  // Costruction of the logical filter
 +  SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter (SMESH::MESHorSUBMESH);
 +  SMESH_TypeFilter* aSmeshGroupFilter    = new SMESH_TypeFilter (SMESH::GROUP);
 +
 +  QList<SUIT_SelectionFilter*> aListOfFilters;
 +  if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
 +  if (aSmeshGroupFilter)    aListOfFilters.append(aSmeshGroupFilter);
 +
 +  myMeshOrSubMeshOrGroupFilter =
 +    new SMESH_LogicalFilter(aListOfFilters, SMESH_LogicalFilter::LO_OR);
 +
 +  myHelpFileName = "Offset_page.html";
 +
 +  Init();
 +
 +  /* signals and slots connections */
 +  connect(buttonOk,     SIGNAL(clicked()), this, SLOT(ClickOnOk()));
 +  connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
 +  connect(buttonApply,  SIGNAL(clicked()), this, SLOT(ClickOnApply()));
 +  connect(buttonHelp,   SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
 +
 +  //connect(SelectElementsButton, SIGNAL (clicked()), this, SLOT(SetEditCurrentArgument()));
 +
 +  connect(mySMESHGUI, SIGNAL (SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
 +  connect(mySelectionMgr, SIGNAL(currentSelectionChanged()),   this, SLOT(SelectionIntoArgument()));
 +  /* to close dialog if study change */
 +  connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()),      this, SLOT(reject()));
 +  connect(mySMESHGUI, SIGNAL(SignalActivatedViewManager()), this, SLOT(onOpenView()));
 +  connect(mySMESHGUI, SIGNAL(SignalCloseView()),            this, SLOT(onCloseView()));
 +
 +  connect(LineEditElements, SIGNAL(textChanged(const QString&)),    SLOT(onTextChange(const QString&)));
 +  connect(CheckBoxMesh,     SIGNAL(toggled(bool)),                  SLOT(onSelectMesh(bool)));
 +  connect(ActionGroup,      SIGNAL(buttonClicked(int)),             SLOT(onActionClicked(int)));
 +
 +  connect(SpinBox,  SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
 +
 +  //To Connect preview check box
 +  connectPreviewControl();
 +
 +  SelectionIntoArgument();
 +  onActionClicked(MOVE_ELEMS_BUTTON);
 +}
 +
 +//=================================================================================
 +// function : ~SMESHGUI_OffsetDlg()
 +// purpose  : Destroys the object and frees any allocated resources
 +//=================================================================================
 +SMESHGUI_OffsetDlg::~SMESHGUI_OffsetDlg()
 +{
 +  if ( myFilterDlg ) {
 +    myFilterDlg->setParent( 0 );
 +    delete myFilterDlg;
 +    myFilterDlg = 0;
 +  }
 +}
 +
 +//=================================================================================
 +// function : Init()
 +// purpose  :
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::Init (bool ResetControls)
 +{
 +  myBusy = false;
 +  myObjects.clear();
 +  myObjectsNames.clear();
 +  myMeshes.clear();
 +
 +  LineEditElements->clear();
 +  myElementsId = "";
 +  myNbOkElements = 0;
 +
 +  buttonOk->setEnabled(false);
 +  buttonApply->setEnabled(false);
 +
 +  myActor = 0;
 +
 +  if (ResetControls)
 +  {
 +    SpinBox->SetValue(1.0);
 +    myPreviewCheckBox->setChecked(false);
 +    onDisplaySimulation(false);
 +
 +    ActionGroup->button( MOVE_ELEMS_BUTTON )->setChecked(true);
 +    CheckBoxMesh->setChecked(true);
 +    onSelectMesh(true);
 +  }
 +}
 +
 +//=================================================================================
 +// function : ClickOnApply()
 +// purpose  :
 +//=================================================================================
 +bool SMESHGUI_OffsetDlg::ClickOnApply()
 +{
++  if (mySMESHGUI->isStudyLocked())
 +    return false;
 +
 +  if( !isValid() )
 +    return false;
 +
 +  SUIT_OverrideCursor aWaitCursor;
 +
 +  if (myNbOkElements)
 +  {
 +    QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
 +
 +    SMESH::long_array_var anElementsId = new SMESH::long_array;
 +    anElementsId->length(aListElementsId.count());
 +    for (int i = 0; i < aListElementsId.count(); i++)
 +      anElementsId[i] = aListElementsId[i].toInt();
 +
 +    double offsetValue = SpinBox->value();
 +
 +    QStringList aParameters;
 +    aParameters << SpinBox->text();
 +
 +    int actionButton = ActionGroup->checkedId();
 +    bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
 +    SMESH::ListOfGroups_var groups;
 +    SMESH::SMESH_Mesh_var mesh;
 +    QStringList anEntryList;
 +    try
 +    {
 +      switch ( actionButton ) {
 +
 +      case MOVE_ELEMS_BUTTON:
 +        if ( CheckBoxMesh->isChecked() )
 +          for ( int i = 0; i < myObjects.count(); i++ ) {
 +            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
 +            myMeshes[i]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
 +            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, true, "", groups.out() );
 +          }
 +        else {
 +          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
 +          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE);
 +          myMeshes[0]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
 +          mesh = aMeshEditor->Offset( src, offsetValue, true, "", groups.out() );
 +        }
 +        break;
 +
 +      case COPY_ELEMS_BUTTON:
 +        if ( CheckBoxMesh->isChecked() )
 +          for ( int i = 0; i < myObjects.count(); i++ ) {
 +            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
 +            myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
 +            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, makeGroups, "", groups.out() );
 +          }
 +        else {
 +          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
 +          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE );
 +          myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
 +          mesh = aMeshEditor->Offset( src, offsetValue, makeGroups, "", groups.out() );
 +        }
 +        break;
 +
 +      case MAKE_MESH_BUTTON: {
 +        SMESH::SMESH_Mesh_var mesh;
 +        if ( CheckBoxMesh->isChecked() ) {
 +          for ( int i = 0; i < myObjects.count(); i++ ) {
 +            QString aName =
 +              SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ));
 +            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
 +            myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
 +            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, makeGroups,
 +                                        aName.toLatin1().data(), groups.out() );
 +            if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ))
 +              anEntryList.append( aSObject->GetID().c_str() );
 +          }
 +        }
 +        else {
 +          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
 +          myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
 +          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE );
 +          mesh = aMeshEditor->Offset( src, offsetValue, makeGroups,
 +                                      LineEditNewMesh->text().toLatin1().data(), groups.out() );
 +          if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
 +            anEntryList.append( aSObject->GetID().c_str() );
 +        }
 +        break;
 +      }
 +      }
 +    }
 +    catch ( const SALOME::SALOME_Exception& S_ex ) {
 +      SalomeApp_Tools::QtCatchCorbaException( S_ex );
 +    }
 +    catch (...) {
 +    }
 +
 +    for ( int i = 0; i < myObjects.count(); i++ ) {
 +      SMESH_Actor* actor = SMESH::FindActorByObject( myObjects[i] );
 +      if ( actor ) SMESH::Update( actor->getIO(), true );
 +    }
 +
 +    if ( makeGroups || actionButton == MAKE_MESH_BUTTON )
 +    {
 +      mySMESHGUI->updateObjBrowser(true); // new groups may appear
 +      if( LightApp_Application* anApp =
 +          dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
 +        anApp->browseObjects( anEntryList, isApplyAndClose() );
 +    }
 +    if ( !isApplyAndClose() )
 +    {
 +      Init(false);
 +      SelectionIntoArgument();
 +    }
 +    SMESHGUI::Modified();
 +  }
 +
 +  return true;
 +}
 +
 +//=================================================================================
 +// function : ClickOnOk()
 +// purpose  :
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::ClickOnOk()
 +{
 +  setIsApplyAndClose( true );
 +  if( ClickOnApply() )
 +    reject();
 +}
 +
 +//=================================================================================
 +// function : reject()
 +// purpose  :
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::reject()
 +{
 +  disconnect(mySelectionMgr, 0, this, 0);
 +  mySelectionMgr->clearFilters();
 +  if (SMESH::GetCurrentVtkView()) {
 +    SMESH::RemoveFilters(); // PAL6938 -- clean all mesh entity filters
 +    SMESH::SetPointRepresentation(false);
 +  }
 +  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 +    aViewWindow->SetSelectionMode( ActorSelection );
 +  mySMESHGUI->ResetState();
 +  QDialog::reject();
 +}
 +
 +//=================================================================================
 +// function : onOpenView()
 +// purpose  :
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::onOpenView()
 +{
 +  if ( mySelector ) {
 +    SMESH::SetPointRepresentation(false);
 +  }
 +  else {
 +    mySelector = SMESH::GetViewWindow( mySMESHGUI )->GetSelector();
 +    ActivateThisDialog();
 +  }
 +}
 +
 +//=================================================================================
 +// function : onCloseView()
 +// purpose  :
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::onCloseView()
 +{
 +  DeactivateActiveDialog();
 +  mySelector = 0;
 +}
 +
 +//=================================================================================
 +// function : ClickOnHelp()
 +// purpose  :
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::ClickOnHelp()
 +{
 +  LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
 +  if (app)
 +    app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
 +  else {
 +    QString platform;
 +#ifdef WIN32
 +    platform = "winapplication";
 +#else
 +    platform = "application";
 +#endif
 +    SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
 +                             tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
 +                             arg(app->resourceMgr()->stringValue("ExternalBrowser",
 +                                                                 platform)).
 +                             arg(myHelpFileName));
 +  }
 +}
 +
 +//=======================================================================
 +// function : onTextChange()
 +// purpose  :
 +//=======================================================================
 +
 +void SMESHGUI_OffsetDlg::onTextChange (const QString& theNewText)
 +{
 +  if (myBusy) return;
 +  BusyLocker lock( myBusy );
 +
 +  myNbOkElements = 0;
 +
 +  buttonOk->setEnabled(false);
 +  buttonApply->setEnabled(false);
 +
 +  // highlight entered elements
 +  SMDS_Mesh* aMesh = 0;
 +  if (myActor)
 +    aMesh = myActor->GetObject()->GetMesh();
 +
 +  if (aMesh) {
 +    Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
 +
 +    TColStd_MapOfInteger newIndices;
 +
 +    QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
 +    for (int i = 0; i < aListId.count(); i++)
 +    {
 +      if ( const SMDS_MeshElement * e = aMesh->FindElement(aListId[ i ].toInt()))
 +        newIndices.Add( e->GetID() );
 +      myNbOkElements++;
 +    }
 +
 +    mySelector->AddOrRemoveIndex( anIO, newIndices, false );
 +    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 +      aViewWindow->highlight( anIO, true, true );
 +
 +    myElementsId = theNewText;
 +  }
 +
 +  if (myNbOkElements) {
 +    buttonOk->setEnabled(true);
 +    buttonApply->setEnabled(true);
 +  }
 +}
 +
 +//=================================================================================
 +// function : SelectionIntoArgument()
 +// purpose  : Called when selection as changed or other case
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::SelectionIntoArgument()
 +{
 +  if (myBusy) return;
 +  if (myFilterDlg && myFilterDlg->isVisible()) return; // filter dlg active
 +
 +  BusyLocker lock( myBusy );
 +
 +  // clear
 +  myActor = 0;
 +  QString aString = "";
 +  onDisplaySimulation(false);
 +
 +  LineEditElements->setText(aString);
 +  myNbOkElements = 0;
 +  buttonOk->setEnabled(false);
 +  buttonApply->setEnabled(false);
 +
 +  if (!GroupButtons->isEnabled()) // inactive
 +    return;
 +
 +  // get selected mesh
 +  SALOME_ListIO aList;
 +  mySelectionMgr->selectedObjects(aList);
 +
 +  int nbSel = aList.Extent();
 +  if (nbSel < 1)
 +    return;
 +
 +  myElementsId = "";
 +  myObjects.clear();
 +  myObjectsNames.clear();
 +  myMeshes.clear();
 +
 +  for ( SALOME_ListIteratorOfListIO it( aList ); it.More(); it.Next() )
 +  {
 +    Handle(SALOME_InteractiveObject) IO = it.Value();
 +    SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( IO );
 +    if ( aMesh->_is_nil() || aMesh->NbFaces() == 0 )
 +      return;
 +
 +    myActor = SMESH::FindActorByObject( aMesh );
 +    if ( !myActor )
 +      myActor = SMESH::FindActorByEntry( IO->getEntry() );
 +
 +    SMESH::SMESH_IDSource_var idSrc = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
 +    if ( _PTR(SObject) obj = SMESH::FindSObject( idSrc ))
 +    {
 +      std::string name = obj->GetName();
 +      if ( !name.empty() )
 +      {
 +        myObjects << idSrc;
 +        myObjectsNames << name.c_str();
 +        myMeshes << aMesh;
 +      }
 +    }
 +  }
 +
 +  // MakeGroups is available if there are groups and "Copy"
 +  int aNbGroups = 0;
 +  for ( int i = 0; i < myMeshes.count(); i++ )
 +    aNbGroups += myMeshes[i]->NbGroups();
 +
 +  if ( aNbGroups == 0 ) {
 +    MakeGroupsCheck->setChecked(false);
 +    MakeGroupsCheck->setEnabled(false);
 +  }
 +  else if ( ActionGroup->checkedId() != MOVE_ELEMS_BUTTON ) {
 +    MakeGroupsCheck->setEnabled(true);
 +  }
 +
 +  if (CheckBoxMesh->isChecked()) {
 +    if (myMeshes.isEmpty())
 +      return;
 +    SMESH::GetNameOfSelectedIObjects( mySelectionMgr, aString );
 +  }
 +  else {
 +    int aNbUnits = SMESH::GetNameOfSelectedElements(mySelector, aList.First(), aString);
 +    myElementsId = aString;
 +    if (aNbUnits < 1)
 +      return;
 +  }
 +
 +  myNbOkElements = true;
 +  
 +  LineEditElements->setText(aString);
 +  LineEditElements->repaint();
 +  LineEditElements->setEnabled(false); // to fully update lineedit IPAL 19809
 +  LineEditElements->setEnabled(true);
 +  setNewMeshName();
 +
 +  buttonOk->setEnabled(true);
 +  buttonApply->setEnabled(true);
 +
 +  onDisplaySimulation(true);
 +}
 +
 +//=================================================================================
 +// function : DeactivateActiveDialog()
 +// purpose  :
 +//=================================================================================
 +
 +void SMESHGUI_OffsetDlg::DeactivateActiveDialog()
 +{
 +  if (ConstructorsBox->isEnabled())
 +  {
 +    ConstructorsBox->setEnabled(false);
 +    GroupArguments->setEnabled(false);
 +    GroupButtons->setEnabled(false);
 +    mySMESHGUI->ResetState();
 +    mySMESHGUI->SetActiveDialogBox(0);
 +  }
 +}
 +
 +//=================================================================================
 +// function : ActivateThisDialog()
 +// purpose  :
 +//=================================================================================
 +
 +void SMESHGUI_OffsetDlg::ActivateThisDialog()
 +{
 +  /* Emit a signal to deactivate the active dialog */
 +  mySMESHGUI->EmitSignalDeactivateDialog();
 +  ConstructorsBox->setEnabled(true);
 +  GroupArguments->setEnabled(true);
 +  GroupButtons->setEnabled(true);
 +
 +  mySMESHGUI->SetActiveDialogBox((QDialog*)this);
 +
 +  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 +    aViewWindow->SetSelectionMode( CellSelection );
 +
 +  SelectionIntoArgument();
 +}
 +
 +//=================================================================================
 +// function : enterEvent()
 +// purpose  :
 +//=================================================================================
 +
 +void SMESHGUI_OffsetDlg::enterEvent (QEvent*)
 +{
 +  if (!ConstructorsBox->isEnabled()) {
 +    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
 +    if ( aViewWindow && !mySelector) {
 +      mySelector = aViewWindow->GetSelector();
 +    }
 +    ActivateThisDialog();
 +  }
 +}
 +
 +//=======================================================================
 +//function : onSelectMesh
 +//purpose  :
 +//=======================================================================
 +
 +void SMESHGUI_OffsetDlg::onSelectMesh (bool toSelectMesh)
 +{
 +  if (toSelectMesh)
 +    TextLabelElements->setText(tr("SMESH_NAME"));
 +  else
 +    TextLabelElements->setText(tr("SMESH_ID_ELEMENTS"));
 +  myFilterBtn->setEnabled(!toSelectMesh);
 +
 +  mySelectionMgr->clearFilters();
 +  SMESH::SetPointRepresentation(false);
 +
 +  if (toSelectMesh)
 +  {
 +    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 +      aViewWindow->SetSelectionMode( ActorSelection );
 +    mySelectionMgr->installFilter( myMeshOrSubMeshOrGroupFilter );
 +    LineEditElements->setReadOnly( true );
 +    LineEditElements->setValidator( 0 );
 +  }
 +  else
 +  {
 +    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
 +      aViewWindow->SetSelectionMode( FaceSelection );
 +    LineEditElements->setReadOnly( false );
 +    LineEditElements->setValidator( myIdValidator );
 +    onTextChange(LineEditElements->text());
 +    hidePreview();
 +  }
 +
 +  SelectionIntoArgument();
 +}
 +
 +//=======================================================================
 +//function : onActionClicked
 +//purpose  : slot called when an action type changed
 +//=======================================================================
 +
 +void SMESHGUI_OffsetDlg::onActionClicked(int button)
 +{
 +  int aNbGroups = 0;
 +  for ( int i = 0; i < myMeshes.count(); i++ )
 +    aNbGroups += myMeshes[i]->NbGroups();
 +
 +  switch ( button ) {
 +  case MOVE_ELEMS_BUTTON:
 +    MakeGroupsCheck->setEnabled(false);
 +    LineEditNewMesh->setEnabled(false);
 +    break;
 +  case COPY_ELEMS_BUTTON:
 +    LineEditNewMesh->setEnabled(false);
 +    MakeGroupsCheck->setText( tr("SMESH_MAKE_GROUPS"));
 +    MakeGroupsCheck->setEnabled( myMeshes.isEmpty() || aNbGroups > 0 );
 +    break;
 +  case MAKE_MESH_BUTTON:
 +    LineEditNewMesh->setEnabled(true);
 +    MakeGroupsCheck->setText( tr("SMESH_COPY_GROUPS"));
 +    MakeGroupsCheck->setEnabled( myMeshes.isEmpty() || aNbGroups > 0 );
 +    break;
 +  }
 +  setNewMeshName();
 +  //toDisplaySimulation();
 +}
 +
 +//=======================================================================
 +//function : setNewMeshName
 +//purpose  : update contents of LineEditNewMesh
 +//=======================================================================
 +
 +void SMESHGUI_OffsetDlg::setNewMeshName()
 +{
 +  LineEditNewMesh->setText("");
 +  if ( LineEditNewMesh->isEnabled() && !myMeshes.isEmpty() ) {
 +    QString name;
 +    if ( CheckBoxMesh->isChecked() ) {
 +      name = myObjects.count() > 1 ? "*" : LineEditElements->text();
 +    }
 +    else {
 +      _PTR(SObject) meshSO = SMESH::FindSObject( myMeshes[0] );
 +      name = meshSO->GetName().c_str();
 +    }
 +    if ( !name.isEmpty() )
 +      LineEditNewMesh->setText( SMESH::UniqueMeshName( name, "Offset"));
 +  }
 +}
 +
 +//=================================================================================
 +// function : keyPressEvent()
 +// purpose  :
 +//=================================================================================
 +
 +void SMESHGUI_OffsetDlg::keyPressEvent( QKeyEvent* e )
 +{
 +  QDialog::keyPressEvent( e );
 +  if ( e->isAccepted() )
 +    return;
 +
 +  if ( e->key() == Qt::Key_F1 ) {
 +    e->accept();
 +    ClickOnHelp();
 +  }
 +}
 +
 +//=================================================================================
 +// function : setFilters()
 +// purpose  : SLOT. Called when "Filter" button pressed.
 +//=================================================================================
 +
 +void SMESHGUI_OffsetDlg::setFilters()
 +{
 +  if ( myMeshes.isEmpty() ) {
 +    SUIT_MessageBox::critical(this, tr("SMESH_ERROR"), tr("NO_MESH_SELECTED"));
 +    return;
 +  }
 +  if ( !myFilterDlg ) {
 +    myFilterDlg = new SMESHGUI_FilterDlg( mySMESHGUI, SMESH::ALL );
 +    connect(myFilterDlg, SIGNAL(Accepted()), SLOT(onFilterAccepted()));
 +  }
 +
 +  myFilterDlg->Init( SMESH::FACE );
 +  myFilterDlg->SetSelection();
 +  myFilterDlg->SetMesh( myMeshes[0] );
 +  myFilterDlg->SetSourceWg( LineEditElements );
 +
 +  myFilterDlg->show();
 +}
 +
 +//=======================================================================
 +// name    : onFilterAccepted()
 +// Purpose : SLOT. Called when Filter dlg closed with OK button.
 +//           Activate [Apply] if no Actor is available
 +//=======================================================================
 +
 +void SMESHGUI_OffsetDlg::onFilterAccepted()
 +{
 +  if ( myMeshes.length() > 0 && !buttonOk->isEnabled() )
 +  {
 +    myElementsId = LineEditElements->text();
 +    QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
 +    myNbOkElements = aListElementsId.count();
 +    buttonOk->setEnabled   ( myNbOkElements );
 +    buttonApply->setEnabled( myNbOkElements );
 +  }
 +}
 +
 +//=================================================================================
 +// function : isValid
 +// purpose  :
 +//=================================================================================
 +
 +bool SMESHGUI_OffsetDlg::isValid()
 +{
 +  return true;
 +}
 +
 +//=================================================================================
 +// function : onDisplaySimulation
 +// purpose  : Show/Hide preview
 +//=================================================================================
 +void SMESHGUI_OffsetDlg::onDisplaySimulation( bool toDisplayPreview )
 +{
 +  SUIT_OverrideCursor aWaitCursor;
 +
 +  if (myPreviewCheckBox->isChecked() && toDisplayPreview)
 +  {
 +    if ( myNbOkElements && isValid() )
 +    {
 +      double offsetValue = SpinBox->value();
 +
 +      SMESH::ListOfGroups_var groups;
 +      SMESH::SMESH_Mesh_var mesh;
 +
 +      try
 +      {
 +        QList<SMESH::MeshPreviewStruct_var> aMeshPreviewStruct;
 +
 +        if ( CheckBoxMesh->isChecked())
 +          for ( int i = 0; i < myObjects.count(); i++ )
 +          {
 +            SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditPreviewer();
 +            mesh = aMeshEditor->Offset( myObjects[i], offsetValue, false, "", groups.out() );
 +            aMeshPreviewStruct << aMeshEditor->GetPreviewData();
 +          }
 +        else
 +        {
 +          SMESH::long_array_var anElementsId = new SMESH::long_array;
 +          QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
 +          anElementsId->length(aListElementsId.count());
 +          for (int i = 0; i < aListElementsId.count(); i++)
 +            anElementsId[i] = aListElementsId[i].toInt();
 +
 +          SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditPreviewer();
 +          SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE);
 +          mesh = aMeshEditor->Offset( src, offsetValue, false, "", groups.out() );
 +          aMeshPreviewStruct << aMeshEditor->GetPreviewData();
 +        }
 +        setSimulationPreview(aMeshPreviewStruct);
 +
 +      } catch (...) {
 +        hidePreview();
 +      }
 +    } else {
 +      hidePreview();
 +    }
 +  } else {
 +    hidePreview();
 +  }
 +}
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -70,10 -69,12 +69,11 @@@ SET(_link_LIBRARIE
    ${KERNEL_SalomeGenericObj}
    ${KERNEL_SalomeIDLKERNEL}
    ${KERNEL_SALOMELocalTrace}
 -  ${CAS_TKCDF}
 -  ${CAS_TKBO}
 -  ${CAS_TKShHealing}
+   ${KERNEL_SalomeKernelHelpers}
 +  ${OpenCASCADE_ApplicationFramework_LIBRARIES}
 +  ${OpenCASCADE_ModelingAlgorithms_LIBRARIES}
    ${GEOM_GEOMClient}
 -  ${GEOM_SalomeIDLGEOM}  
 +  ${GEOM_SalomeIDLGEOM}
    SalomeIDLSMESH
    SMESHimpl
    SMDS
Simple merge
@@@ -2550,31 -2537,29 +2536,31 @@@ SMESH_Gen_i::ConcatenateCommon(const SM
  
  
      // create groups of just added elements
 -    SMESH::SMESH_Group_var aNewGroup;
 -    SMESH::ElementType aGroupType;
 +    SMESH::SMESH_Group_var newGroup;
 +    SMESH::ElementType     groupType;
      if ( theCommonGroups )
      {
 -      SMESH::long_array_var curState = aNewMesh->GetNbElementsByType();
 +      // type names
 +      const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
 +      { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
 +        const int nbNames = sizeof(typeNames) / sizeof(const char*);
 +        int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
 +      }
 +
 +      SMESH::long_array_var curState = newMesh->GetNbElementsByType();
  
 -      for( aGroupType = SMESH::NODE;
 -           aGroupType < SMESH::NB_ELEMENT_TYPES;
 -           aGroupType = (SMESH::ElementType)( aGroupType + 1 ))
 +      for( groupType = SMESH::NODE;
 +           groupType < SMESH::NB_ELEMENT_TYPES;
 +           groupType = (SMESH::ElementType)( groupType + 1 ))
        {
 -        if ( curState[ aGroupType ] <= prevState[ aGroupType ])
 -          continue;
 +        if ( curState[ groupType ] <= prevState[ groupType ])
 +          continue; // no elements of groupType added from the i-th mesh
  
          // make a group name
 -        const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
 -        { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
 -          const int nbNames = sizeof(typeNames) / sizeof(const char*);
 -          int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
 -        }
 -        string groupName = "Gr";
 -        SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( theMeshesArray[i] );
 -        if ( aMeshSObj ) {
 -          CORBA::String_var name = aMeshSObj->GetName();
 +        std::string groupName = "Gr";
-         SALOMEDS::SObject_wrap meshSO = ObjectToSObject( myCurrentStudy, theMeshesArray[i] );
++        SALOMEDS::SObject_wrap meshSO = ObjectToSObject( theMeshesArray[i] );
 +        if ( meshSO ) {
 +          CORBA::String_var name = meshSO->GetName();
            groupName += name;
          }
          groupName += "_";
    }
  
    // IPAL21468 Change icon of compound because it need not be computed.
-   SALOMEDS::SObject_wrap meshSO = ObjectToSObject( myCurrentStudy, newMesh );
 -  SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( aNewMesh );
 -  SetPixMap( aMeshSObj, "ICON_SMESH_TREE_MESH" );
++  SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
 +  SetPixMap( meshSO, "ICON_SMESH_TREE_MESH" );
  
 -  if (aNewMeshDS)
 -    aNewMeshDS->Modified();
 +  newMeshDS->Modified();
  
 -  return aNewMesh._retn();
 +  return newMesh._retn();
  }
  
  //================================================================================
@@@ -3338,8 -3352,8 +3331,8 @@@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( S
              // write applied hypotheses if exist
              SALOMEDS::SObject_wrap myHypBranch;
              found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch.inout() );
 -            if ( found && !shapeRefFound && hasShape) { // remove applied hyps
 +            if ( found && !shapeRefFound && hasShape ) { // remove applied hyps
-               myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
+               aStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
              }
              if ( found && (shapeRefFound || !hasShape) ) {
                aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
Simple merge
@@@ -492,7 -499,7 +499,7 @@@ SALOMEDS::SObject_ptr SMESH_Gen_i::Publ
    // Publishing a hypothesis or algorithm
    SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( theIOR );
    if ( aSO->_is_nil() && !aHyp->_is_nil() )
-     aSO = PublishHypothesis( theStudy, aHyp, theName );
 -    aSO = PublishHypothesis( aHyp );
++    aSO = PublishHypothesis( aHyp, theName );
  
    // Publishing a group
    SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(theIOR);
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -186,23 -136,16 +186,23 @@@ class StdMeshersBuilder_Segment(Mesh_Al
          hyp.SetUsePreestimatedLength( length == 0.0 )
          return hyp
  
 -    ## Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
 -    #  @param n for the number of segments that cut an edge
 -    #  @param s for the scale factor (optional)
 -    #  @param reversedEdges is a list of edges to mesh using reversed orientation.
 -    #                       A list item can also be a tuple (edge, 1st_vertex_of_edge)
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - create a new one
 -    #  @return an instance of StdMeshers_NumberOfSegments hypothesis
 -    #  @ingroup l3_hypos_1dhyps
      def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0):
-       Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
 +        """
-                   A list item can also be a tuple (edge, 1st_vertex_of_edge)
++        Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
 +
 +        Parameters:
 +            n: for the number of segments that cut an edge
 +            s: for the scale factor (optional)
 +            reversedEdges: is a list of edges to mesh using reversed orientation.
-                   the same parameters, else (default) - create a new one
++                    A list item can also be a tuple (edge, 1st_vertex_of_edge)
 +            UseExisting: if ==true - searches for an existing hypothesis created with
-           an instance of StdMeshers_NumberOfSegments hypothesis
++                    the same parameters, else (default) - create a new one
 +    
 +        Returns: 
-       
++            an instance of StdMeshers_NumberOfSegments hypothesis
 +        """
 +    
++        
          if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
              reversedEdges, UseExisting = [], reversedEdges
          entry = self.MainShapeEntry()
          hyp.SetObjectEntry( entry )
          return hyp
  
 -    ## Private method
 -    #  
 -    #  Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
      def _compareNumberOfSegments(self, hyp, args):
-       Private method
-       Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
 +        """
++        Private method
++        Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
 +        """
          if hyp.GetNumberOfSegments() == args[0]:
              if len(args) == 3:
                  if hyp.GetReversedEdges() == args[1]:
                                  return True
          return False
  
 -    ## Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
 -    #  within the given range and considering (1) deflection of segments from the edge
 -    #  and (2) distance from segments to closest edges and faces to have segment length
 -    #  not longer than two times shortest distances to edges and faces.
 -    #  @param minSize defines the minimal allowed segment length
 -    #  @param maxSize defines the maximal allowed segment length
 -    #  @param deflection defines the maximal allowed distance from a segment to an edge
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - creates a new one
 -    #  @return an instance of StdMeshers_Adaptive1D hypothesis
 -    #  @ingroup l3_hypos_1dhyps
      def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
-       
 +        """
 +        Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
 +        within the given range and considering (1) deflection of segments from the edge
 +        and (2) distance from segments to closest edges and faces to have segment length
 +        not longer than two times shortest distances to edges and faces.
 +
 +        Parameters:
 +            minSize: defines the minimal allowed segment length
 +            maxSize: defines the maximal allowed segment length
 +            deflection: defines the maximal allowed distance from a segment to an edge
 +            UseExisting: if ==true - searches for an existing hypothesis created with
 +                the same parameters, else (default) - creates a new one
 +
 +        Returns:
 +            an instance of StdMeshers_Adaptive1D hypothesis
 +        """
++        
          from salome.smesh.smeshBuilder import IsEqual
          compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
                                        IsEqual(hyp.GetMaxSize(), args[1]) and \
          hyp.SetDeflection(deflection)
          return hyp
  
 -    ## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
 -    #  that changes in arithmetic progression
 -    #  @param start defines the length of the first segment
 -    #  @param end   defines the length of the last  segment
 -    #  @param reversedEdges is a list of edges to mesh using reversed orientation.
 -    #                       A list item can also be a tuple (edge, 1st_vertex_of_edge)
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - creates a new one
 -    #  @return an instance of StdMeshers_Arithmetic1D hypothesis
 -    #  @ingroup l3_hypos_1dhyps
      def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0):
-       """
-       Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
-               that changes in arithmetic progression
-       Parameters:
-           start: defines the length of the first segment
-           end:   defines the length of the last  segment
-           reversedEdges: is a list of edges to mesh using reversed orientation.
-               A list item can also be a tuple (edge, 1st_vertex_of_edge)
-           UseExisting: if ==true - searches for an existing hypothesis created with
-               the same parameters, else (default) - creates a new one
-       Returns:
-               an instance of StdMeshers_Arithmetic1D hypothesis
-       """
++        """
++        Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
++                that changes in arithmetic progression
++
++        Parameters:
++            start: defines the length of the first segment
++            end:   defines the length of the last  segment
++            reversedEdges: is a list of edges to mesh using reversed orientation.
++                A list item can also be a tuple (edge, 1st_vertex_of_edge)
++            UseExisting: if ==true - searches for an existing hypothesis created with
++                the same parameters, else (default) - creates a new one
++
++        Returns:
++                an instance of StdMeshers_Arithmetic1D hypothesis
++        """
 +        
          if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
              reversedEdges, UseExisting = [], reversedEdges
          reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
          hyp.SetObjectEntry( entry )
          return hyp
  
 -    ## Defines "GeometricProgression" hypothesis to cut an edge in several
 -    #  segments with a length that changes in Geometric progression
 -    #  @param start defines the length of the first segment
 -    #  @param ratio defines the common ratio of the geometric progression
 -    #  @param reversedEdges is a list of edges to mesh using reversed orientation.
 -    #                       A list item can also be a tuple (edge, 1st_vertex_of_edge)
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - creates a new one
 -    #  @return an instance of StdMeshers_Geometric1D hypothesis
 -    #  @ingroup l3_hypos_1dhyps
      def GeometricProgression(self, start, ratio, reversedEdges=[], UseExisting=0):
-       """
-           Defines "GeometricProgression" hypothesis to cut an edge in several
-               segments with a length that changes in Geometric progression
-           Parameters:
-               start: defines the length of the first segment
-               ratio: defines the common ratio of the geometric progression
-               reversedEdges: is a list of edges to mesh using reversed orientation.
-                   A list item can also be a tuple (edge, 1st_vertex_of_edge)
-               UseExisting: if ==true - searches for an existing hypothesis created with
-                   the same parameters, else (default) - creates a new one
-           Returns:
-               an instance of StdMeshers_Geometric1D hypothesis
-       """
++        """
++            Defines "GeometricProgression" hypothesis to cut an edge in several
++                segments with a length that changes in Geometric progression
++
++            Parameters:
++                start: defines the length of the first segment
++                ratio: defines the common ratio of the geometric progression
++                reversedEdges: is a list of edges to mesh using reversed orientation.
++                    A list item can also be a tuple (edge, 1st_vertex_of_edge)
++                UseExisting: if ==true - searches for an existing hypothesis created with
++                    the same parameters, else (default) - creates a new one
++
++            Returns:
++                an instance of StdMeshers_Geometric1D hypothesis
++        """
 +        
          reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
          entry = self.MainShapeEntry()
          from salome.smesh.smeshBuilder import IsEqual
          hyp.SetObjectEntry( entry )
          return hyp
  
 -    ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter
 -    # on curve from 0 to 1 (additionally it is neecessary to check
 -    # orientation of edges and create list of reversed edges if it is
 -    # needed) and sets numbers of segments between given points (default
 -    # values are 1)
 -    #  @param points defines the list of parameters on curve
 -    #  @param nbSegs defines the list of numbers of segments
 -    #  @param reversedEdges is a list of edges to mesh using reversed orientation.
 -    #                       A list item can also be a tuple (edge, 1st_vertex_of_edge)
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - creates a new one
 -    #  @return an instance of StdMeshers_FixedPoints1D hypothesis
 -    #  @ingroup l3_hypos_1dhyps
      def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
-       Defines "FixedPoints1D" hypothesis to cut an edge using parameter
-               on curve from 0 to 1 (additionally it is neecessary to check
-               orientation of edges and create list of reversed edges if it is
-               needed) and sets numbers of segments between given points (default
-               values are 1)
-       Parameters:
-           points: defines the list of parameters on curve
-           nbSegs: defines the list of numbers of segments
-           reversedEdges: is a list of edges to mesh using reversed orientation.
-               A list item can also be a tuple (edge, 1st_vertex_of_edge)
-           UseExisting: if ==true - searches for an existing hypothesis created with
-               the same parameters, else (default) - creates a new one
-       Returns:
-               an instance of StdMeshers_FixedPoints1D hypothesis
-       """
 +        """
++        Defines "FixedPoints1D" hypothesis to cut an edge using parameter
++                on curve from 0 to 1 (additionally it is neecessary to check
++                orientation of edges and create list of reversed edges if it is
++                needed) and sets numbers of segments between given points (default
++                values are 1)
++
++        Parameters:
++            points: defines the list of parameters on curve
++            nbSegs: defines the list of numbers of segments
++            reversedEdges: is a list of edges to mesh using reversed orientation.
++                A list item can also be a tuple (edge, 1st_vertex_of_edge)
++            UseExisting: if ==true - searches for an existing hypothesis created with
++                the same parameters, else (default) - creates a new one
++
++        Returns:
++                an instance of StdMeshers_FixedPoints1D hypothesis
++        """
 +        
          if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
              reversedEdges, UseExisting = [], reversedEdges
          reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
          hyp.SetObjectEntry(entry)
          return hyp
  
 -    ## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
 -    #  @param start defines the length of the first segment
 -    #  @param end   defines the length of the last  segment
 -    #  @param reversedEdges is a list of edges to mesh using reversed orientation.
 -    #                       A list item can also be a tuple (edge, 1st_vertex_of_edge)
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - creates a new one
 -    #  @return an instance of StdMeshers_StartEndLength hypothesis
 -    #  @ingroup l3_hypos_1dhyps
      def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0):
-       
 +        """
 +        Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
 +
 +        Parameters:
 +            start: defines the length of the first segment
 +            end:   defines the length of the last  segment
 +            reversedEdges: is a list of edges to mesh using reversed orientation.
 +                A list item can also be a tuple (edge, 1st_vertex_of_edge)
 +            UseExisting: if ==true - searches for an existing hypothesis created with
 +                the same parameters, else (default) - creates a new one
 +
 +        Returns:
 +            an instance of StdMeshers_StartEndLength hypothesis
 +        """
++        
          if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
              reversedEdges, UseExisting = [], reversedEdges
          reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
          hyp.SetObjectEntry( entry )
          return hyp
  
 -    ## Defines "Deflection1D" hypothesis
 -    #  @param d for the deflection
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with
 -    #                     the same parameters, else (default) - create a new one
 -    #  @ingroup l3_hypos_1dhyps
      def Deflection1D(self, d, UseExisting=0):
-       """
-       Defines "Deflection1D" hypothesis
++        """
++        Defines "Deflection1D" hypothesis
 +
-       Parameters:
++        Parameters:
 +            d: for the deflection
 +            UseExisting: if ==true - searches for an existing hypothesis created with
 +                the same parameters, else (default) - create a new one
-       """
++        """
 +        
          from salome.smesh.smeshBuilder import IsEqual
          compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0])
          hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun)
          hyp.SetDeflection(d)
          return hyp
  
 -    ## Defines "Propagation" hypothesis that propagates 1D hypotheses
 -    #  from an edge where this hypothesis is assigned to
 -    #  on all other edges that are at the opposite side in case of quadrangular faces
 -    #  This hypothesis should be assigned to an edge to propagate a hypothesis from.
 -    #  @ingroup l3_hypos_additi
      def Propagation(self):
-       """
-       Defines "Propagation" hypothesis that propagates 1D hypotheses
-               from an edge where this hypothesis is assigned to
-               on all other edges that are at the opposite side in case of quadrangular faces
-               This hypothesis should be assigned to an edge to propagate a hypothesis from.
-       """
++        """
++        Defines "Propagation" hypothesis that propagates 1D hypotheses
++                from an edge where this hypothesis is assigned to
++                on all other edges that are at the opposite side in case of quadrangular faces
++                This hypothesis should be assigned to an edge to propagate a hypothesis from.
++        """
 +        
          return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp)
  
 -    ## Defines "Propagation of Node Distribution" hypothesis that propagates
 -    #  distribution of nodes from an edge where this hypothesis is assigned to,
 -    #  to opposite edges of quadrangular faces, so that number of segments on all these
 -    #  edges will be the same, as well as relations between segment lengths. 
 -    #  @ingroup l3_hypos_additi
      def PropagationOfDistribution(self):
-       """
-       Defines "Propagation of Node Distribution" hypothesis that propagates
-               distribution of nodes from an edge where this hypothesis is assigned to,
-               to opposite edges of quadrangular faces, so that number of segments on all these
-               edges will be the same, as well as relations between segment lengths. 
-       """
++        """
++        Defines "Propagation of Node Distribution" hypothesis that propagates
++                distribution of nodes from an edge where this hypothesis is assigned to,
++                to opposite edges of quadrangular faces, so that number of segments on all these
++                edges will be the same, as well as relations between segment lengths. 
++        """
 +        
          return self.Hypothesis("PropagOfDistribution", UseExisting=1,
                                 CompareMethod=self.CompareEqualHyp)
  
 -    ## Defines "AutomaticLength" hypothesis
 -    #  @param fineness for the fineness [0-1]
 -    #  @param UseExisting if ==true - searches for an existing hypothesis created with the
 -    #                     same parameters, else (default) - create a new one
 -    #  @ingroup l3_hypos_1dhyps
      def AutomaticLength(self, fineness=0, UseExisting=0):
-       """
-       Defines "AutomaticLength" hypothesis
-       Parameters:
-           fineness: for the fineness [0-1]
-           UseExisting: if ==true - searches for an existing hypothesis created with the
-               same parameters, else (default) - create a new one
-       """
++        """
++        Defines "AutomaticLength" hypothesis
++
++        Parameters:
++            fineness: for the fineness [0-1]
++            UseExisting: if ==true - searches for an existing hypothesis created with the
++                same parameters, else (default) - create a new one
++        """
 +        
          from salome.smesh.smeshBuilder import IsEqual
          compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0])
          hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting,
          hyp.SetFineness( fineness )
          return hyp
  
 -    ## Defines "SegmentLengthAroundVertex" hypothesis
 -    #  @param length for the segment length
 -    #  @param vertex for the length localization: the vertex index [0,1] | vertex object.
 -    #         Any other integer value means that the hypothesis will be set on the
 -    #         whole 1D shape, where Mesh_Segment algorithm is assigned.
 -    #  @param UseExisting if ==true - searches for an  existing hypothesis created with
 -    #                   the same parameters, else (default) - creates a new one
 -    #  @ingroup l3_algos_segmarv
      def LengthNearVertex(self, length, vertex=0, UseExisting=0):
-       """
-       Defines "SegmentLengthAroundVertex" hypothesis
-       Parameters:
-           length: for the segment length
-           vertex: for the length localization: the vertex index [0,1] | vertex object.
-               Any other integer value means that the hypothesis will be set on the
-               whole 1D shape, where Mesh_Segment algorithm is assigned.
-           UseExisting: if ==true - searches for an  existing hypothesis created with
-               the same parameters, else (default) - creates a new one
-       """
++        """
++        Defines "SegmentLengthAroundVertex" hypothesis
++
++        Parameters:
++            length: for the segment length
++            vertex: for the length localization: the vertex index [0,1] | vertex object.
++                Any other integer value means that the hypothesis will be set on the
++                whole 1D shape, where Mesh_Segment algorithm is assigned.
++            UseExisting: if ==true - searches for an  existing hypothesis created with
++                the same parameters, else (default) - creates a new one
++        """
 +        
          import types
          store_geom = self.geom
-         if type(vertex) is types.IntType:
+         if isinstance(vertex, int):
              if vertex == 0 or vertex == 1:
                  from salome.geom import geomBuilder
                  vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.geomBuilder.ShapeType["VERTEX"],True)[vertex]
          hyp.SetLength( length )
          return hyp
  
 -    ## Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
 -    #  If the 2D mesher sees that all boundary edges are quadratic,
 -    #  it generates quadratic faces, else it generates linear faces using
 -    #  medium nodes as if they are vertices.
 -    #  The 3D mesher generates quadratic volumes only if all boundary faces
 -    #  are quadratic, else it fails.
 -    #
 -    #  @ingroup l3_hypos_additi
      def QuadraticMesh(self):
-       """
-       Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
-       If the 2D mesher sees that all boundary edges are quadratic,
-       it generates quadratic faces, else it generates linear faces using
-       medium nodes as if they are vertices.
-       The 3D mesher generates quadratic volumes only if all boundary faces
-       are quadratic, else it fails.
-       """
-       
++        """
++        Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
++        If the 2D mesher sees that all boundary edges are quadratic,
++        it generates quadratic faces, else it generates linear faces using
++        medium nodes as if they are vertices.
++        The 3D mesher generates quadratic volumes only if all boundary faces
++        are quadratic, else it fails.
++        """
++        
          hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp)
          return hyp
  
@@@ -564,35 -447,28 +564,35 @@@ class StdMeshersBuilder_CompositeSegmen
  
      pass # end of StdMeshersBuilder_CompositeSegment class
  
 -## Defines a segment 1D algorithm for discretization of edges with Python function
 -#
 -#  It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
 -#
 -#  @ingroup l3_algos_basic
  class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
-       It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
 +    """
 +    Defines a segment 1D algorithm for discretization of edges with Python function
++        It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
 +    """
 +    
  
 -    ## name of the dynamic method in smeshBuilder.Mesh class
 -    #  @internal
      meshMethod = "Segment"
 -    ## type of algorithm used with helper function in smeshBuilder.Mesh class
 -    #  @internal
 +    """
 +    name of the dynamic method in smeshBuilder.Mesh class
 +    """
      algoType   = PYTHON
 -    ## doc string of the method
 -    #  @internal
 +    """
 +    type of algorithm used with helper function in smeshBuilder.Mesh class
 +    """
      docHelper  = "Creates segment 1D algorithm for edges"
 +    """
 +    doc string of the method
 +    """
  
 -    ## Private constructor.
 -    #  @param mesh parent mesh object algorithm is assigned to
 -    #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
 -    #              if it is @c 0 (default), the algorithm is assigned to the main shape
      def __init__(self, mesh, geom=0):
 +        """
 +        Private constructor.
 +
 +        Parameters:
 +            mesh: parent mesh object algorithm is assigned to
 +            geom: geometry (shape/sub-shape) algorithm is assigned to;
 +                if it is :code:`0` (default), the algorithm is assigned to the main shape
 +        """
          import Python1dPlugin
          self.Create(mesh, geom, self.algoType, "libPython1dEngine.so")
          pass
@@@ -801,18 -646,14 +801,18 @@@ class StdMeshersBuilder_Quadrangle(Mesh
          self.params.SetEnforcedNodes( enfVertices, pStructs )
          return self.params
  
 -    ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
 -    #   quadrangles are built in the transition area along the finer meshed sides,
 -    #   iff the total quantity of segments on all four sides of the face is even.
 -    #  @param reversed if True, transition area is located along the coarser meshed sides.
 -    #  @param UseExisting: if ==true - searches for the existing hypothesis created with
 -    #                  the same parameters, else (default) - creates a new one
 -    #  @ingroup l3_hypos_quad
      def QuadranglePreference(self, reversed=False, UseExisting=0):
-       Parameters:
 +        """
 +        Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
 +            quadrangles are built in the transition area along the finer meshed sides,
 +            if the total quantity of segments on all four sides of the face is even.
 +
-       
++        Parameters:
 +            reversed: if True, transition area is located along the coarser meshed sides.
 +        UseExisting: if ==true - searches for the existing hypothesis created with
 +            the same parameters, else (default) - creates a new one
 +        """
++        
          if reversed:
              return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting)
          return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting)
@@@ -1205,26 -980,18 +1205,26 @@@ class StdMeshersBuilder_Prism3D(Mesh_Al
              pass
          pass
  
 -    ## Return 3D hypothesis holding the 1D one
      def Get3DHypothesis(self):
 +        """
 +        Returns: 
 +            3D hypothesis holding the 1D one
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          return self.distribHyp
  
 -    ## Private method creating a 1D hypothesis and storing it in the LayerDistribution
 -    #  hypothesis. Returns the created hypothesis
      def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
 +        """
 +        Private method creating a 1D hypothesis and storing it in the LayerDistribution
 +            hypothesis. 
 +
 +        Returns:
 +            the created hypothesis
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          if not self.nbLayers is None:
              self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
          self.distribHyp.SetLayerDistribution( hyp )
          return hyp
  
 -    ## Defines "NumberOfLayers" hypothesis, specifying the number of layers of
 -    #  prisms to build between the inner and outer shells
 -    #  @param n number of layers
 -    #  @param UseExisting if ==true - searches for the existing hypothesis created with
 -    #                     the same parameters, else (default) - creates a new one
      def NumberOfLayers(self, n, UseExisting=0):
 +        """
 +        Defines "NumberOfLayers" hypothesis, specifying the number of layers of
 +            prisms to build between the inner and outer shells
 +
 +        Parameters:
 +            n: number of layers
 +            UseExisting: if ==true - searches for the existing hypothesis created with
 +                the same parameters, else (default) - creates a new one
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
          from salome.smesh.smeshBuilder import IsEqual
          self.nbLayers.SetNumberOfLayers( n )
          return self.nbLayers
  
 -    ## Defines "LocalLength" hypothesis, specifying the segment length
 -    #  to build between the inner and the outer shells
 -    #  @param l the length of segments
 -    #  @param p the precision of rounding
      def LocalLength(self, l, p=1e-07):
 +        """
 +        Defines "LocalLength" hypothesis, specifying the segment length
 +            to build between the inner and the outer shells
 +
 +        Parameters:
 +            l: the length of segments
 +            p: the precision of rounding
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          hyp = self.OwnHypothesis("LocalLength", [l,p])
          hyp.SetLength(l)
          hyp.SetPrecision(p)
          return hyp
  
 -    ## Defines "NumberOfSegments" hypothesis, specifying the number of layers of
 -    #  prisms to build between the inner and the outer shells.
 -    #  @param n the number of layers
 -    #  @param s the scale factor (optional)
      def NumberOfSegments(self, n, s=[]):
 +        """
 +        Defines "NumberOfSegments" hypothesis, specifying the number of layers of
 +            prisms to build between the inner and the outer shells.
 +
 +        Parameters:
 +            n: the number of layers
 +            s: the scale factor (optional)
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          if not s:
              hyp = self.OwnHypothesis("NumberOfSegments", [n])
          hyp.SetNumberOfSegments(n)
          return hyp
  
 -    ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
 -    #  to build between the inner and the outer shells with a length that changes
 -    #  in arithmetic progression
 -    #  @param start  the length of the first segment
 -    #  @param end    the length of the last  segment
      def Arithmetic1D(self, start, end ):
 +        """
 +        Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
 +            to build between the inner and the outer shells with a length that changes
 +            in arithmetic progression
 +
 +        Parameters:
 +            start:  the length of the first segment
 +            end:    the length of the last  segment
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
          hyp.SetLength(start, 1)
          hyp.SetLength(end  , 0)
          return hyp
  
 -    ## Defines "GeometricProgression" hypothesis, specifying the distribution of segments
 -    #  to build between the inner and the outer shells with a length that changes
 -    #  in Geometric progression
 -    #  @param start  the length of the first segment
 -    #  @param ratio  the common ratio of the geometric progression
      def GeometricProgression(self, start, ratio ):
 +        """
 +        Defines "GeometricProgression" hypothesis, specifying the distribution of segments
 +            to build between the inner and the outer shells with a length that changes
 +            in Geometric progression
 +
 +        Parameters:
 +            start:  the length of the first segment
 +            ratio:  the common ratio of the geometric progression
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
          hyp.SetStartLength( start )
          hyp.SetCommonRatio( ratio )
          return hyp
  
 -    ## Defines "StartEndLength" hypothesis, specifying distribution of segments
 -    #  to build between the inner and the outer shells as geometric length increasing
 -    #  @param start for the length of the first segment
 -    #  @param end   for the length of the last  segment
      def StartEndLength(self, start, end):
 +        """
 +        Defines "StartEndLength" hypothesis, specifying distribution of segments
 +            to build between the inner and the outer shells as geometric length increasing
 +
 +        Parameters:
 +            start: for the length of the first segment
 +        end:   for the length of the last  segment
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          hyp = self.OwnHypothesis("StartEndLength", [start, end])
          hyp.SetLength(start, 1)
          hyp.SetLength(end  , 0)
          return hyp
  
 -    ## Defines "AutomaticLength" hypothesis, specifying the number of segments
 -    #  to build between the inner and outer shells
 -    #  @param fineness defines the quality of the mesh within the range [0-1]
      def AutomaticLength(self, fineness=0):
 +        """
 +        Defines "AutomaticLength" hypothesis, specifying the number of segments
 +            to build between the inner and outer shells
 +
 +        Parameters:
 +            fineness: defines the quality of the mesh within the range [0-1]
 +        """
          if self.algoType != "RadialPrism_3D":
-             print "Prism_3D algorithm doesn't support any hypothesis"
+             print("Prism_3D algorithm doesn't support any hypothesis")
              return None
          hyp = self.OwnHypothesis("AutomaticLength")
          hyp.SetFineness( fineness )
@@@ -30,10 -94,85 +34,85 @@@ from   salome.smesh.smesh_algorithm imp
  import SALOME
  import SALOMEDS
  import os
+ import inspect
+ # In case the omniORBpy EnumItem class does not fully support Python 3
+ # (for instance in version 4.2.1-2), the comparison ordering methods must be
+ # defined
+ #
+ try:
+     SMESH.Entity_Triangle < SMESH.Entity_Quadrangle
+ except TypeError:
+     def enumitem_eq(self, other):
+         try:
+             if isinstance(other, omniORB.EnumItem):
+                 if other._parent_id == self._parent_id:
+                     return self._v == other._v
+                 else:
+                     return self._parent_id == other._parent_id
+             else:
+                 return id(self) == id(other)
+         except:
+             return id(self) == id(other)
+     def enumitem_lt(self, other):
+         try:
+             if isinstance(other, omniORB.EnumItem):
+                 if other._parent_id == self._parent_id:
+                     return self._v < other._v
+                 else:
+                     return self._parent_id < other._parent_id
+             else:
+                 return id(self) < id(other)
+         except:
+             return id(self) < id(other)
+     def enumitem_le(self, other):
+         try:
+             if isinstance(other, omniORB.EnumItem):
+                 if other._parent_id == self._parent_id:
+                     return self._v <= other._v
+                 else:
+                     return self._parent_id <= other._parent_id
+             else:
+                 return id(self) <= id(other)
+         except:
+             return id(self) <= id(other)
+     def enumitem_gt(self, other):
+         try:
+             if isinstance(other, omniORB.EnumItem):
+                 if other._parent_id == self._parent_id:
+                     return self._v > other._v
+                 else:
+                     return self._parent_id > other._parent_id
+             else:
+                 return id(self) > id(other)
+         except:
+             return id(self) > id(other)
+     def enumitem_ge(self, other):
+         try:
+             if isinstance(other, omniORB.EnumItem):
+                 if other._parent_id == self._parent_id:
+                     return self._v >= other._v
+                 else:
+                     return self._parent_id >= other._parent_id
+             else:
+                 return id(self) >= id(other)
+         except:
+             return id(self) >= id(other)
+     omniORB.EnumItem.__eq__ = enumitem_eq
+     omniORB.EnumItem.__lt__ = enumitem_lt
+     omniORB.EnumItem.__le__ = enumitem_le
+     omniORB.EnumItem.__gt__ = enumitem_gt
+     omniORB.EnumItem.__ge__ = enumitem_ge
  
 -## Private class used to workaround a problem that sometimes isinstance(m, Mesh) returns False
 -#
  class MeshMeta(type):
 +    """Private class used to workaround a problem that sometimes isinstance(m, Mesh) returns False
 +    """
      def __instancecheck__(cls, inst):
          """Implement isinstance(inst, cls)."""
          return any(cls.__subclasscheck__(c)
@@@ -102,14 -237,11 +181,13 @@@ def __initPointStruct(point,*args)
      pass
  SMESH.PointStruct.__init__ = __initPointStruct
  
 -## Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables.
 -#  Parameters are stored in AxisStruct.parameters attribute
  def __initAxisStruct(ax,*args):
 +    """
 +    Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables.
 +    Parameters are stored in AxisStruct.parameters attribute
 +    """
      if len( args ) != 6:
-         raise RuntimeError,\
-               "Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args ))
+         raise RuntimeError("Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args )))
      ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args)
      pass
  SMESH.AxisStruct.__init__ = __initAxisStruct
@@@ -160,12 -281,10 +233,12 @@@ def GetName(obj)
              # unknown non-CORBA object, having GetName() method
              return obj.GetName()
          pass
-     raise RuntimeError, "Null or invalid object"
+     raise RuntimeError("Null or invalid object")
  
 -## Print error message if a hypothesis was not assigned.
  def TreatHypoStatus(status, hypName, geomName, isAlgo, mesh):
 +    """
 +    Print error message if a hypothesis was not assigned.
 +    """
      if isAlgo:
          hypType = "algorithm"
      else:
          pass
      reason = ""
      if hasattr( status, "__getitem__" ):
-         status,reason = status[0],status[1]
-     if status == HYP_UNKNOWN_FATAL :
+         status, reason = status[0], status[1]
+     if status == HYP_UNKNOWN_FATAL:
          reason = "for unknown reason"
-     elif status == HYP_INCOMPATIBLE :
+     elif status == HYP_INCOMPATIBLE:
          reason = "this hypothesis mismatches the algorithm"
-     elif status == HYP_NOTCONFORM :
+     elif status == HYP_NOTCONFORM:
          reason = "a non-conform mesh would be built"
-     elif status == HYP_ALREADY_EXIST :
+     elif status == HYP_ALREADY_EXIST:
          if isAlgo: return # it does not influence anything
          reason = hypType + " of the same dimension is already assigned to this shape"
-     elif status == HYP_BAD_DIM :
+     elif status == HYP_BAD_DIM:
          reason = hypType + " mismatches the shape"
 -    elif status == HYP_CONCURENT:
 +    elif status == HYP_CONCURRENT :
          reason = "there are concurrent hypotheses on sub-shapes"
-     elif status == HYP_BAD_SUBSHAPE :
+     elif status == HYP_BAD_SUBSHAPE:
          reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
      elif status == HYP_BAD_GEOMETRY:
          reason = "the algorithm is not applicable to this geometry"
              if meshName and meshName != NO_NAME:
                  where = '"%s" shape in "%s" mesh ' % ( geomName, meshName )
      if status < HYP_UNKNOWN_FATAL and where:
-         print '"%s" was assigned to %s but %s' %( hypName, where, reason )
+         print('"%s" was assigned to %s but %s' %( hypName, where, reason ))
      elif where:
-         print '"%s" was not assigned to %s : %s' %( hypName, where, reason )
+         print('"%s" was not assigned to %s : %s' %( hypName, where, reason ))
      else:
-         print '"%s" was not assigned : %s' %( hypName, reason )
+         print('"%s" was not assigned : %s' %( hypName, reason ))
          pass
  
 -## Private method. Add geom (sub-shape of the main shape) into the study if not yet there
  def AssureGeomPublished(mesh, geom, name=''):
 +    """
 +    Private method. Add geom (sub-shape of the main shape) into the study if not yet there
 +    """
      if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
          return
-     if not geom.GetStudyEntry() and \
-            mesh.smeshpyD.GetCurrentStudy():
-         ## set the study
-         studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId()
-         if studyID != mesh.geompyD.myStudyId:
-             mesh.geompyD.init_geom( mesh.smeshpyD.GetCurrentStudy())
+     if not geom.GetStudyEntry():
          ## get a name
          if not name and geom.GetShapeType() != geomBuilder.GEOM.COMPOUND:
              # for all groups SubShapeName() return "Compound_-1"
          mesh.geompyD.addToStudyInFather( mesh.geom, geom, name )
      return
  
 -## Return the first vertex of a geometrical edge by ignoring orientation
  def FirstVertexOnCurve(mesh, edge):
 +    """
 +    Returns:
 +        the first vertex of a geometrical edge by ignoring orientation
 +    """
      vv = mesh.geompyD.SubShapeAll( edge, geomBuilder.geomBuilder.ShapeType["VERTEX"])
      if not vv:
-         raise TypeError, "Given object has no vertices"
+         raise TypeError("Given object has no vertices")
      if len( vv ) == 1: return vv[0]
      v0   = mesh.geompyD.MakeVertexOnCurve(edge,0.)
      xyz  = mesh.geompyD.PointCoordinates( v0 ) # coords of the first vertex
@@@ -269,12 -383,10 +337,12 @@@ engine = Non
  doLcc = False
  created = False
  
- class smeshBuilder(object, SMESH._objref_SMESH_Gen):
 -## This class allows to create, load or manipulate meshes.
 -#  It has a set of methods to create, load or copy meshes, to combine several meshes, etc.
 -#  It also has methods to get infos and measure meshes.
 -class smeshBuilder(SMESH._objref_SMESH_Gen):
++class smeshBuilder( SMESH._objref_SMESH_Gen, object ):
 +    """
 +    This class allows to create, load or manipulate meshes.
 +    It has a set of methods to create, load or copy meshes, to combine several meshes, etc.
 +    It also has methods to get infos and measure meshes.
 +    """
  
      # MirrorType enumeration
      POINT = SMESH_MeshEditor.POINT
          global engine
          global smeshInst
          global doLcc
--        #print "==== __new__", engine, smeshInst, doLcc
++        #print("==== __new__", engine, smeshInst, doLcc)
  
          if smeshInst is None:
              # smesh engine is either retrieved from engine, or created
                      # FindOrLoadComponent called:
                      # 1. CORBA resolution of server
                      # 2. the __new__ method is called again
--                    #print "==== smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc
++                    #print("==== smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc)
                      smeshInst = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" )
              else:
                  # FindOrLoadComponent not called
                  if smeshInst is None:
                      # smeshBuilder instance is created from lcc.FindOrLoadComponent
--                    #print "==== smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc
++                    #print("==== smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc)
                      smeshInst = super(smeshBuilder,cls).__new__(cls)
                  else:
                      # smesh engine not created: existing engine found
--                    #print "==== existing ", engine, smeshInst, doLcc
++                    #print("==== existing ", engine, smeshInst, doLcc)
                      pass
--            #print "====1 ", smeshInst
++            #print("====1 ", smeshInst)
              return smeshInst
  
--        #print "====2 ", smeshInst
++        #print("====2 ", smeshInst)
          return smeshInst
  
-     def __init__(self):
+     def __init__(self, *args):
          global created
--        #print "--------------- smeshbuilder __init__ ---", created
++        #print("--------------- smeshbuilder __init__ ---", created)
          if not created:
-           created = True
-           SMESH._objref_SMESH_Gen.__init__(self)
+             created = True
+             SMESH._objref_SMESH_Gen.__init__(self, *args)
 -    ## Dump component to the Python script
 -    #  This method overrides IDL function to allow default values for the parameters.
 -    #  @ingroup l1_auxiliary
 -    def DumpPython(self, theIsPublished=True, theIsMultiFile=True):
 -        return SMESH._objref_SMESH_Gen.DumpPython(self, theIsPublished, theIsMultiFile)
 -
 -    ## Set mode of DumpPython(), \a historical or \a snapshot.
 -    #  In the \a historical mode, the Python Dump script includes all commands
 -    #  performed by SMESH engine. In the \a snapshot mode, commands
 -    #  relating to objects removed from the Study are excluded from the script
 -    #  as well as commands not influencing the current state of meshes
 -    #  @ingroup l1_auxiliary
 +
 +    def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True):
 +        """
 +        Dump component to the Python script.
 +        This method overrides IDL function to allow default values for the parameters.
 +        """
 +
 +        return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
 +
      def SetDumpPythonHistorical(self, isHistorical):
 +        """
 +        Set mode of DumpPython(), *historical* or *snapshot*.
 +        In the *historical* mode, the Python Dump script includes all commands
 +        performed by SMESH engine. In the *snapshot* mode, commands
 +        relating to objects removed from the Study are excluded from the script
 +        as well as commands not influencing the current state of meshes
 +        """
 +
          if isHistorical: val = "true"
          else:            val = "false"
          SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val)
  
-     def init_smesh(self,theStudy,geompyD = None):
-         """
-         Set the current study and Geometry component
 -    ## Set Geometry component
 -    #  @ingroup l1_auxiliary
 -    def init_smesh(self,isPublished = True,geompyD = None):
 -        #print "init_smesh"
++    def init_smesh(self,geompyD = None):
 +        """
-         #print "init_smesh"
-         self.SetCurrentStudy(theStudy,geompyD)
-         if theStudy:
-             global notebook
-             notebook.myStudy = theStudy
++        Set Geometry component
++        """    
++        #print("init_smesh")
+         self.UpdateStudy(geompyD)
 -        if isPublished:
 -            global notebook
 -            notebook.myStudy = salome.myStudy
 -
 -    ## Create a mesh. This can be either an empty mesh, possibly having an underlying geometry,
 -    #  or a mesh wrapping a CORBA mesh given as a parameter.
 -    #  @param obj either (1) a CORBA mesh (SMESH._objref_SMESH_Mesh) got e.g. by calling
 -    #         salome.myStudy.FindObjectID("0:1:2:3").GetObject() or
 -    #         (2) a Geometrical object for meshing or
 -    #         (3) none.
 -    #  @param name the name for the new mesh.
 -    #  @return an instance of Mesh class.
 -    #  @ingroup l2_construct
++        notebook.myStudy = salome.myStudy
 +
      def Mesh(self, obj=0, name=0):
 +        """
 +        Create a mesh. This mesh can be either 
 +
 +        * an empty mesh not bound to geometry, if *obj* == 0
 +        * an empty mesh bound to geometry, if *obj* is GEOM.GEOM_Object
 +        * a mesh wrapping a :class:`CORBA mesh <SMESH.SMESH_Mesh>` given as *obj* parameter.
 +
 +        Parameters:
 +            obj: either 
 +
 +                   1. a :class:`CORBA mesh <SMESH.SMESH_Mesh>` got by calling e.g.
 +                      ::
 +
 +                        salome.myStudy.FindObjectID("0:1:2:3").GetObject() 
 +
 +                   2. a geometrical object for meshing
 +                   3. none.
 +            name: the name for the new mesh.
 +
 +        Returns:
 +            an instance of class :class:`Mesh`.
 +        """
 +
          if isinstance(obj,str):
              obj,name = name,obj
--        return Mesh(self,self.geompyD,obj,name)
++        return Mesh(self, self.geompyD, obj, name)
 +
 +    def EnumToLong(self,theItem):
 +        """
 +        Return a long value from enumeration
 +        """
 +
 +        return theItem._v
  
 -    ## Return a string representation of the color.
 -    #  To be used with filters.
 -    #  @param c color value (SALOMEDS.Color)
 -    #  @ingroup l1_auxiliary
      def ColorToString(self,c):
 +        """
 +        Convert SALOMEDS.Color to string.
 +        To be used with filters.
 +
 +        Parameters:
 +            c: color value (SALOMEDS.Color)
 +
 +        Returns:
 +            a string representation of the color.
 +        """
 +
          val = ""
          if isinstance(c, SALOMEDS.Color):
              val = "%s;%s;%s" % (c.R, c.G, c.B)
          elif isinstance(c, str):
              val = c
          else:
-             raise ValueError, "Color value should be of string or SALOMEDS.Color type"
+             raise ValueError("Color value should be of string or SALOMEDS.Color type")
          return val
  
 -    ## Get PointStruct from vertex
 -    #  @param theVertex a GEOM object(vertex)
 -    #  @return SMESH.PointStruct
 -    #  @ingroup l1_auxiliary
      def GetPointStruct(self,theVertex):
 +        """
 +        Get :class:`SMESH.PointStruct` from vertex
 +
 +        Parameters:
 +                theVertex (GEOM.GEOM_Object): vertex
 +
 +        Returns:
 +                :class:`SMESH.PointStruct`
 +        """
 +
          [x, y, z] = self.geompyD.PointCoordinates(theVertex)
          return PointStruct(x,y,z)
  
 -    ## Get DirStruct from vector
 -    #  @param theVector a GEOM object(vector)
 -    #  @return SMESH.DirStruct
 -    #  @ingroup l1_auxiliary
      def GetDirStruct(self,theVector):
 +        """
 +        Get :class:`SMESH.DirStruct` from vector
 +
 +        Parameters:
 +                theVector (GEOM.GEOM_Object): vector
 +
 +        Returns:
 +                :class:`SMESH.DirStruct`
 +        """
 +
          vertices = self.geompyD.SubShapeAll( theVector, geomBuilder.geomBuilder.ShapeType["VERTEX"] )
          if(len(vertices) != 2):
-             print "Error: vector object is incorrect."
+             print("Error: vector object is incorrect.")
              return None
          p1 = self.geompyD.PointCoordinates(vertices[0])
          p2 = self.geompyD.PointCoordinates(vertices[1])
          ior  = salome.orb.object_to_string(obj)
          SMESH._objref_SMESH_Gen.SetName(self, ior, name)
  
 -    ## Set the current mode
 -    #  @ingroup l1_auxiliary
      def SetEmbeddedMode( self,theMode ):
 +        """
 +        Set the current mode
 +        """
 +
          SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode)
  
 -    ## Get the current mode
 -    #  @ingroup l1_auxiliary
      def IsEmbeddedMode(self):
 +        """
 +        Get the current mode
 +        """
 +
          return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
 -    
 -    ## Update the current study. Calling UpdateStudy() allows to 
 -    #  update meshes at switching GEOM->SMESH
 -    #  @ingroup l1_auxiliary
 +
-     def SetCurrentStudy( self, theStudy, geompyD = None ):
-         """
-         Set the current study. Calling SetCurrentStudy( None ) allows to
-         switch **off** automatic pubilishing in the Study of mesh objects.
-         """
-         if not geompyD:
+     def UpdateStudy( self, geompyD = None  ):
++      """
++        Update the current study. Calling UpdateStudy() allows to 
++      update meshes at switching GEOM->SMESH
++      """
+         #self.UpdateStudy()
 -        if not geompyD:
++      if not geompyD:
              from salome.geom import geomBuilder
              geompyD = geomBuilder.geom
              pass
--        self.geompyD=geompyD
--        self.SetGeomEngine(geompyD)
-         SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy)
-         global notebook
-         if theStudy:
-             notebook = salome_notebook.NoteBook( theStudy )
-         else:
-             notebook = salome_notebook.NoteBook( salome_notebook.PseudoStudyForNoteBook() )
-         if theStudy:
-             sb = theStudy.NewBuilder()
-             sc = theStudy.FindComponent("SMESH")
-             if sc: sb.LoadWith(sc, self)
-             pass
 -        SMESH._objref_SMESH_Gen.UpdateStudy(self)
 -        sb = salome.myStudy.NewBuilder()
 -        sc = salome.myStudy.FindComponent("SMESH")
 -        if sc: sb.LoadWith(sc, self)
--        pass
-     def GetCurrentStudy(self):
-         """
-         Get the current study
-         """
 -        
 -    ## Sets enable publishing in the study. Calling SetEnablePublish( false ) allows to
 -    #  switch OFF publishing in the Study of mesh objects.
 -    #  @ingroup l1_auxiliary
++      self.geompyD=geompyD
++      self.SetGeomEngine(geompyD)
++      SMESH._objref_SMESH_Gen.UpdateStudy(self)
++      sb = salome.myStudy.NewBuilder()
++      sc = salome.myStudy.FindComponent("SMESH")
++      if sc:
++            sb.LoadWith(sc, self)
++      pass
++    
+     def SetEnablePublish( self, theIsEnablePublish ):
++      """
++        Sets enable publishing in the study. Calling SetEnablePublish( false ) allows to
++      switch OFF publishing in the Study of mesh objects.
++      """
+         #self.SetEnablePublish(theIsEnablePublish)
 -        SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
 -        global notebook
 -        notebook = salome_notebook.NoteBook( theIsEnablePublish )
++      SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
++      global notebook
++      notebook = salome_notebook.NoteBook( theIsEnablePublish )
 +
-         return SMESH._objref_SMESH_Gen.GetCurrentStudy(self)
  
 -    ## Create a Mesh object importing data from the given UNV file
 -    #  @return an instance of Mesh class
 -    #  @ingroup l2_impexp
      def CreateMeshesFromUNV( self,theFileName ):
 +        """
 +        Create a Mesh object importing data from the given UNV file
 +
 +        Returns:
 +                an instance of class :class:`Mesh`
 +        """
 +
          aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName)
          aMesh = Mesh(self, self.geompyD, aSmeshMesh)
          return aMesh
          aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self,
                                                                          theFileName,
                                                                          True)
-         if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment
+         if error.comment: print("*** CreateMeshesFromGMF() errors:\n", error.comment)
          return Mesh(self, self.geompyD, aSmeshMesh), error
  
 -    ## Concatenate the given meshes into one mesh. All groups of input meshes will be
 -    #  present in the new mesh.
 -    #  @param meshes the meshes, sub-meshes and groups to combine into one mesh
 -    #  @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed
 -    #  @param mergeNodesAndElements if true, equal nodes and elements are merged
 -    #  @param mergeTolerance tolerance for merging nodes
 -    #  @param allGroups forces creation of groups corresponding to every input mesh
 -    #  @param name name of a new mesh
 -    #  @return an instance of Mesh class
 -    #  @ingroup l1_creating
      def Concatenate( self, meshes, uniteIdenticalGroups,
                       mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False,
                       name = ""):
                       UnaryOp=FT_Undefined,
                       BinaryOp=FT_Undefined,
                       Tolerance=1e-07):
 +        """
 +        Create a criterion by the given parameters
 +        Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below)
 +
 +        Parameters:
 +                elementType: the :class:`type of elements <SMESH.ElementType>` (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
 +                CritType: the type of criterion :class:`SMESH.FunctorType` (SMESH.FT_Taper, SMESH.FT_Area, etc.).
 +                        Note that the items starting from FT_LessThan are not suitable for *CritType*.
 +                Compare:  belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
 +                Threshold: the threshold value (range of ids as string, shape, numeric)
 +                UnaryOp:  SMESH.FT_LogicalNOT or SMESH.FT_Undefined
 +                BinaryOp: a binary logical operation SMESH.FT_LogicalAND, SMESH.FT_LogicalOR or
 +                        SMESH.FT_Undefined
 +                Tolerance: the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
 +                        SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
 +
 +        Returns:
 +                :class:`SMESH.Filter.Criterion`
 +
 +        Example: :ref:`combining_filters`
 +        """
 +
          if not CritType in SMESH.FunctorType._items:
-             raise TypeError, "CritType should be of SMESH.FunctorType"
+             raise TypeError("CritType should be of SMESH.FunctorType")
          aCriterion               = self.GetEmptyCriterion()
          aCriterion.TypeOfElement = elementType
 -        aCriterion.Type          = EnumToLong(CritType)
 +        aCriterion.Type          = self.EnumToLong(CritType)
          aCriterion.Tolerance     = Tolerance
  
          aThreshold = Threshold
      pass # end of class smeshBuilder
  
  import omniORB
 -#Registering the new proxy for SMESH_Gen
  omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshBuilder)
 +"""Registering the new proxy for SMESH.SMESH_Gen"""
  
 -## Create a new smeshBuilder instance.The smeshBuilder class provides the Python
 -#  interface to create or load meshes.
 -#
 -#  Typical use is:
 -#  \code
 -#    import salome
 -#    salome.salome_init()
 -#    from salome.smesh import smeshBuilder
 -#    smesh = smeshBuilder.New()
 -#  \endcode
 -#  @param  isPublished If False, the notebool will not be used.
 -#  @param  instance  CORBA proxy of SMESH Engine. If None, the default Engine is used.
 -#  @return smeshBuilder instance
 -
 -def New( isPublished = True, instance=None):
 +
- def New( study, instance=None, instanceGeom=None):
++def New( instance=None, instanceGeom=None):
      """
 -    Create a new smeshBuilder instance.The smeshBuilder class provides the Python
 +    Create a new smeshBuilder instance. The smeshBuilder class provides the Python
      interface to create or load meshes.
  
-     Typical use is::
+     Typical use is:
 +
          import salome
          salome.salome_init()
          from salome.smesh import smeshBuilder
-         smesh = smeshBuilder.New(salome.myStudy)
+         smesh = smeshBuilder.New()
  
      Parameters:
-         study:         SALOME study, generally obtained by salome.myStudy.
-         instance:      CORBA proxy of SMESH Engine. If None, the default Engine is used.
-         instanceGeom:  CORBA proxy of GEOM  Engine. If None, the default Engine is used.
+         isPublished If False, the notebool will not be used.
+         instance  CORBA proxy of SMESH Engine. If None, the default Engine is used.
      Returns:
 -        smeshBuilder instance
 +        :class:`smeshBuilder` instance
      """
      global engine
      global smeshInst
      global doLcc
      engine = instance
      if engine is None:
-       doLcc = True
+         doLcc = True
      smeshInst = smeshBuilder()
      assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__
-     smeshInst.init_smesh(study, instanceGeom)
 -    smeshInst.init_smesh(isPublished)
++    smeshInst.init_smesh(instanceGeom)
      return smeshInst
  
  
  # Public class: Mesh
  # ==================
  
- class Mesh:
 -## This class allows defining and managing a mesh.
 -#  It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
 -#  It also has methods to define groups of mesh elements, to modify a mesh (by addition of
 -#  new nodes and elements and by changing the existing entities), to get information
 -#  about a mesh and to export a mesh in different formats.
 -class Mesh(metaclass=MeshMeta):
++
++class Mesh(metaclass = MeshMeta):
 +    """
 +    This class allows defining and managing a mesh.
 +    It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
 +    It also has methods to define groups of mesh elements, to modify a mesh (by addition of
 +    new nodes and elements and by changing the existing entities), to get information
 +    about a mesh and to export a mesh in different formats.
-     """
-     __metaclass__ = MeshMeta
++    """    
 +
      geom = 0
      mesh = 0
      editor = 0
  
 -    ## Constructor
 -    #
 -    #  Create a mesh on the shape \a obj (or an empty mesh if \a obj is equal to 0) and
 -    #  sets the GUI name of this mesh to \a name.
 -    #  @param smeshpyD an instance of smeshBuilder class
 -    #  @param geompyD an instance of geomBuilder class
 -    #  @param obj Shape to be meshed or SMESH_Mesh object
 -    #  @param name Study name of the mesh
 -    #  @ingroup l2_construct
      def __init__(self, smeshpyD, geompyD, obj=0, name=0):
-         self.smeshpyD=smeshpyD
-         self.geompyD=geompyD
++
 +        """
 +        Constructor
 +
 +        Create a mesh on the shape *obj* (or an empty mesh if *obj* is equal to 0) and
 +        sets the GUI name of this mesh to *name*.
 +
 +        Parameters:
 +                smeshpyD: an instance of smeshBuilder class
 +                geompyD: an instance of geomBuilder class
 +                obj: Shape to be meshed or :class:`SMESH.SMESH_Mesh` object
 +                name: Study name of the mesh
 +        """
 +
+         self.smeshpyD = smeshpyD
+         self.geompyD = geompyD
          if obj is None:
              obj = 0
          objHasName = False
              pass
  
          groups = []
-         for algoName, shapes in algo2shapes.items():
+         for algoName, shapes in list(algo2shapes.items()):
              while shapes:
 -                groupType = EnumToLong( shapes[0].GetShapeType() )
 +                groupType = self.smeshpyD.EnumToLong( shapes[0].GetShapeType() )
                  otherTypeShapes = []
                  sameTypeShapes  = []
                  group = self.geompyD.CreateGroup( self.geom, groupType )
                  self.geompyD.addToStudyInFather( self.geom, group, group.GetName() )
          return groups
  
 -    ## Return sub-mesh objects list in meshing order
 -    #  @return list of lists of sub-meshes
 -    #  @ingroup l2_construct
      def GetMeshOrder(self):
 +        """
 +        Return sub-mesh objects list in meshing order
 +
 +        Returns:
 +                list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
 +        """
 +
          return self.mesh.GetMeshOrder()
  
 -    ## Set order in which concurrent sub-meshes should be meshed
 -    #  @param submeshes list of lists of sub-meshes
 -    #  @ingroup l2_construct
      def SetMeshOrder(self, submeshes):
 +        """
 +        Set order in which concurrent sub-meshes should be meshed
 +
 +        Parameters:
 +                submeshes: list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
 +        """
 +
          return self.mesh.SetMeshOrder(submeshes)
  
 -    ## Remove all nodes and elements generated on geometry. Imported elements remain.
 -    #  @param refresh if @c True, Object browser is automatically updated (when running in GUI)
 -    #  @ingroup l2_construct
      def Clear(self, refresh=False):
 +        """
 +        Remove all nodes and elements generated on geometry. Imported elements remain.
 +
 +        Parameters:
 +                refresh: if *True*, Object browser is automatically updated (when running in GUI)
 +        """
 +
          self.mesh.Clear()
-         if ( salome.sg.hasDesktop() and
-              salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() ) ):
+         if ( salome.sg.hasDesktop() ):
              smeshgui = salome.ImportComponentGUI("SMESH")
-             smeshgui.Init(self.mesh.GetStudyId())
+             smeshgui.Init()
              smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
-             if refresh: salome.sg.updateObjBrowser(True)
+             if refresh: salome.sg.updateObjBrowser()
  
 -    ## Remove all nodes and elements of indicated shape
 -    #  @param refresh if @c True, Object browser is automatically updated (when running in GUI)
 -    #  @param geomId the ID of a sub-shape to remove elements on
 -    #  @ingroup l2_submeshes
      def ClearSubMesh(self, geomId, refresh=False):
 +        """
 +        Remove all nodes and elements of indicated shape
 +
 +        Parameters:
 +                geomId: the ID of a sub-shape to remove elements on
 +                refresh: if *True*, Object browser is automatically updated (when running in GUI)
 +        """
 +
          self.mesh.ClearSubMesh(geomId)
          if salome.sg.hasDesktop():
              smeshgui = salome.ImportComponentGUI("SMESH")
-             smeshgui.Init(self.mesh.GetStudyId())
+             smeshgui.Init()
              smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
-             if refresh: salome.sg.updateObjBrowser(True)
+             if refresh: salome.sg.updateObjBrowser()
  
 -    ## Compute a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
 -    #  @param fineness [0.0,1.0] defines mesh fineness
 -    #  @return True or False
 -    #  @ingroup l3_algos_basic
      def AutomaticTetrahedralization(self, fineness=0):
 +        """
 +        Compute a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
 +
 +        Parameters:
 +                fineness: [0.0,1.0] defines mesh fineness
 +
 +        Returns:
 +                True or False
 +        """
 +
          dim = self.MeshDimension()
          # assign hypotheses
          self.RemoveGlobalHypotheses()
              return self.mesh.RemoveHypothesis( shape, hyp )
          hypName = GetName( hyp )
          geoName = GetName( shape )
-         print "WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName )
+         print("WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName ))
          return None
  
 -    ## Get the list of hypotheses added on a geometry
 -    #  @param geom a sub-shape of mesh geometry
 -    #  @return the sequence of SMESH_Hypothesis
 -    #  @ingroup l2_editing
      def GetHypothesisList(self, geom):
 +        """
 +        Get the list of hypotheses added on a geometry
 +
 +        Parameters:
 +                geom (GEOM.GEOM_Object): a sub-shape of mesh geometry
 +
 +        Returns:
 +                the sequence of :class:`SMESH.SMESH_Hypothesis`
 +        """
 +
          return self.mesh.GetHypothesisList( geom )
  
 -    ## Remove all global hypotheses
 -    #  @ingroup l2_editing
      def RemoveGlobalHypotheses(self):
 +        """
 +        Remove all global hypotheses
 +        """
 +
          current_hyps = self.mesh.GetHypothesisList( self.geom )
          for hyp in current_hyps:
              self.mesh.RemoveHypothesis( self.geom, hyp )
              pass
          pass
--
-     def ExportMED(self, f, auto_groups=0, version=MED_V2_2,
-                   overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
 -    ## Export the mesh in a file in MED format
 -    ## allowing to overwrite the file if it exists or add the exported data to its contents
 -    #  @param fileName is the file name
 -    #  @param auto_groups boolean parameter for creating/not creating
 -    #  the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
 -    #  the typical use is auto_groups=False.
 -    #  @param overwrite boolean parameter for overwriting/not overwriting the file
 -    #  @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
 -    #  @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
 -    #         - 1D if all mesh nodes lie on OX coordinate axis, or
 -    #         - 2D if all mesh nodes lie on XOY coordinate plane, or
 -    #         - 3D in the rest cases.<br>
 -    #         If @a autoDimension is @c False, the space dimension is always 3.
 -    #  @param fields list of GEOM fields defined on the shape to mesh.
 -    #  @param geomAssocFields each character of this string means a need to export a
 -    #         corresponding field; correspondence between fields and characters is following:
 -    #         - 'v' stands for "_vertices _" field;
 -    #         - 'e' stands for "_edges _" field;
 -    #         - 'f' stands for "_faces _" field;
 -    #         - 's' stands for "_solids _" field.
 -    #  @ingroup l2_impexp
+     def ExportMED(self, *args, **kwargs):
 +        """
 +        Export the mesh in a file in MED format
 +        allowing to overwrite the file if it exists or add the exported data to its contents
 +
 +        Parameters:
-                 f: is the file name
-                 auto_groups: boolean parameter for creating/not creating
-                         the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
-                         the typical use is auto_groups=False.
-                 version: MED format version (MED_V2_1 or MED_V2_2,
-                         the latter meaning any current version). The parameter is
-                         obsolete since MED_V2_1 is no longer supported.
-                 overwrite: boolean parameter for overwriting/not overwriting the file
-                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
-                 autoDimension: if *True* (default), a space dimension of a MED mesh can be either
-                         - 1D if all mesh nodes lie on OX coordinate axis, or
-                         - 2D if all mesh nodes lie on XOY coordinate plane, or
-                         - 3D in the rest cases.
++                fileName: is the file name
++                auto_groups (boolean): parameter for creating/not creating
++                       the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
++                       the typical use is auto_groups=False.
++                overwrite (boolean): parameter for overwriting/not overwriting the file
++                meshPart: a part of mesh (group, sub-mesh) to export instead of the mesh
++                autoDimension if @c True (default), a space dimension of a MED mesh can be either
++                       - 1D if all mesh nodes lie on OX coordinate axis, or
++                       - 2D if all mesh nodes lie on XOY coordinate plane, or
++                       - 3D in the rest cases.
 +                        If *autoDimension* is *False*, the space dimension is always 3.
 +                fields: list of GEOM fields defined on the shape to mesh.
 +                geomAssocFields: each character of this string means a need to export a 
 +                        corresponding field; correspondence between fields and characters is following:
 +                        - 'v' stands for "_vertices _" field;
 +                        - 'e' stands for "_edges _" field;
 +                        - 'f' stands for "_faces _" field;
 +                        - 's' stands for "_solids _" field.
 +        """
+         # process positional arguments
+         args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+         fileName        = args[0]
+         auto_groups     = args[1] if len(args) > 1 else False
+         overwrite       = args[2] if len(args) > 2 else True
+         meshPart        = args[3] if len(args) > 3 else None
+         autoDimension   = args[4] if len(args) > 4 else True
+         fields          = args[5] if len(args) > 5 else []
+         geomAssocFields = args[6] if len(args) > 6 else ''
+         # process keywords arguments
+         auto_groups     = kwargs.get("auto_groups", auto_groups)
+         overwrite       = kwargs.get("overwrite", overwrite)
+         meshPart        = kwargs.get("meshPart", meshPart)
+         autoDimension   = kwargs.get("autoDimension", autoDimension)
+         fields          = kwargs.get("fields", fields)
+         geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)
+         # invoke engine's function
          if meshPart or fields or geomAssocFields:
              unRegister = genObjUnRegister()
              if isinstance( meshPart, list ):
                  meshPart = self.GetIDSource( meshPart, SMESH.ALL )
                  unRegister.set( meshPart )
-             self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension,
+             self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, overwrite, autoDimension,
                                         fields, geomAssocFields)
          else:
-             self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension)
+             self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
  
 -    ## Export the mesh in a file in SAUV format
 -    #  @param f is the file name
 -    #  @param auto_groups boolean parameter for creating/not creating
 -    #  the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
 -    #  the typical use is auto_groups=false.
 -    #  @ingroup l2_impexp
      def ExportSAUV(self, f, auto_groups=0):
 +        """
 +        Export the mesh in a file in SAUV format
 +
 +
 +        Parameters:
 +                f: is the file name
 +                auto_groups: boolean parameter for creating/not creating
 +                        the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
 +                        the typical use is auto_groups=False.
 +        """
 +
          self.mesh.ExportSAUV(f, auto_groups)
  
 -    ## Export the mesh in a file in DAT format
 -    #  @param f the file name
 -    #  @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
 -    #  @ingroup l2_impexp
      def ExportDAT(self, f, meshPart=None):
 +        """
 +        Export the mesh in a file in DAT format
 +
 +        Parameters:
 +                f: the file name
 +                meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
 +        """
 +
          if meshPart:
              unRegister = genObjUnRegister()
              if isinstance( meshPart, list ):
              meshPart = self.mesh
          self.mesh.ExportGMF(meshPart, f, True)
  
-     def ExportToMED(self, f, version=MED_V2_2, opt=0, overwrite=1, autoDimension=True):
 -    ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
 -    #  Export the mesh in a file in MED format
 -    #  allowing to overwrite the file if it exists or add the exported data to its contents
 -    #  @param fileName the file name
 -    #  @param opt boolean parameter for creating/not creating
 -    #         the groups Group_On_All_Nodes, Group_On_All_Faces, ...
 -    #  @param overwrite boolean parameter for overwriting/not overwriting the file
 -    #  @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
 -    #         - 1D if all mesh nodes lie on OX coordinate axis, or
 -    #         - 2D if all mesh nodes lie on XOY coordinate plane, or
 -    #         - 3D in the rest cases.<br>
 -    #         If @a autoDimension is @c False, the space dimension is always 3.
 -    #  @ingroup l2_impexp
+     def ExportToMED(self, *args, **kwargs):
 +        """
 +        Deprecated, used only for compatibility! Please, use :meth:`ExportMED` method instead.
 +        Export the mesh in a file in MED format
 +        allowing to overwrite the file if it exists or add the exported data to its contents
 +
 +        Parameters:
-                 f: the file name
-                 version: MED format version (MED_V2_1 or MED_V2_2,
-                         the latter meaning any current version). The parameter is
-                         obsolete since MED_V2_1 is no longer supported.
-                 opt: boolean parameter for creating/not creating
++                fileName: the file name
++                opt (boolean): parameter for creating/not creating
 +                        the groups Group_On_All_Nodes, Group_On_All_Faces, ...
 +                overwrite: boolean parameter for overwriting/not overwriting the file
 +                autoDimension: if *True* (default), a space dimension of a MED mesh can be either
 +
 +                        - 1D if all mesh nodes lie on OX coordinate axis, or
 +                        - 2D if all mesh nodes lie on XOY coordinate plane, or
 +                        - 3D in the rest cases.
 +
 +                        If **autoDimension** is *False*, the space dimension is always 3.
 +        """
++    
+         print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
+         # process positional arguments
+         args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+         fileName      = args[0]
+         auto_groups   = args[1] if len(args) > 1 else False
+         overwrite     = args[2] if len(args) > 2 else True
+         autoDimension = args[3] if len(args) > 3 else True
+         # process keywords arguments
+         auto_groups   = kwargs.get("opt", auto_groups)         # old keyword name
+         auto_groups   = kwargs.get("auto_groups", auto_groups) # new keyword name
+         overwrite     = kwargs.get("overwrite", overwrite)
+         autoDimension = kwargs.get("autoDimension", autoDimension)
+         # invoke engine's function
+         self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
 -    ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
 -    #  Export the mesh in a file in MED format
 -    #  allowing to overwrite the file if it exists or add the exported data to its contents
 -    #  @param fileName the file name
 -    #  @param opt boolean parameter for creating/not creating
 -    #         the groups Group_On_All_Nodes, Group_On_All_Faces, ...
 -    #  @param overwrite boolean parameter for overwriting/not overwriting the file
 -    #  @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
 -    #         - 1D if all mesh nodes lie on OX coordinate axis, or
 -    #         - 2D if all mesh nodes lie on XOY coordinate plane, or
 -    #         - 3D in the rest cases.<br>
 -    #         If @a autoDimension is @c False, the space dimension is always 3.
 -    #  @ingroup l2_impexp
+     def ExportToMEDX(self, *args, **kwargs):
++        """
++        Deprecated, used only for compatibility! Please, use ExportMED() method instead.
++        Export the mesh in a file in MED format
++
++        Parameters:
++                fileName: the file name
++                opt (boolean): parameter for creating/not creating
++                        the groups Group_On_All_Nodes, Group_On_All_Faces, ...
++                overwrite: boolean parameter for overwriting/not overwriting the file
++                autoDimension: if *True* (default), a space dimension of a MED mesh can be either
 +
-         self.mesh.ExportToMEDX(f, opt, version, overwrite, autoDimension)
++                        - 1D if all mesh nodes lie on OX coordinate axis, or
++                        - 2D if all mesh nodes lie on XOY coordinate plane, or
++                        - 3D in the rest cases.
++
++                        If **autoDimension** is *False*, the space dimension is always 3.
++              """
++
+         print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
+         # process positional arguments
+         args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+         fileName      = args[0]
+         auto_groups   = args[1] if len(args) > 1 else False
+         overwrite     = args[2] if len(args) > 2 else True
+         autoDimension = args[3] if len(args) > 3 else True
+         # process keywords arguments
+         auto_groups   = kwargs.get("auto_groups", auto_groups)
+         overwrite     = kwargs.get("overwrite", overwrite)
+         autoDimension = kwargs.get("autoDimension", autoDimension)
+         # invoke engine's function
+         self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
  
      # Operations with groups:
      # ----------------------
--
 -    ## Create an empty mesh group
 -    #  @param elementType the type of elements in the group; either of
 -    #         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
 -    #  @param name the name of the mesh group
 -    #  @return SMESH_Group
 -    #  @ingroup l2_grps_create
      def CreateEmptyGroup(self, elementType, name):
 +        """
 +        Create an empty mesh group
 +
 +        Parameters:
 +                elementType: the :class:`type <SMESH.ElementType>` of elements in the group; 
 +                        either of (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
 +                name: the name of the mesh group
 +
 +        Returns:
 +                :class:`SMESH.SMESH_Group`
 +        """
 +
          return self.mesh.CreateGroup(elementType, name)
  
 -    ## Create a mesh group based on the geometric object \a grp
 -    #  and gives a \a name, \n if this parameter is not defined
 -    #  the name is the same as the geometric group name \n
 -    #  Note: Works like GroupOnGeom().
 -    #  @param grp  a geometric group, a vertex, an edge, a face or a solid
 -    #  @param name the name of the mesh group
 -    #  @return SMESH_GroupOnGeom
 -    #  @ingroup l2_grps_create
      def Group(self, grp, name=""):
 +        """
 +        Create a mesh group based on the geometric object *grp*
 +        and give it a *name*.
 +        If *name* is not defined the name of the geometric group is used
 +
 +        Note:
 +                Works like :meth:`GroupOnGeom`.
 +
 +        Parameters:
 +                grp:  a geometric group, a vertex, an edge, a face or a solid
 +                name: the name of the mesh group
 +
 +        Returns:
 +                :class:`SMESH.SMESH_GroupOnGeom`
 +        """
 +
          return self.GroupOnGeom(grp, name)
  
 -    ## Create a mesh group based on the geometrical object \a grp
 -    #  and gives a \a name, \n if this parameter is not defined
 -    #  the name is the same as the geometrical group name
 -    #  @param grp  a geometrical group, a vertex, an edge, a face or a solid
 -    #  @param name the name of the mesh group
 -    #  @param typ  the type of elements in the group; either of
 -    #         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
 -    #         automatically detected by the type of the geometry
 -    #  @return SMESH_GroupOnGeom
 -    #  @ingroup l2_grps_create
      def GroupOnGeom(self, grp, name="", typ=None):
 +        """
 +        Create a mesh group based on the geometrical object *grp*
 +        and gives a *name*.
 +        if *name* is not defined the name of the geometric group is used
 +
 +        Parameters:
 +                grp:  a geometrical group, a vertex, an edge, a face or a solid
 +                name: the name of the mesh group
 +                typ:  the type of elements in the group; either of
 +                        (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
 +                        automatically detected by the type of the geometry
 +
 +        Returns:
 +                :class:`SMESH.SMESH_GroupOnGeom`
 +        """
 +
          AssureGeomPublished( self, grp, name )
          if name == "":
              name = grp.GetName()
          elif tgeo == "COMPOUND":
              sub = self.geompyD.SubShapeAll( shape, self.geompyD.ShapeType["SHAPE"])
              if not sub:
-                 raise ValueError,"_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape)
+                 raise ValueError("_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape))
              return self._groupTypeFromShape( sub[0] )
          else:
-             raise ValueError, \
-                   "_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape)
+             raise ValueError("_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape))
          return typ
  
 -    ## Create a mesh group with given \a name based on the \a filter which
 -    ## is a special type of group dynamically updating it's contents during
 -    ## mesh modification
 -    #  @param typ  the type of elements in the group; either of
 -    #         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
 -    #  @param name the name of the mesh group
 -    #  @param filter the filter defining group contents
 -    #  @return SMESH_GroupOnFilter
 -    #  @ingroup l2_grps_create
      def GroupOnFilter(self, typ, name, filter):
 +        """
 +        Create a mesh group with given *name* based on the *filter* which
 +        is a special type of group dynamically updating it's contents during
 +        mesh modification
 +
 +        Parameters:
 +                typ: the type of elements in the group; either of
 +                        (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
 +                name: the name of the mesh group
 +                filter (SMESH.Filter): the filter defining group contents
 +
 +        Returns:
 +                :class:`SMESH.SMESH_GroupOnFilter`
 +        """
 +
          return self.mesh.CreateGroupFromFilter(typ, name, filter)
  
 -    ## Create a mesh group by the given ids of elements
 -    #  @param groupName the name of the mesh group
 -    #  @param elementType the type of elements in the group; either of
 -    #         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
 -    #  @param elemIDs either the list of ids, group, sub-mesh, or filter
 -    #  @return SMESH_Group
 -    #  @ingroup l2_grps_create
      def MakeGroupByIds(self, groupName, elementType, elemIDs):
 +        """
 +        Create a mesh group by the given ids of elements
 +
 +        Parameters:
 +                groupName: the name of the mesh group
 +                elementType: the type of elements in the group; either of
 +                        (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
 +                elemIDs: either the list of ids, :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
 +
 +        Returns:
 +                :class:`SMESH.SMESH_Group`
 +        """
 +
          group = self.mesh.CreateGroup(elementType, groupName)
          if isinstance( elemIDs, Mesh ):
              elemIDs = elemIDs.GetMesh()
                      groups.append( group )
          return groups
  
 -    ## Produce a union of two groups.
 -    #  A new group is created. All mesh elements that are
 -    #  present in the initial groups are added to the new one
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def UnionGroups(self, group1, group2, name):
 +        """
 +        Produce a union of two groups.
 +        A new group is created. All mesh elements that are
 +        present in the initial groups are added to the new one
 +
 +        Parameters:
 +           group1 (SMESH.SMESH_GroupBase): a group
 +           group2 (SMESH.SMESH_GroupBase): another group
 +
 +        Returns:
 +                instance of :class:`SMESH.SMESH_Group`
 +        """
 +
          return self.mesh.UnionGroups(group1, group2, name)
  
 -    ## Produce a union list of groups.
 -    #  New group is created. All mesh elements that are present in
 -    #  initial groups are added to the new one
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def UnionListOfGroups(self, groups, name):
 +        """
 +        Produce a union list of groups.
 +        New group is created. All mesh elements that are present in
 +        initial groups are added to the new one
 +
 +        Parameters:
 +           groups: list of :class:`SMESH.SMESH_GroupBase`
 +
 +        Returns:
 +                instance of :class:`SMESH.SMESH_Group`
 +        """
          return self.mesh.UnionListOfGroups(groups, name)
  
 -    ## Prodice an intersection of two groups.
 -    #  A new group is created. All mesh elements that are common
 -    #  for the two initial groups are added to the new one.
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def IntersectGroups(self, group1, group2, name):
 +        """
 +        Prodice an intersection of two groups.
 +        A new group is created. All mesh elements that are common
 +        for the two initial groups are added to the new one.
 +
 +        Parameters:
 +           group1 (SMESH.SMESH_GroupBase): a group
 +           group2 (SMESH.SMESH_GroupBase): another group
 +
 +        Returns:
 +                instance of :class:`SMESH.SMESH_Group`
 +        """
 +
          return self.mesh.IntersectGroups(group1, group2, name)
  
 -    ## Produce an intersection of groups.
 -    #  New group is created. All mesh elements that are present in all
 -    #  initial groups simultaneously are added to the new one
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def IntersectListOfGroups(self, groups, name):
 +        """
 +        Produce an intersection of groups.
 +        New group is created. All mesh elements that are present in all
 +        initial groups simultaneously are added to the new one
 +
 +        Parameters:
 +           groups: a list of :class:`SMESH.SMESH_GroupBase`
 +
 +        Returns:
 +                instance of :class:`SMESH.SMESH_Group`
 +        """
          return self.mesh.IntersectListOfGroups(groups, name)
  
 -    ## Produce a cut of two groups.
 -    #  A new group is created. All mesh elements that are present in
 -    #  the main group but are not present in the tool group are added to the new one
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def CutGroups(self, main_group, tool_group, name):
 +        """
 +        Produce a cut of two groups.
 +        A new group is created. All mesh elements that are present in
 +        the main group but are not present in the tool group are added to the new one
 +
 +        Parameters:
 +           main_group (SMESH.SMESH_GroupBase): a group to cut from
 +           tool_group (SMESH.SMESH_GroupBase): a group to cut by
 +
 +        Returns:
 +                an instance of :class:`SMESH.SMESH_Group`
 +        """
 +
          return self.mesh.CutGroups(main_group, tool_group, name)
  
 -    ## Produce a cut of groups.
 -    #  A new group is created. All mesh elements that are present in main groups
 -    #  but do not present in tool groups are added to the new one
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def CutListOfGroups(self, main_groups, tool_groups, name):
 +        """
 +        Produce a cut of groups.
 +        A new group is created. All mesh elements that are present in main groups
 +        but do not present in tool groups are added to the new one
 +
 +        Parameters:
 +           main_group: groups to cut from  (list of :class:`SMESH.SMESH_GroupBase`)
 +           tool_group: groups to cut by    (list of :class:`SMESH.SMESH_GroupBase`)
 +
 +        Returns:
 +                an instance of :class:`SMESH.SMESH_Group`
 +        """
 +
          return self.mesh.CutListOfGroups(main_groups, tool_groups, name)
  
 -    ##
 -    #  Create a standalone group of entities basing on nodes of other groups.
 -    #  \param groups - list of reference groups, sub-meshes or filters, of any type.
 -    #  \param elemType - a type of elements to include to the new group; either of
 -    #         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
 -    #  \param name - a name of the new group.
 -    #  \param nbCommonNodes - a criterion of inclusion of an element to the new group
 -    #         basing on number of element nodes common with reference \a groups.
 -    #         Meaning of possible values are:
 -    #         - SMESH.ALL_NODES - include if all nodes are common,
 -    #         - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh),
 -    #         - SMESH.AT_LEAST_ONE - include if one or more node is common,
 -    #         - SMEHS.MAJORITY - include if half of nodes or more are common.
 -    #  \param underlyingOnly - if \c True (default), an element is included to the
 -    #         new group provided that it is based on nodes of an element of \a groups;
 -    #         in this case the reference \a groups are supposed to be of higher dimension
 -    #         than \a elemType, which can be useful for example to get all faces lying on
 -    #         volumes of the reference \a groups.
 -    #  @return an instance of SMESH_Group
 -    #  @ingroup l2_grps_operon
      def CreateDimGroup(self, groups, elemType, name,
                         nbCommonNodes = SMESH.ALL_NODES, underlyingOnly = True):
 +        """
 +        Create a standalone group of entities basing on nodes of other groups.
 +
 +        Parameters:
 +                groups: list of reference :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>`, of any type.
 +                elemType: a type of elements to include to the new group; either of
 +                        (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
 +                name: a name of the new group.
 +                nbCommonNodes: a criterion of inclusion of an element to the new group
 +                        basing on number of element nodes common with reference *groups*.
 +                        Meaning of possible values are:
 +
 +                                - SMESH.ALL_NODES - include if all nodes are common,
 +                                - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh),
 +                                - SMESH.AT_LEAST_ONE - include if one or more node is common,
 +                                - SMEHS.MAJORITY - include if half of nodes or more are common.
 +                underlyingOnly: if *True* (default), an element is included to the
 +                        new group provided that it is based on nodes of an element of *groups*;
 +                        in this case the reference *groups* are supposed to be of higher dimension
 +                        than *elemType*, which can be useful for example to get all faces lying on
 +                        volumes of the reference *groups*.
 +
 +        Returns:
 +                an instance of :class:`SMESH.SMESH_Group`
 +        """
 +
          if isinstance( groups, SMESH._objref_SMESH_IDSource ):
              groups = [groups]
          return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly)
      # Get some info about mesh:
      # ------------------------
  
 -    ## Return the log of nodes and elements added or removed
 -    #  since the previous clear of the log.
 -    #  @param clearAfterGet log is emptied after Get (safe if concurrents access)
 -    #  @return list of log_block structures:
 -    #                                        commandType
 -    #                                        number
 -    #                                        coords
 -    #                                        indexes
 -    #  @ingroup l1_auxiliary
      def GetLog(self, clearAfterGet):
 +        """
 +        Return the log of nodes and elements added or removed
 +        since the previous clear of the log.
 +
 +        Parameters:
 +                clearAfterGet: log is emptied after Get (safe if concurrents access)
 +
 +        Returns:
 +                list of SMESH.log_block structures { commandType, number, coords, indexes }
 +        """
 +
          return self.mesh.GetLog(clearAfterGet)
  
 -    ## Clear the log of nodes and elements added or removed since the previous
 -    #  clear. Must be used immediately after GetLog if clearAfterGet is false.
 -    #  @ingroup l1_auxiliary
      def ClearLog(self):
 +        """
 +        Clear the log of nodes and elements added or removed since the previous
 +        clear. Must be used immediately after :meth:`GetLog` if clearAfterGet is false.
 +        """
 +
          self.mesh.ClearLog()
  
 -    ## Toggle auto color mode on the object.
 -    #  @param theAutoColor the flag which toggles auto color mode.
 -    #
 -    #  If switched on, a default color of a new group in Create Group dialog is chosen randomly.
 -    #  @ingroup l1_grouping
      def SetAutoColor(self, theAutoColor):
 +        """
 +        Toggle auto color mode on the object.
 +        If switched on, a default color of a new group in Create Group dialog is chosen randomly.
 +
 +        Parameters:
 +                theAutoColor (boolean): the flag which toggles auto color mode.
 +        """
 +
          self.mesh.SetAutoColor(theAutoColor)
  
 -    ## Get flag of object auto color mode.
 -    #  @return True or False
 -    #  @ingroup l1_grouping
      def GetAutoColor(self):
 +        """
 +        Get flag of object auto color mode.
 +
 +        Returns:
 +                True or False
 +        """
 +
          return self.mesh.GetAutoColor()
  
 -    ## Get the internal ID
 -    #  @return integer value, which is the internal Id of the mesh
 -    #  @ingroup l1_auxiliary
      def GetId(self):
 +        """
 +        Get the internal ID
 +
 +        Returns:
 +            integer value, which is the internal Id of the mesh
 +        """
 +
          return self.mesh.GetId()
  
-     def GetStudyId(self):
-         """
-         Get the study Id
-         Returns:
-             integer value, which is the study Id of the mesh
-         """
-         return self.mesh.GetStudyId()
 -    ## Check the group names for duplications.
 -    #  Consider the maximum group name length stored in MED file.
 -    #  @return True or False
 -    #  @ingroup l1_grouping
      def HasDuplicatedGroupNamesMED(self):
 +        """
 +        Check the group names for duplications.
 +        Consider the maximum group name length stored in MED file.
 +
 +        Returns:
 +            True or False
 +        """
 +
          return self.mesh.HasDuplicatedGroupNamesMED()
  
 -    ## Obtain the mesh editor tool
 -    #  @return an instance of SMESH_MeshEditor
 -    #  @ingroup l1_modifying
      def GetMeshEditor(self):
 +        """
 +        Obtain the mesh editor tool
 +
 +        Returns:
 +            an instance of :class:`SMESH.SMESH_MeshEditor`
 +        """
 +
          return self.editor
  
 -    ## Wrap a list of IDs of elements or nodes into SMESH_IDSource which
 -    #  can be passed as argument to a method accepting mesh, group or sub-mesh
 -    #  @param ids list of IDs
 -    #  @param elemType type of elements; this parameter is used to distinguish
 -    #         IDs of nodes from IDs of elements; by default ids are treated as
 -    #         IDs of elements; use SMESH.NODE if ids are IDs of nodes.
 -    #  @return an instance of SMESH_IDSource
 -    #  @warning call UnRegister() for the returned object as soon as it is no more useful:
 -    #          idSrc = mesh.GetIDSource( [1,3,5], SMESH.NODE )
 -    #          mesh.DoSomething( idSrc )
 -    #          idSrc.UnRegister()
 -    #  @ingroup l1_auxiliary
      def GetIDSource(self, ids, elemType = SMESH.ALL):
 +        """
 +        Wrap a list of IDs of elements or nodes into :class:`SMESH.SMESH_IDSource` which
 +        can be passed as argument to a method accepting :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
 +
 +        Parameters:
 +                ids: list of IDs
 +                elemType: type of elements; this parameter is used to distinguish
 +                        IDs of nodes from IDs of elements; by default ids are treated as
 +                        IDs of elements; use SMESH.NODE if ids are IDs of nodes.
 +
 +        Returns:
 +            an instance of :class:`SMESH.SMESH_IDSource`
 +
 +        Warning:
 +                call UnRegister() for the returned object as soon as it is no more useful::
 +
 +                        idSrc = mesh.GetIDSource( [1,3,5], SMESH.NODE )
 +                        mesh.DoSomething( idSrc )
 +                        idSrc.UnRegister()
 +        """
 +
          if isinstance( ids, int ):
              ids = [ids]
          return self.editor.MakeIDSource(ids, elemType)
              EdgeID = Edge
          try:
              self.editor.SetNodeOnEdge(NodeID, EdgeID, paramOnEdge)
-         except SALOME.SALOME_Exception, inst:
-             raise ValueError, inst.details.text
+         except SALOME.SALOME_Exception as inst:
+             raise ValueError(inst.details.text)
          return True
  
 -    ## @brief Stores node position on a face
 -    #  @param NodeID a node ID
 -    #  @param Face a face or face ID
 -    #  @param u U parameter on the face where the node is located
 -    #  @param v V parameter on the face where the node is located
 -    #  @return True if succeed else raises an exception
 -    #  @ingroup l2_modif_add
      def SetNodeOnFace(self, NodeID, Face, u, v):
 +        """
 +        Stores node position on a face
 +
 +        Parameters:
 +                NodeID: a node ID
 +                Face: a face (GEOM.GEOM_Object) or face ID
 +                u: U parameter on the face where the node is located
 +                v: V parameter on the face where the node is located
 +
 +        Returns:
 +            True if succeed else raises an exception
 +        """
 +
          if ( isinstance( Face, geomBuilder.GEOM._objref_GEOM_Object)):
              FaceID = self.geompyD.GetSubShapeID( self.geom, Face )
          else:
              FaceID = Face
          try:
              self.editor.SetNodeOnFace(NodeID, FaceID, u, v)
-         except SALOME.SALOME_Exception, inst:
-             raise ValueError, inst.details.text
+         except SALOME.SALOME_Exception as inst:
+             raise ValueError(inst.details.text)
          return True
  
 -    ## @brief Binds a node to a solid
 -    #  @param NodeID a node ID
 -    #  @param Solid  a solid or solid ID
 -    #  @return True if succeed else raises an exception
 -    #  @ingroup l2_modif_add
      def SetNodeInVolume(self, NodeID, Solid):
 +        """
 +        Binds a node to a solid
 +
 +        Parameters:
 +                NodeID: a node ID
 +                Solid:  a solid (GEOM.GEOM_Object) or solid ID
 +
 +        Returns:
 +            True if succeed else raises an exception
 +        """
 +
          if ( isinstance( Solid, geomBuilder.GEOM._objref_GEOM_Object)):
              SolidID = self.geompyD.GetSubShapeID( self.geom, Solid )
          else:
              SolidID = Solid
          try:
              self.editor.SetNodeInVolume(NodeID, SolidID)
-         except SALOME.SALOME_Exception, inst:
-             raise ValueError, inst.details.text
+         except SALOME.SALOME_Exception as inst:
+             raise ValueError(inst.details.text)
          return True
  
 -    ## @brief Bind an element to a shape
 -    #  @param ElementID an element ID
 -    #  @param Shape a shape or shape ID
 -    #  @return True if succeed else raises an exception
 -    #  @ingroup l2_modif_add
      def SetMeshElementOnShape(self, ElementID, Shape):
 +        """
 +        Bind an element to a shape
 +
 +        Parameters:
 +                ElementID: an element ID
 +                Shape: a shape (GEOM.GEOM_Object) or shape ID
 +
 +        Returns:
 +            True if succeed else raises an exception
 +        """
 +
          if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)):
              ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape )
          else:
          #return preview.MoveClosestNodeToPoint(x, y, z, -1)
          return self.editor.FindNodeClosestTo(x, y, z)
  
 -    ## Find the elements where a point lays IN or ON
 -    #  @param x  the X coordinate of a point
 -    #  @param y  the Y coordinate of a point
 -    #  @param z  the Z coordinate of a point
 -    #  @param elementType type of elements to find; either of
 -    #         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); SMESH.ALL type
 -    #         means elements of any type excluding nodes, discrete and 0D elements.
 -    #  @param meshPart a part of mesh (group, sub-mesh) to search within
 -    #  @return list of IDs of found elements
 -    #  @ingroup l1_meshinfo
      def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL, meshPart=None):
 +        """
 +        Find the elements where a point lays IN or ON
 +
 +        Parameters:
 +                x,y,z (float): coordinates of the point
 +                elementType (SMESH.ElementType): type of elements to find; SMESH.ALL type
 +                        means elements of any type excluding nodes, discrete and 0D elements.
 +                meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to search within
 +
 +        Returns:
 +            list of IDs of found elements
 +        """
          if meshPart:
              return self.editor.FindAmongElementsByPoint( meshPart, x, y, z, elementType );
          else:
                  self.editor.ConvertToQuadratic(theForce3d)
          error = self.editor.GetLastError()
          if error and error.comment:
-             print error.comment
+             print(error.comment)
          return error
  
 -    ## Convert the mesh from quadratic to ordinary,
 -    #  deletes old quadratic elements, \n replacing
 -    #  them with ordinary mesh elements with the same id.
 -    #  @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal
 -    #  @ingroup l2_modif_tofromqu
      def ConvertFromQuadratic(self, theSubMesh=None):
 +        """
 +        Convert the mesh from quadratic to ordinary,
 +        deletes old quadratic elements,
 +        replacing them with ordinary mesh elements with the same id.
 +
 +        Parameters:
 +            theSubMesh: a :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>` to convert
 +
 +        Warning:
 +            If *theSubMesh* is provided, the mesh can become non-conformal
 +        """
 +
          if theSubMesh:
              self.editor.ConvertFromQuadraticObject(theSubMesh)
          else:
          if holeNodes and isinstance( holeNodes, list ) and isinstance( holeNodes[0], int ):
              holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
          if not isinstance( holeNodes, SMESH.FreeBorder ):
-             raise TypeError, "holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes
+             raise TypeError("holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes)
          self.editor.FillHole( holeNodes )
  
 -    ## Return groups of FreeBorder's coincident within the given tolerance.
 -    #  @param tolerance the tolerance. If the tolerance <= 0.0 then one tenth of an average
 -    #         size of elements adjacent to free borders being compared is used.
 -    #  @return SMESH.CoincidentFreeBorders structure
 -    #  @ingroup l2_modif_trsf
      def FindCoincidentFreeBorders (self, tolerance=0.):
 +        """
 +        Return groups of FreeBorder's coincident within the given tolerance.
 +
 +        Parameters:
 +            tolerance: the tolerance. If the tolerance <= 0.0 then one tenth of an average
 +                size of elements adjacent to free borders being compared is used.
 +
 +        Returns:
 +            SMESH.CoincidentFreeBorders structure
 +        """
 +
          return self.editor.FindCoincidentFreeBorders( tolerance )
  
 -    ## Sew FreeBorder's of each group
 -    #  @param freeBorders either a SMESH.CoincidentFreeBorders structure or a list of lists
 -    #         where each enclosed list contains node IDs of a group of coincident free
 -    #         borders such that each consequent triple of IDs within a group describes
 -    #         a free border in a usual way: n1, n2, nLast - i.e. 1st node, 2nd node and
 -    #         last node of a border.
 -    #         For example [[1, 2, 10, 20, 21, 40], [11, 12, 15, 55, 54, 41]] describes two
 -    #         groups of coincident free borders, each group including two borders.
 -    #  @param createPolygons if @c True faces adjacent to free borders are converted to
 -    #         polygons if a node of opposite border falls on a face edge, else such
 -    #         faces are split into several ones.
 -    #  @param createPolyhedra if @c True volumes adjacent to free borders are converted to
 -    #         polyhedra if a node of opposite border falls on a volume edge, else such
 -    #         volumes, if any, remain intact and the mesh becomes non-conformal.
 -    #  @return a number of successfully sewed groups
 -    #  @ingroup l2_modif_trsf
      def SewCoincidentFreeBorders (self, freeBorders, createPolygons=False, createPolyhedra=False):
 +        """
 +        Sew FreeBorder's of each group
 +
 +        Parameters:
 +            freeBorders: either a SMESH.CoincidentFreeBorders structure or a list of lists
 +                where each enclosed list contains node IDs of a group of coincident free
 +                borders such that each consequent triple of IDs within a group describes
 +                a free border in a usual way: n1, n2, nLast - i.e. 1st node, 2nd node and
 +                last node of a border.
 +                For example [[1, 2, 10, 20, 21, 40], [11, 12, 15, 55, 54, 41]] describes two
 +                groups of coincident free borders, each group including two borders.
 +            createPolygons: if :code:`True` faces adjacent to free borders are converted to
 +                polygons if a node of opposite border falls on a face edge, else such
 +                faces are split into several ones.
 +            createPolyhedra: if :code:`True` volumes adjacent to free borders are converted to
 +                polyhedra if a node of opposite border falls on a volume edge, else such
 +                volumes, if any, remain intact and the mesh becomes non-conformal.
 +
 +        Returns:
 +            a number of successfully sewed groups
 +        """
 +
          if freeBorders and isinstance( freeBorders, list ):
              # construct SMESH.CoincidentFreeBorders
              if isinstance( freeBorders[0], int ):
                  return twoGroups[ int(theMakeNodeGroup) ]
          return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems)
  
 -    ## Create a hole in a mesh by doubling the nodes of some particular elements
 -    #  This method provided for convenience works as DoubleNodes() described above.
 -    #  @param theElems - list of groups of elements (edges or faces) to be replicated
 -    #  @param theNodesNot - list of groups of nodes not to replicated
 -    #  @param theShape - shape to detect affected elements (element which geometric center
 -    #         located on or inside shape).
 -    #         The replicated nodes should be associated to affected elements.
 -    #  @return TRUE if operation has been completed successfully, FALSE otherwise
 -    #  @ingroup l2_modif_duplicat
      def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape):
 +        """
 +        Create a hole in a mesh by doubling the nodes of some particular elements.
 +        This method provided for convenience works as :meth:`DoubleNodes`.
 +
 +        Parameters:
 +            theElems: list of groups of elements (edges or faces) to replicate
 +            theNodesNot: list of groups of nodes NOT to replicate
 +            theShape: shape to detect affected elements (element which geometric center
 +                located on or inside shape).
 +                The replicated nodes should be associated to affected elements
 +
 +        Returns:
 +            True if operation has been completed successfully, False otherwise
 +        """
 +
          return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape)
  
 -    ## Identify the elements that will be affected by node duplication (actual duplication is not performed.
 -    #  This method is the first step of DoubleNodeElemGroupsInRegion.
 -    #  @param theElems - list of groups of nodes or elements (edges or faces) to be replicated
 -    #  @param theNodesNot - list of groups of nodes not to replicated
 -    #  @param theShape - shape to detect affected elements (element which geometric center
 -    #         located on or inside shape).
 -    #         The replicated nodes should be associated to affected elements.
 -    #  @return groups of affected elements in order: volumes, faces, edges
 -    #  @ingroup l2_modif_duplicat
      def AffectedElemGroupsInRegion(self, theElems, theNodesNot, theShape):
 +        """
 +        Identify the elements that will be affected by node duplication (actual duplication is not performed).
 +        This method is the first step of :meth:`DoubleNodeElemGroupsInRegion`.
 +
 +        Parameters:
 +            theElems: list of groups of nodes or elements (edges or faces) to replicate
 +            theNodesNot: list of groups of nodes NOT to replicate
 +            theShape: shape to detect affected elements (element which geometric center
 +                located on or inside shape).
 +                The replicated nodes should be associated to affected elements
 +
 +        Returns:
 +            groups of affected elements in order: volumes, faces, edges
 +        """
 +
          return self.editor.AffectedElemGroupsInRegion(theElems, theNodesNot, theShape)
  
 -    ## Double nodes on shared faces between groups of volumes and create flat elements on demand.
 -    #  The list of groups must describe a partition of the mesh volumes.
 -    #  The nodes of the internal faces at the boundaries of the groups are doubled.
 -    #  In option, the internal faces are replaced by flat elements.
 -    #  Triangles are transformed in prisms, and quadrangles in hexahedrons.
 -    #  @param theDomains - list of groups of volumes
 -    #  @param createJointElems - if TRUE, create the elements
 -    #  @param onAllBoundaries - if TRUE, the nodes and elements are also created on
 -    #         the boundary between \a theDomains and the rest mesh
 -    #  @return TRUE if operation has been completed successfully, FALSE otherwise
 -    #  @ingroup l2_modif_duplicat
      def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ):
++
 +        """
 +        Double nodes on shared faces between groups of volumes and create flat elements on demand.
 +        The list of groups must describe a partition of the mesh volumes.
 +        The nodes of the internal faces at the boundaries of the groups are doubled.
 +        In option, the internal faces are replaced by flat elements.
 +        Triangles are transformed to prisms, and quadrangles to hexahedrons.
 +
 +        Parameters:
 +            theDomains: list of groups of volumes
 +            createJointElems: if True, create the elements
 +            onAllBoundaries: if True, the nodes and elements are also created on
 +                the boundary between *theDomains* and the rest mesh
 +
 +        Returns:
 +            True if operation has been completed successfully, False otherwise
 +        """
 +
          return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries )
  
 -    ## Double nodes on some external faces and create flat elements.
 -    #  Flat elements are mainly used by some types of mechanic calculations.
 -    #
 -    #  Each group of the list must be constituted of faces.
 -    #  Triangles are transformed in prisms, and quadrangles in hexahedrons.
 -    #  @param theGroupsOfFaces - list of groups of faces
 -    #  @return TRUE if operation has been completed successfully, FALSE otherwise
 -    #  @ingroup l2_modif_duplicat
      def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ):
 +        """
 +        Double nodes on some external faces and create flat elements.
 +        Flat elements are mainly used by some types of mechanic calculations.
 +
 +        Each group of the list must be constituted of faces.
 +        Triangles are transformed in prisms, and quadrangles in hexahedrons.
 +
 +        Parameters:
 +            theGroupsOfFaces: list of groups of faces
 +
 +        Returns:
 +            True if operation has been completed successfully, False otherwise
 +        """
 +
          return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces )
  
 -    ## identify all the elements around a geom shape, get the faces delimiting the hole
 -    #
      def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords):
 +        """
 +        Identify all the elements around a geom shape, get the faces delimiting the hole
 +        """
          return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords )
  
 -    ## Create a polyline consisting of 1D mesh elements each lying on a 2D element of
 -    #  the initial mesh. Positions of new nodes are found by cutting the mesh by the
 -    #  plane passing through pairs of points specified by each PolySegment structure.
 -    #  If there are several paths connecting a pair of points, the shortest path is
 -    #  selected by the module. Position of the cutting plane is defined by the two
 -    #  points and an optional vector lying on the plane specified by a PolySegment.
 -    #  By default the vector is defined by Mesh module as following. A middle point
 -    #  of the two given points is computed. The middle point is projected to the mesh.
 -    #  The vector goes from the middle point to the projection point. In case of planar
 -    #  mesh, the vector is normal to the mesh.
 -    #  @param segments - PolySegment's defining positions of cutting planes.
 -    #         Return the used vector which goes from the middle point to its projection.
 -    #  @param groupName - optional name of a group where created mesh segments will
 -    #         be added.
 -    #  @ingroup l2_modif_duplicat
      def MakePolyLine(self, segments, groupName='', isPreview=False ):
 +        """    
 +        Create a polyline consisting of 1D mesh elements each lying on a 2D element of
 +        the initial mesh. Positions of new nodes are found by cutting the mesh by the
 +        plane passing through pairs of points specified by each :class:`SMESH.PolySegment` structure.
 +        If there are several paths connecting a pair of points, the shortest path is
 +        selected by the module. Position of the cutting plane is defined by the two
 +        points and an optional vector lying on the plane specified by a PolySegment.
 +        By default the vector is defined by Mesh module as following. A middle point
 +        of the two given points is computed. The middle point is projected to the mesh.
 +        The vector goes from the middle point to the projection point. In case of planar
 +        mesh, the vector is normal to the mesh.
 +
 +        *segments* [i].vector returns the used vector which goes from the middle point to its projection.
 +
 +        Parameters:        
 +            segments: list of :class:`SMESH.PolySegment` defining positions of cutting planes.
 +            groupName: optional name of a group where created mesh segments will be added.
 +            
 +        """    
          editor = self.editor
          if isPreview:
              editor = self.mesh.GetMeshEditPreviewer()
      pass # end of Mesh class
  
  
 -## Private class used to compensate change of CORBA API of SMESH_Mesh for backward compatibility
 -#  with old dump scripts which call SMESH_Mesh directly and not via smeshBuilder.Mesh
 -#
  class meshProxy(SMESH._objref_SMESH_Mesh):
 -    def __init__(self, *args):
 -        SMESH._objref_SMESH_Mesh.__init__(self, *args)
 +    """
 +    Private class used to compensate change of CORBA API of SMESH_Mesh for backward compatibility
 +    with old dump scripts which call SMESH_Mesh directly and not via smeshBuilder.Mesh
 +    """
-     def __init__(self):
-         SMESH._objref_SMESH_Mesh.__init__(self)
++    def __init__(self,*args):
++        SMESH._objref_SMESH_Mesh.__init__(self,*args)
      def __deepcopy__(self, memo=None):
-         new = self.__class__()
+         new = self.__class__(self)
          return new
      def CreateDimGroup(self,*args): # 2 args added: nbCommonNodes, underlyingOnly
          if len( args ) == 3:
  omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)
  
  
 -## Private class wrapping SMESH.SMESH_SubMesh in order to add Compute()
 -#
  class submeshProxy(SMESH._objref_SMESH_subMesh):
 -    def __init__(self, *args):
 -        SMESH._objref_SMESH_subMesh.__init__(self, *args)
++
 +    """
 +    Private class wrapping SMESH.SMESH_SubMesh in order to add Compute()
 +    """
-     def __init__(self):
-         SMESH._objref_SMESH_subMesh.__init__(self)
++    def __init__(self,*args):
++        SMESH._objref_SMESH_subMesh.__init__(self,*args)
          self.mesh = None
      def __deepcopy__(self, memo=None):
-         new = self.__class__()
+         new = self.__class__(self)
          return new
  
 -    ## Compute the sub-mesh and return the status of the computation
 -    #  @param refresh if @c True, Object browser is automatically updated (when running in GUI)
 -    #  @return True or False
 -    #
 -    #  This is a method of SMESH.SMESH_submesh that can be obtained via Mesh.GetSubMesh() or
 -    #  @ref smesh_algorithm.Mesh_Algorithm.GetSubMesh() "Mesh_Algorithm.GetSubMesh()".
 -    #  @ingroup l2_submeshes
      def Compute(self,refresh=False):
 +        """
 +        Compute the sub-mesh and return the status of the computation
 +
 +        Parameters:
 +            refresh: if *True*, Object Browser is automatically updated (when running in GUI)
 +
 +        Returns:
 +            True or False
 +
 +        This is a method of SMESH.SMESH_submesh that can be obtained via Mesh.GetSubMesh() or
 +        :meth:`smeshBuilder.Mesh.GetSubMesh`.
 +        """
 +
          if not self.mesh:
              self.mesh = Mesh( smeshBuilder(), None, self.GetMesh())
  
  omniORB.registerObjref(SMESH._objref_SMESH_subMesh._NP_RepositoryId, submeshProxy)
  
  
 -## Private class used to compensate change of CORBA API of SMESH_MeshEditor for backward
 -#  compatibility with old dump scripts which call SMESH_MeshEditor directly and not via
 -#  smeshBuilder.Mesh
 -#
  class meshEditor(SMESH._objref_SMESH_MeshEditor):
 -    def __init__(self, *args):
 -        SMESH._objref_SMESH_MeshEditor.__init__(self, *args)
 +    """
 +    Private class used to compensate change of CORBA API of SMESH_MeshEditor for backward
 +    compatibility with old dump scripts which call SMESH_MeshEditor directly and not via
 +    smeshBuilder.Mesh
 +    """
-     def __init__(self):
-         SMESH._objref_SMESH_MeshEditor.__init__(self)
++    def __init__(self,*args):
++        SMESH._objref_SMESH_MeshEditor.__init__( self, *args)
          self.mesh = None
      def __getattr__(self, name ): # method called if an attribute not found
          if not self.mesh:         # look for name() method in Mesh class
@@@ -6881,23 -5396,18 +6993,23 @@@ class algoCreator
          self.algoTypeToClass = {}
          self.method = method
  
 -    # Store a python class of algorithm
      def add(self, algoClass):
-         if type( algoClass ).__name__ == 'classobj' and \
 +        """
 +        Store a python class of algorithm
 +        """
 -           hasattr(algoClass, "algoType"):
+         if inspect.isclass(algoClass) and \
 +           hasattr( algoClass, "algoType"):
              self.algoTypeToClass[ algoClass.algoType ] = algoClass
              if not self.defaultAlgoType and \
                 hasattr( algoClass, "isDefault") and algoClass.isDefault:
                  self.defaultAlgoType = algoClass.algoType
--            #print "Add",algoClass.algoType, "dflt",self.defaultAlgoType
++            #print("Add",algoClass.algoType, "dflt",self.defaultAlgoType)
  
 -    # Create a copy of self and assign mesh to the copy
      def copy(self, mesh):
 +        """
 +        Create a copy of self and assign mesh to the copy
 +        """
 +
          other = algoCreator( self.method )
          other.defaultAlgoType = self.defaultAlgoType
          other.algoTypeToClass = self.algoTypeToClass
              algoType = self.defaultAlgoType
          if not algoType and self.algoTypeToClass:
              algoType = sorted( self.algoTypeToClass.keys() )[0]
-         if self.algoTypeToClass.has_key( algoType ):
-             #print "Create algo",algoType
+         if algoType in self.algoTypeToClass:
 -            #print "Create algo",algoType
++            #print("Create algo",algoType)
              return self.algoTypeToClass[ algoType ]( self.mesh, shape )
-         raise RuntimeError, "No class found for algo type %s" % algoType
+         raise RuntimeError( "No class found for algo type %s" % algoType)
          return None
  
 -## Private class used to substitute and store variable parameters of hypotheses.
 -#
  class hypMethodWrapper:
 +    """
 +    Private class used to substitute and store variable parameters of hypotheses.
 +    """
 +
      def __init__(self, hyp, method):
          self.hyp    = hyp
          self.method = method
--        #print "REBIND:", method.__name__
++        #print("REBIND:", method.__name__)
          return
  
 -    # call a method of hypothesis with calling SetVarParameter() before
      def __call__(self,*args):
 +        """
 +        call a method of hypothesis with calling SetVarParameter() before
 +        """
 +
          if not args:
              return self.method( self.hyp, *args ) # hypothesis method with no args
  
--        #print "MethWrapper.__call__",self.method.__name__, args
++        #print("MethWrapper.__call__", self.method.__name__, args)
          try:
              parsed = ParseParameters(*args)     # replace variables with their values
              self.hyp.SetVarParameter( parsed[-2], self.method.__name__ )
@@@ -7004,12 -5507,12 +7117,12 @@@ class genObjUnRegister
              if genObj and hasattr( genObj, "UnRegister" ):
                  genObj.UnRegister()
  
 -
 -## Bind methods creating mesher plug-ins to the Mesh class
 -#
  for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
 -    #
 -    #print "pluginName: ", pluginName
 +    """
 +    Bind methods creating mesher plug-ins to the Mesh class
 +    """
 +
-     # print "pluginName: ", pluginName
++    # print("pluginName: ", pluginName)
      pluginBuilderName = pluginName + "Builder"
      try:
          exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
          continue
      exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
      plugin = eval( pluginBuilderName )
-     # print "  plugin:" , str(plugin)
 -    #print "  plugin:" , str(plugin)
++    # print("  plugin:" , str(plugin))
  
      # add methods creating algorithms to Mesh
      for k in dir( plugin ):
          if k[0] == '_': continue
          algo = getattr( plugin, k )
-         # print "             algo:", str(algo)
-         if type( algo ).__name__ == 'classobj' and hasattr( algo, "meshMethod" ):
-             # print "                     meshMethod:" , str(algo.meshMethod)
 -        #print "             algo:", str(algo)
++        #print("             algo:", str(algo))
+         if inspect.isclass(algo) and hasattr(algo, "meshMethod"):
 -            #print "                     meshMethod:" , str(algo.meshMethod)
++            #print("                     meshMethod:" , str(algo.meshMethod))
              if not hasattr( Mesh, algo.meshMethod ):
                  setattr( Mesh, algo.meshMethod, algoCreator( algo.meshMethod ))
                  pass
@@@ -25,64 -25,52 +25,64 @@@ import salom
  from salome.geom import geomBuilder
  import SMESH, StdMeshers
  
 -## The base class to define meshing algorithms
 -#
 -#  @note This class should not be used directly, it is supposed to be sub-classed
 -#  for implementing Python API for specific meshing algorithms
 -#
 -#  For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
 -#  should be defined. This descendant class should have two attributes defining the way
 -#  it is created by class Mesh (see e.g. class @ref StdMeshersBuilder.StdMeshersBuilder_Segment "StdMeshersBuilder_Segment"
 -#  in StdMeshersBuilder package):
 -#  - @c meshMethod attribute defines name of method of class smesh.Mesh by calling which the
 -#    python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
 -#    in runtime. For example, if in @c class MyPlugin_Algorithm this attribute is defined as
 -#    @code
 -#    meshMethod = "MyAlgorithm"
 -#    @endcode
 -#    then an instance of @c MyPlugin_Algorithm can be created by the direct invocation of the function
 -#    of smesh.Mesh class:
 -#    @code
 -#    my_algo = mesh.MyAlgorithm()
 -#    @endcode
 -#  - @c algoType defines type of algorithm and is used mostly to discriminate
 -#    algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
 -#    is specified in @c MyPlugin_Algorithm class as
 -#    @code
 -#    algoType = "MyPLUGIN"
 -#    @endcode
 -#    then it's creation code can be:
 -#    @code
 -#    my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
 -#    @endcode
 -#  @ingroup l2_algorithms
  class Mesh_Algorithm:
-       This class should not be used directly, it is supposed to be sub-classed
 +    """
 +    The base class to define meshing algorithms
 +
 +    Note:
-       - :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the
-               python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
-               in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as
-               ::
++        This class should not be used directly, it is supposed to be sub-classed
 +    for implementing Python API for specific meshing algorithms
 +
 +    For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
 +    should be defined. This descendant class should have two attributes defining the way
 +    it is created by class Mesh (see e.g. class :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment`
 +    in StdMeshersBuilder package):
 +
-                       meshMethod = "MyAlgorithm"
++        - :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the
++                python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
++                in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as
++                ::
 +
-               then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
-               of smesh.Mesh class:
-               ::
++                        meshMethod = "MyAlgorithm"
 +
-                       my_algo = mesh.MyAlgorithm()
++                then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
++                of smesh.Mesh class:
++                ::
 +    
-       - :code:`algoType` defines type of algorithm and is used mostly to discriminate
-               algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
-               is specified in :code:`MyPlugin_Algorithm` class as
-               ::
++                        my_algo = mesh.MyAlgorithm()
 +    
-                       algoType = "MyPLUGIN"
++        - :code:`algoType` defines type of algorithm and is used mostly to discriminate
++                algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
++                is specified in :code:`MyPlugin_Algorithm` class as
++                ::
 +    
-               then it's creation code can be:
-               ::
++                        algoType = "MyPLUGIN"
 +
-                       my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
++                then it's creation code can be:
++                ::
 +
++                        my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
 +    """
 +    
      
 -    ## Private constructor
      def __init__(self):
-       """
-       Private constuctor
-       """
++        """
++        Private constuctor
++        """
          self.mesh = None
          self.geom = None
          self.subm = None
          self.algo = None
          pass
  
 -    ## Finds a hypothesis in the study by its type name and parameters.
 -    #  Finds only the hypotheses created in smeshpyD engine.
 -    #  @return SMESH.SMESH_Hypothesis
      def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD):
-       """
-       Finds a hypothesis in the study by its type name and parameters.
-       Finds only the hypotheses created in smeshpyD engine.
-       Returns: 
-               SMESH.SMESH_Hypothesis
-       """
-         study = smeshpyD.GetCurrentStudy()
++        """
++        Finds a hypothesis in the study by its type name and parameters.
++        Finds only the hypotheses created in smeshpyD engine.
++        Returns: 
++                SMESH.SMESH_Hypothesis
++        """
+         study = salome.myStudy
          if not study: return None
          #to do: find component by smeshpyD object, not by its data type
          scomp = study.FindComponent(smeshpyD.ComponentDataType())
              pass
          return None
  
 -    ## Finds the algorithm in the study by its type name.
 -    #  Finds only the algorithms, which have been created in smeshpyD engine.
 -    #  @return SMESH.SMESH_Algo
      def FindAlgorithm (self, algoname, smeshpyD):
-       """
-       Finds the algorithm in the study by its type name.
-       Finds only the algorithms, which have been created in smeshpyD engine.
-       Returns:
-               SMESH.SMESH_Algo
-       """
-         study = smeshpyD.GetCurrentStudy()
++        """
++        Finds the algorithm in the study by its type name.
++        Finds only the algorithms, which have been created in smeshpyD engine.
++
++        Returns:
++                SMESH.SMESH_Algo
++        """
+         study = salome.myStudy
          if not study: return None
          #to do: find component by smeshpyD object, not by its data type
          scomp = study.FindComponent(smeshpyD.ComponentDataType())
              pass
          return None
  
 -    ## If the algorithm is global, returns 0; \n
 -    #  else returns the submesh associated to this algorithm.
      def GetSubMesh(self):
-       """
-       If the algorithm is global, returns 0; 
-       else returns the submesh associated to this algorithm.
-       """
++        """
++        If the algorithm is global, returns 0; 
++        else returns the submesh associated to this algorithm.
++        """
          return self.subm
  
 -    ## Returns the wrapped mesher.
      def GetAlgorithm(self):
-       """
-       Returns the wrapped mesher.
-       """
++        """
++        Returns the wrapped mesher.
++        """
          return self.algo
  
 -    ## Gets the list of hypothesis that can be used with this algorithm
      def GetCompatibleHypothesis(self):
-       """
-       Gets the list of hypothesis that can be used with this algorithm
-       """
++        """
++        Gets the list of hypothesis that can be used with this algorithm
++        """
          mylist = []
          if self.algo:
              mylist = self.algo.GetCompatibleHypothesis()
          return mylist
  
 -    ## Gets the name of the algorithm
      def GetName(self):
-       """
-       Gets the name of the algorithm
-       """
++        """
++        Gets the name of the algorithm
++        """
          from salome.smesh.smeshBuilder import GetName
          return GetName(self.algo)
  
 -    ## Sets the name to the algorithm
      def SetName(self, name):
-       """
-       Sets the name to the algorithm
-       """
++        """
++        Sets the name to the algorithm
++        """
          self.mesh.smeshpyD.SetName(self.algo, name)
  
 -    ## Gets the id of the algorithm
      def GetId(self):
-       """
-       Gets the id of the algorithm
-       """
++        """
++        Gets the id of the algorithm
++        """
          return self.algo.GetId()
  
 -    ## Private method.
      def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
-       """
-       Private method.
-       """
++        """
++        Private method.
++        """
          if geom is None and mesh.mesh.HasShapeToMesh():
-             raise RuntimeError, "Attempt to create " + hypo + " algorithm on None shape"
+             raise RuntimeError("Attempt to create " + hypo + " algorithm on None shape")
          algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
          if algo is None:
              algo = mesh.smeshpyD.CreateHypothesis(hypo, so)
          self.Assign(algo, mesh, geom)
          return self.algo
  
 -    ## Private method
      def Assign(self, algo, mesh, geom):
-       """
-       Private method
-       """
++        """
++        Private method
++        """
          from salome.smesh.smeshBuilder import AssureGeomPublished, TreatHypoStatus, GetName
          if geom is None and mesh.mesh.HasShapeToMesh():
-             raise RuntimeError, "Attempt to create " + algo + " algorithm on None shape"
+             raise RuntimeError("Attempt to create " + algo + " algorithm on None shape")
          self.mesh = mesh
          if not geom or geom.IsSame( mesh.geom ):
              self.geom = mesh.geom
      def CompareEqualHyp (self, hyp, args):
          return True
  
 -    ## Private method
      def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so",
                      UseExisting=0, CompareMethod="", toAdd=True):
-       """
-       Private method
-       """
++        """
++        Private method
++        """
          from salome.smesh.smeshBuilder import TreatHypoStatus, GetName
          hypo = None
          if UseExisting:
              TreatHypoStatus( status, GetName(hypo), geomName, 0, self.mesh )
          return hypo
  
 -    ## Returns entry of the shape to mesh in the study
      def MainShapeEntry(self):
-       """
-       Returns entry of the shape to mesh in the study
-       """
++        """
++        Returns entry of the shape to mesh in the study
++        """
          if not self.mesh or not self.mesh.GetMesh(): return ""
          if not self.mesh.GetMesh().HasShapeToMesh(): return ""
          shape = self.mesh.GetShape()
          return shape.GetStudyEntry()
  
 -    ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
 -    #  near mesh boundary. This hypothesis can be used by several 3D algorithms:
 -    #  NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
 -    #  @param thickness total thickness of layers of prisms
 -    #  @param numberOfLayers number of layers of prisms
 -    #  @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
 -    #  @param faces list of geometrical faces (or their ids).
 -    #         Viscous layers are either generated on these faces or not, depending on
 -    #         the value of \a isFacesToIgnore parameter.
 -    #  @param isFacesToIgnore if \c True, the Viscous layers are not generated on the
 -    #         faces specified by the previous parameter (\a faces).
 -    #  @param extrMethod extrusion method defines how position of new nodes are found during
 -    #         prism construction and how creation of distorted and intersecting prisms is
 -    #         prevented. Possible values are:
 -    #       - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
 -    #         to underlying geometrical surface. Smoothing of internal surface of
 -    #         element layers can be used to avoid creation of invalid prisms.
 -    #       - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
 -    #         surrounding mesh faces till intersection with a neighbor mesh face
 -    #         translated along its own normal by the layers thickness. Thickness
 -    #         of layers can be limited to avoid creation of invalid prisms.
 -    #       - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
 -    #         surrounding mesh faces by the layers thickness. Thickness of
 -    #         layers can be limited to avoid creation of invalid prisms.
 -    #  @ingroup l3_hypos_additi
      def ViscousLayers(self, thickness, numberOfLayers, stretchFactor,
                        faces=[], isFacesToIgnore=True, extrMethod=StdMeshers.SURF_OFFSET_SMOOTH ):
-       """
-       Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
-       near mesh boundary. This hypothesis can be used by several 3D algorithms:
-       NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
-       Parameters:
-               thickness: total thickness of layers of prisms
-               numberOfLayers: number of layers of prisms
-               stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
-               faces: list of geometrical faces (or their ids).
-                       Viscous layers are either generated on these faces or not, depending on
-                       the value of **isFacesToIgnore** parameter.
-               isFacesToIgnore: if *True*, the Viscous layers are not generated on the
-                       faces specified by the previous parameter (**faces**).
-               extrMethod: extrusion method defines how position of new nodes are found during
-                       prism construction and how creation of distorted and intersecting prisms is
-                       prevented. Possible values are:
-                       - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
-                               to underlying geometrical surface. Smoothing of internal surface of
-                               element layers can be used to avoid creation of invalid prisms.
-                       - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
-                               surrounding mesh faces till intersection with a neighbor mesh face
-                               translated along its own normal by the layers thickness. Thickness
-                               of layers can be limited to avoid creation of invalid prisms.
-                       - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
-                               surrounding mesh faces by the layers thickness. Thickness of
-                               layers can be limited to avoid creation of invalid prisms.
-       """
++        """
++        Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
++        near mesh boundary. This hypothesis can be used by several 3D algorithms:
++        NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
++
++        Parameters:
++                thickness: total thickness of layers of prisms
++                numberOfLayers: number of layers of prisms
++                stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
++                faces: list of geometrical faces (or their ids).
++                        Viscous layers are either generated on these faces or not, depending on
++                        the value of **isFacesToIgnore** parameter.
++                isFacesToIgnore: if *True*, the Viscous layers are not generated on the
++                        faces specified by the previous parameter (**faces**).
++                extrMethod: extrusion method defines how position of new nodes are found during
++                        prism construction and how creation of distorted and intersecting prisms is
++                        prevented. Possible values are:
++
++                        - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
++                                to underlying geometrical surface. Smoothing of internal surface of
++                                element layers can be used to avoid creation of invalid prisms.
++                        - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
++                                surrounding mesh faces till intersection with a neighbor mesh face
++                                translated along its own normal by the layers thickness. Thickness
++                                of layers can be limited to avoid creation of invalid prisms.
++                        - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
++                                surrounding mesh faces by the layers thickness. Thickness of
++                                layers can be limited to avoid creation of invalid prisms.
++        """
 +        
          if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo):
-             raise TypeError, "ViscousLayers are supported by 3D algorithms only"
+             raise TypeError("ViscousLayers are supported by 3D algorithms only")
          if not "ViscousLayers" in self.GetCompatibleHypothesis():
-             raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName()
+             raise TypeError("ViscousLayers are not supported by %s"%self.algo.GetName())
          if faces and isinstance( faces, geomBuilder.GEOM._objref_GEOM_Object ):
              faces = [ faces ]
          if faces and isinstance( faces[0], geomBuilder.GEOM._objref_GEOM_Object ):
          self.mesh.AddHypothesis( hyp, self.geom )
          return hyp
  
 -    ## Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
 -    #  elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
 -    #  NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
 -    #  @param thickness total thickness of layers of quadrilaterals
 -    #  @param numberOfLayers number of layers
 -    #  @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
 -    #  @param edges list of geometrical edges (or their ids).
 -    #         Viscous layers are either generated on these edges or not, depending on
 -    #         the value of \a isEdgesToIgnore parameter.
 -    #  @param isEdgesToIgnore if \c True, the Viscous layers are not generated on the
 -    #         edges specified by the previous parameter (\a edges).
 -    #  @ingroup l3_hypos_additi
      def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor,
                          edges=[], isEdgesToIgnore=True ):
-       """
-       Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
-       elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
-       NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
-       Parameters:
-               thickness: total thickness of layers of quadrilaterals
-               numberOfLayers: number of layers
-               stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
-               edges: list of geometrical edges (or their ids).
-                       Viscous layers are either generated on these edges or not, depending on
-                       the value of **isEdgesToIgnore** parameter.
-               isEdgesToIgnore: if *True*, the Viscous layers are not generated on the
-                       edges specified by the previous parameter (**edges**).
-       """
++        """
++        Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
++        elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
++        NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
++
++        Parameters:
++                thickness: total thickness of layers of quadrilaterals
++                numberOfLayers: number of layers
++                stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
++                edges: list of geometrical edges (or their ids).
++                        Viscous layers are either generated on these edges or not, depending on
++                        the value of **isEdgesToIgnore** parameter.
++                isEdgesToIgnore: if *True*, the Viscous layers are not generated on the
++                        edges specified by the previous parameter (**edges**).
++        """
 +        
          if not isinstance(self.algo, SMESH._objref_SMESH_2D_Algo):
-             raise TypeError, "ViscousLayers2D are supported by 2D algorithms only"
+             raise TypeError("ViscousLayers2D are supported by 2D algorithms only")
          if not "ViscousLayers2D" in self.GetCompatibleHypothesis():
-             raise TypeError, "ViscousLayers2D are not supported by %s"%self.algo.GetName()
+             raise TypeError("ViscousLayers2D are not supported by %s"%self.algo.GetName())
          if edges and not isinstance( edges, list ) and not isinstance( edges, tuple ):
              edges = [edges]
          if edges and isinstance( edges[0], geomBuilder.GEOM._objref_GEOM_Object ):
          self.mesh.AddHypothesis( hyp, self.geom )
          return hyp
  
 -    ## Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
 -    #  into a list acceptable to SetReversedEdges() of some 1D hypotheses
 -    #  @ingroup l3_hypos_1dhyps
      def ReversedEdgeIndices(self, reverseList):
-       """
-       Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
-       into a list acceptable to SetReversedEdges() of some 1D hypotheses
-       """
++        """
++        Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
++        into a list acceptable to SetReversedEdges() of some 1D hypotheses
++        """
 +        
          from salome.smesh.smeshBuilder import FirstVertexOnCurve
          resList = []
          geompy = self.mesh.geompyD
Simple merge
  #include <vtkActorCollection.h>
  #include <vtkRenderer.h>
  
 -static CORBA::ORB_var anORB;
 -
  namespace
  {
 -  //---------------------------------------------------------------
 -  inline
 -  CORBA::Object_var
 -  StringToObject(const std::string& theIOR)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Print deprecation warning to termninal.
 +  /// \param function Interface function's name.
 +  /// \param replacement Replacement (new) function's name
 +  ///        (if there's any).
 +  ///////////////////////////////////////////////////////////////
 +  void deprecated(const char* function, const char* replacement = 0)
    {
 -    return anORB->string_to_object(theIOR.c_str());
 +    if ( replacement )
 +      printf("libSMESH_Swig: method '%s' is deprecated; use '%s' instead.\n", function, replacement);
 +    else
 +      printf("libSMESH_Swig: method '%s' is deprecated.\n", function);
    }
  
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Get CORBA object by its IOR.
 +  /// \param ior Object's IOR.
 +  /// \return CORBA object (nil object if it isn't found).
 +  ///////////////////////////////////////////////////////////////
 +  CORBA::Object_var string2object(const std::string& ior)
 +  {
 +    return SalomeApp_Application::orb()->string_to_object(ior.c_str());
 +  }
  
 -  //---------------------------------------------------------------
 -  inline
 -  SALOMEDS::SObject_var
 -  GetDomainRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 -                const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 -                CORBA::Long theDomainRootTag,
 -                const QString& theName,
 -                const QString& thePixmap)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Get study object by its study UID or IOR.
-   /// \param studyId Study UID.
 +  /// \param uid Object's study UID or IOR.
 +  /// \return Pointer to study object (null object if it isn't
 +  ///         found).
 +  ///////////////////////////////////////////////////////////////
-   _PTR(SObject) uid2object(int studyId, const std::string& uid)
++  _PTR(SObject) uid2object(const std::string& uid)
    {
 -    SALOMEDS::SObject_var aDomainRoot;
 -    if (!theSComponentMesh->FindSubObject(theDomainRootTag,aDomainRoot)) {
 -      aDomainRoot = theStudyBuilder->NewObjectToTag(theSComponentMesh,theDomainRootTag);
 -      SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeName");
 -      SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 -      aName->SetValue(theName.toLatin1().data());
 -      aName->UnRegister();
 -      anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributePixMap");
 -      SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 -      aPixmap->SetPixMap(thePixmap.toLatin1().data());
 -      aPixmap->UnRegister();
 -      anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeSelectable");
 -      SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 -      aSelAttr->SetSelectable(false);
 -      aSelAttr->UnRegister();
 +    _PTR(SObject) sobject;
-     if ( studyId > 0 )
 +    {
-       _PTR(Study) study = SalomeApp_Application::studyMgr()->GetStudyByID( studyId );
++      _PTR(Study) study = SMESH::getStudy();
 +      if ( study )
 +      {
 +      sobject = study->FindObjectID( uid );
 +      if ( !sobject )
 +        sobject = study->FindObjectIOR( uid );
 +      }
      }
 -
 -    return aDomainRoot;
 +    return sobject;
    }
  
 -
 -  //---------------------------------------------------------------
 -  inline
 -  SALOMEDS::SObject_var
 -  GetHypothesisRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 -                    const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Get view window by its identifier.
 +  /// \param uid Window's identifier.
 +  /// \return Pointer to the view window (0 if it isn't found).
 +  ///////////////////////////////////////////////////////////////
 +  SALOME_View* uid2wnd(int uid, bool create = false)
    {
 -    return GetDomainRoot(theSComponentMesh,
 -                         theStudyBuilder,
 -                         SMESH::Tag_HypothesisRoot,
 -                         QObject::tr("SMESH_MEN_HYPOTHESIS"),
 -                         "ICON_SMESH_TREE_HYPO");
 -  }
 +    SALOME_View* window = 0;
  
 +    SUIT_Session* session = SUIT_Session::session();
 +    SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
 +    if ( app )
 +    {
 +      if ( uid )
 +      {
 +      ViewManagerList vms = app->viewManagers();
 +      for ( int i = 0; i < vms.count() && !window; i++ )
 +      {
 +        SUIT_ViewManager* vm = vms[i];
 +        QVector<SUIT_ViewWindow*> vws = vm->getViews();
 +        for ( int j = 0; j < vws.count() && !window; j++)
 +        {
 +          SUIT_ViewWindow* vw = vws[0];
 +          if ( uid == vw->getId() )
 +            window = dynamic_cast<SALOME_View*>( vm->getViewModel() );
 +        }
 +      }
 +      }
 +      else
 +      {
 +      SUIT_ViewManager* vm = app->getViewManager( SVTK_Viewer::Type(), create );
 +      if ( vm )
 +      { 
 +        window = dynamic_cast<SALOME_View*>( vm->getViewModel() );
 +      }
 +      }
 +    }
 +    return window;
 +  }
  
 -  //---------------------------------------------------------------
 -  inline
 -  SALOMEDS::SObject_var
 -  GetAlgorithmsRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 -                    const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Get all view windows.
 +  /// \return List of view windows.
 +  ///////////////////////////////////////////////////////////////
 +  QList<SALOME_View*> windows()
    {
 -    return GetDomainRoot(theSComponentMesh,
 -                         theStudyBuilder,
 -                         SMESH::Tag_AlgorithmsRoot,
 -                         QObject::tr("SMESH_MEN_ALGORITHMS"),
 -                         "ICON_SMESH_TREE_ALGO");
 +    QList<SALOME_View*> views;
 +    SUIT_Session* session = SUIT_Session::session();
 +    SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
 +    if ( app )
 +    {
 +      ViewManagerList vms = app->viewManagers();
 +      foreach( SUIT_ViewManager* vm, vms )
 +      {
 +        if ( vm && vm->getType() == SVTK_Viewer::Type() )
 +      {
 +          SALOME_View* view = dynamic_cast<SALOME_View*>( vm->getViewModel() );
 +          if ( view )
 +          views << view;
 +      }
 +      }
 +    }
 +    return views;
    }
  
 -
 -  //---------------------------------------------------------------
 -  inline
 -  SALOMEDS::SObject_var
 -  AddToDomain(const std::string&                theIOR,
 -              const SALOMEDS::SComponent_var&   theSComponentMesh,
 -              const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 -              CORBA::Long                       theDomainRootTag,
 -              const QString&                    theDomainName,
 -              const QString&                    theDomainPixmap)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Get mesh actor from view.
 +  /// \param view Pointer to the view window.
 +  /// \param uid Mesh object's study UID.
 +  /// \return Mesh actor (0 if it isn't found).
 +  ///////////////////////////////////////////////////////////////
 +  SMESH_Actor* actorFromView(SALOME_View* view, const char* uid)
    {
 -    SALOMEDS::SObject_var aDomain = GetDomainRoot(theSComponentMesh,
 -                                                  theStudyBuilder,
 -                                                  SMESH::Tag_AlgorithmsRoot,
 -                                                  theDomainName,
 -                                                  theDomainPixmap);
 -    // Add New Hypothesis
 -    SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(aDomain);
 -    aDomain->UnRegister();
 -    SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 -    SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 -    CORBA::Object_var anObject = StringToObject(theIOR);
 -    SMESH::SMESH_Hypothesis_var aDomainItem = SMESH::SMESH_Hypothesis::_narrow(anObject.in());
 -    CORBA::String_var aType = aDomainItem->GetName();
 -    QString aPixmapName = theDomainPixmap + "_" + aType.in();
 -    aPixmap->SetPixMap(aPixmapName.toLatin1().data());
 -    aPixmap->UnRegister();
 -    anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 -    SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 -    anIOR->SetValue(theIOR.c_str());
 -    anIOR->UnRegister();
 -
 -    return aSObject;
 +    SMESH_Actor* actor = 0;
 +    SVTK_Viewer* model = dynamic_cast<SVTK_Viewer*>( view );
 +    if ( model )
 +    {
 +      SUIT_ViewWindow* vw = model->getViewManager()->getActiveView();
 +      if ( vw )
 +      {
 +        actor = SMESH::FindActorByEntry( vw, uid );
 +      }
 +    }
 +    return actor;
    }
  
 -
 -  //---------------------------------------------------------------
 -  SALOMEDS::SObject_var
 -  AddHypothesis(const std::string& theIOR,
 -                const SALOMEDS::SComponent_var& theSComponentMesh,
 -                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Get mesh object's visual properties.
 +  /// \param view Pointer to the view window.
 +  /// \param uid Mesh object's study UID.
 +  /// \return Properties data structure.
 +  ///////////////////////////////////////////////////////////////
 +  Properties properties(SALOME_View* view, const char* uid)
    {
 -    return AddToDomain(theIOR,
 -                       theSComponentMesh,
 -                       theStudyBuilder,
 -                       SMESH::Tag_HypothesisRoot,
 -                       QObject::tr("SMESH_MEN_HYPOTHESIS"),
 -                       "ICON_SMESH_TREE_HYPO");
 +    Properties props;
 +    SMESH_Actor* actor = actorFromView( view, uid );
 +    if ( actor )
 +    {
 +      actor->GetNodeColor( props.nodeColor.r,
 +                         props.nodeColor.g,
 +                         props.nodeColor.b );
 +      props.markerType = actor->GetMarkerType();
 +      props.markerScale = actor->GetMarkerScale();
 +      
 +      actor->GetEdgeColor( props.edgeColor.r,
 +                         props.edgeColor.g,
 +                         props.edgeColor.b );
 +      props.edgeWidth = qMax( (int)actor->GetLineWidth(), 1 );
 +      
 +      actor->GetSufaceColor( props.surfaceColor.r,
 +                           props.surfaceColor.g,
 +                           props.surfaceColor.b,
 +                           props.surfaceColor.delta );
 +      
 +      actor->GetVolumeColor( props.volumeColor.r,
 +                           props.volumeColor.g,
 +                           props.volumeColor.b,
 +                           props.volumeColor.delta );
 +      
 +      actor->Get0DColor( props.elem0dColor.r,
 +                       props.elem0dColor.g,
 +                       props.elem0dColor.b );
 +      props.elem0dSize = qMax( (int)actor->Get0DSize(), 1 );
 +      
 +      actor->GetBallColor( props.ballColor.r,
 +                         props.ballColor.g,
 +                         props.ballColor.b );
 +      props.ballScale = qMax( actor->GetBallScale(), 1e-2 );
 +      
 +      actor->GetOutlineColor( props.outlineColor.r,
 +                            props.outlineColor.g,
 +                            props.outlineColor.b );
 +      props.outlineWidth = qMax( (int)actor->GetOutlineWidth(), 1 );
 +      
 +      actor->GetFacesOrientationColor( props.orientationColor.r,
 +                                     props.orientationColor.g,
 +                                     props.orientationColor.b );
 +      props.orientationScale = actor->GetFacesOrientationScale();
 +      props.orientation3d = actor->GetFacesOrientation3DVectors();
 +      
 +      props.shrinkFactor = actor->GetShrinkFactor();
 +      
 +      props.opacity = actor->GetOpacity();
 +    }
 +    return props;
    }
  
 -
 -  //---------------------------------------------------------------
 -  SALOMEDS::SObject_var
 -  AddAlgorithms(const std::string& theIOR,
 -                const SALOMEDS::SComponent_var& theSComponentMesh,
 -                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 +  ///////////////////////////////////////////////////////////////
 +  /// \internal
 +  /// \brief Set mesh object's visual properties.
 +  /// \param view Pointer to the view window.
 +  /// \param uid Mesh object's study UID.
 +  /// \param props Properties data structure.
 +  ///////////////////////////////////////////////////////////////
 +  void setProperties(SALOME_View* view, const char* uid, const Properties& props)
    {
 -    return AddToDomain(theIOR,
 -                       theSComponentMesh,
 -                       theStudyBuilder,
 -                       SMESH::Tag_AlgorithmsRoot,
 -                       QObject::tr("SMESH_MEN_ALGORITHMS"),
 -                       "ICON_SMESH_TREE_ALGO");
 +    SMESH_Actor* actor = actorFromView( view, uid );
 +    if ( actor )
 +    {
 +      actor->SetNodeColor( props.nodeColor.r,
 +                         props.nodeColor.g,
 +                         props.nodeColor.b );
 +      if ( props.markerType != VTK::MT_USER )
 +      actor->SetMarkerStd( props.markerType, props.markerScale );
 +      
 +      actor->SetEdgeColor( props.edgeColor.r,
 +                         props.edgeColor.g,
 +                         props.edgeColor.b );
 +      actor->SetLineWidth( qMax( (double)props.edgeWidth, 1. ) );
 +      
 +      actor->SetSufaceColor( props.surfaceColor.r,
 +                           props.surfaceColor.g,
 +                           props.surfaceColor.b,
 +                           props.surfaceColor.delta );
 +      
 +      actor->SetVolumeColor( props.volumeColor.r,
 +                           props.volumeColor.g,
 +                           props.volumeColor.b,
 +                           props.volumeColor.delta );
 +      
 +      actor->Set0DColor( props.elem0dColor.r,
 +                       props.elem0dColor.g,
 +                       props.elem0dColor.b );
 +      actor->Set0DSize( qMax( (double)props.elem0dSize, 1. ) );
 +      
 +      actor->SetBallColor( props.ballColor.r,
 +                         props.ballColor.g,
 +                         props.ballColor.b );
 +      actor->SetBallScale( qMax( props.ballScale, 1e-2 ) );
 +      
 +      actor->SetOutlineColor( props.outlineColor.r,
 +                            props.outlineColor.g,
 +                            props.outlineColor.b );
 +      actor->SetOutlineWidth( qMax( (double)props.outlineWidth, 1. ) );
 +      
 +      actor->SetFacesOrientationColor( props.orientationColor.r,
 +                                     props.orientationColor.g,
 +                                     props.orientationColor.b );
 +      actor->SetFacesOrientationScale( props.orientationScale );
 +      actor->SetFacesOrientation3DVectors( props.orientation3d );
 +      
 +      actor->SetShrinkFactor( props.shrinkFactor );
 +      
 +      actor->SetOpacity( props.opacity );
 +      
 +      view->Repaint();
 +    }
    }
-   : myCachedStudyId( 0 )
 +} // end of anonymous namespace
 +
 +/////////////////////////////////////////////////////////////////
 +/// \enum EntityMode
 +/// \brief Enumeration for mesh entities.
 +/// \var EntityMode Entity0d
 +/// \brief 0D elements.
 +/// \var EntityMode EntityEdges
 +/// \brief Edges.
 +/// \var EntityMode EntityFaces
 +/// \brief Faces.
 +/// \var EntityMode EntityVolumes
 +/// \brief Volumes.
 +/// \var EntityMode EntityBalls
 +/// \brief Ball elements.
 +/// \var EntityMode EntityAll
 +/// \brief All elements.
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \enum SelectionMode
 +/// \brief Selection mode.
 +/// \var SelectionMode Undefined
 +/// \brief Undefined selection mode.
 +/// \var SelectionMode Node
 +/// \brief Selection of mesh nodes.
 +/// \var SelectionMode Cell
 +/// \brief Selection of any mesh cells.
 +/// \var SelectionMode EdgeOfCell
 +/// \brief Selection of pseudo-edges specified by couple of nodes.
 +/// \var SelectionMode Edge
 +/// \brief Selection of edges.
 +/// \var SelectionMode Face
 +/// \brief Selection of faces.
 +/// \var SelectionMode Volume
 +/// \brief Selection of volumes
 +/// \var SelectionMode Actor
 +/// \brief Selection of whole actors (meshes, sub-meshes, groups).
 +/// \var SelectionMode Elem0D
 +/// \brief Selection of 0D elements.
 +/// \var SelectionMode Ball
 +/// \brief Selection of ball ellements.
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \enum DisplayMode
 +/// \brief Display mode.
 +/// \var DisplayMode UndefinedMode
 +/// \brief Undefined display mode.
 +/// \var DisplayMode PointMode
 +/// \brief Point representation.
 +/// \var DisplayMode EdgeMode
 +/// \brief Wireframe representation.
 +/// \var DisplayMode SurfaceMode
 +/// \brief Surface representation.
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \struct ColorData
 +/// \brief Color data, in RGBf format.
 +/// \var ColorData::r
 +/// \brief Red color's component (0.0:1.0).
 +/// \var ColorData::g
 +/// \brief Green color's component (0.0:1.0).
 +/// \var ColorData::b
 +/// \brief Blue color's component (0.0:1.0).
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \brief Constructor.
 +/////////////////////////////////////////////////////////////////
 +ColorData::ColorData()
 +  : r( 0 ), g( 0 ), b( 0 )
 +{}
 +
 +/////////////////////////////////////////////////////////////////
 +/// \struct BicolorData
 +/// \brief Bi-color data, in RGBf format.
 +/// \var BicolorData::r
 +/// \brief Red color's component (0.0:1.0).
 +/// \var BicolorData::g
 +/// \brief Green color's component (0.0:1.0).
 +/// \var BicolorData::b
 +/// \brief Blue color's component (0.0:1.0).
 +/// \var BicolorData::delta
 +/// \brief Shift for backface color (-100:100).
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \brief Constructor.
 +/////////////////////////////////////////////////////////////////
 +BicolorData::BicolorData()
 +  : r( 0 ), g( 0 ), b( 0 ), delta( 0 )
 +{}
 +
 +/////////////////////////////////////////////////////////////////
 +/// \struct Properties
 +/// \brief Mesh object presentation's properties.
 +/// \var Properties::nodeColor
 +/// \brief Node color.
 +/// \var Properties::markerType
 +/// \brief Node standard marker type.
 +/// \var Properties::markerScale
 +/// \brief Node scale factor.
 +/// \var Properties::edgeColor
 +/// \brief Edges color.
 +/// \var Properties::edgeWidth
 +/// \brief Edges width.
 +/// \var Properties::surfaceColor
 +/// \brief Faces color.
 +/// \var Properties::volumeColor
 +/// \brief Volumes color.
 +/// \var Properties::elem0dColor
 +/// \brief 0D elements color.
 +/// \var Properties::elem0dSize
 +/// \brief 0D elements size.
 +/// \var Properties::ballColor
 +/// \brief Ball elements color.
 +/// \var Properties::ballScale
 +/// \brief Ball elements scale factor.
 +/// \var Properties::outlineColor
 +/// \brief Outlines color.
 +/// \var Properties::outlineWidth
 +/// \brief Outlines width.
 +/// \var Properties::orientationColor
 +/// \brief Face orientation vectors color.
 +/// \var Properties::orientationScale
 +/// \brief Face orientation vectors scale factor.
 +/// \var Properties::orientation3d
 +/// \brief Face orientation vectors 3d flag.
 +/// \var Properties::shrinkFactor
 +/// \brief Shrink coefficient.
 +/// \var Properties::opacity
 +/// \brief Opacity.
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \brief Constructor.
 +/////////////////////////////////////////////////////////////////
 +Properties::Properties()
 +  : markerType( VTK::MT_NONE ), markerScale( VTK::MS_NONE ),
 +    edgeWidth( 1 ), elem0dSize( 1 ), ballScale( 1 ), outlineWidth( 1 ),
 +    orientationScale( 0 ), orientation3d( false ), shrinkFactor( 0 ),
 +    opacity( 1 )
 +{}
 +
 +/////////////////////////////////////////////////////////////////
 +/// \typedef nodeColorStruct
 +/// \deprecated Use ColorData instead.
 +/// \typedef edgeColorStruct
 +/// \deprecated Use ColorData instead.
 +/// \typedef surfaceColorStruct
 +/// \deprecated Use BicolorData instead.
 +/// \typedef volumeColorStruct
 +/// \deprecated Use BicolorData instead.
 +/// \typedef actorAspect
 +/// \deprecated Use Properties instead.
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \class SMESH_Swig
 +/// \brief %SMESH GUI Python interface.
 +/////////////////////////////////////////////////////////////////
 +
 +/////////////////////////////////////////////////////////////////
 +/// \brief Constructor.
 +/////////////////////////////////////////////////////////////////
 +SMESH_Swig::SMESH_Swig()
 +{
 +  init();
 +}
  
 +/////////////////////////////////////////////////////////////////
 +/// \brief Destructor.
 +/////////////////////////////////////////////////////////////////
 +SMESH_Swig::~SMESH_Swig()
 +{
 +}
  
 -  //---------------------------------------------------------------
 -  void
 -  SetDomain(const char*                       theMeshOrSubMeshEntry,
 -            const char*                       theDomainEntry,
 -            const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 -            long                              theRefOnAppliedDomainTag,
 -            const QString&                    theAppliedDomainMEN,
 -            const QString&                    theAppliedDomainICON)
 +/////////////////////////////////////////////////////////////////
 +/// \internal
 +/// \brief Initialize interface.
 +/////////////////////////////////////////////////////////////////
 +void SMESH_Swig::init()
 +{
 +  class TInitEvent: public SALOME_Event
    {
 -    SALOMEDS::SObject_var aMeshOrSubMeshSO = KERNEL::getStudyServant()->FindObjectID(theMeshOrSubMeshEntry);
 -    SALOMEDS::SObject_var    aHypothesisSO = KERNEL::getStudyServant()->FindObjectID(theDomainEntry);
 +  public:
 +    TInitEvent() {}
 +    virtual void Execute()
 +    {
 +      SUIT_Session* session = SUIT_Session::session();
 +      SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
  
 -    if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
 -      //Find or Create Applied Hypothesis root
 -      SALOMEDS::SObject_var anAppliedDomainSO;
 -      if( !aMeshOrSubMeshSO->FindSubObject( theRefOnAppliedDomainTag, anAppliedDomainSO ))
 -      {
 -        anAppliedDomainSO = theStudyBuilder->NewObjectToTag(aMeshOrSubMeshSO,theRefOnAppliedDomainTag);
 -        SALOMEDS::GenericAttribute_var anAttr =
 -          theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeName");
 -        SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 -        aName->SetValue(theAppliedDomainMEN.toLatin1().data());
 -        aName->UnRegister();
 -        anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeSelectable");
 -        SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 -        aSelAttr->SetSelectable(false);
 -        aSelAttr->UnRegister();
 -        anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributePixMap");
 -        SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 -        aPixmap->SetPixMap(theAppliedDomainICON.toLatin1().data());
 -        aPixmap->UnRegister();
 -      }
 -      SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(anAppliedDomainSO);
 -      theStudyBuilder->Addreference(aSObject,aHypothesisSO);
 -      aSObject->UnRegister();
 -      anAppliedDomainSO->UnRegister();
 +      if ( !SMESHGUI::GetSMESHGUI() )
 +      app->loadModule( "Mesh" );
      }
 -    if ( !aMeshOrSubMeshSO->_is_nil() ) aMeshOrSubMeshSO->UnRegister();
 -    if ( !aHypothesisSO->_is_nil())     aHypothesisSO->UnRegister();
 -  }
 +  };
  
-   // set current study
-   std::vector<std::string> studies = SalomeApp_Application::studyMgr()->GetOpenStudies();
-   if ( studies.size() > 0 )
-   {
-     _PTR(Study) study = SalomeApp_Application::studyMgr()->GetStudyByName( studies[0] );
-     int studyId = study->StudyId();
-     if ( myCachedStudyId != studyId )
-     {
-       myCachedStudyId = studyId;
-       SMESHGUI::GetSMESHGen()->SetCurrentStudy( _CAST(Study, study)->GetStudy() );
-     }
-   }
-   else
-   {
-     myCachedStudyId = 0;
-   }
 +  // load SMESH GUI if it's not yet loaded
 +  ProcessVoidEvent( new TInitEvent() );
++  SMESHGUI::GetSMESHGen()->UpdateStudy();
 +}
  
 -  //---------------------------------------------------------------
 -  void
 -  SetHypothesis(const char*                       theMeshOrSubMeshEntry,
 -                const char*                       theDomainEntry,
 -                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 -  {
 -    SetDomain(theMeshOrSubMeshEntry,
 -              theDomainEntry,
 -              theStudyBuilder,
 -              SMESH::Tag_RefOnAppliedHypothesis,
 -              QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"),
 -              "ICON_SMESH_TREE_HYPO");
 -  }
 +/////////////////////////////////////////////////////////////////
 +/// \brief Publish object.
 +/// \param ior IOR of the mesh object to publish.
 +/// \param name Study name of the object; if not given,
 +///             name is assigned automatically.
 +/// \return UID of the data object.
 +/////////////////////////////////////////////////////////////////
 +const char* SMESH_Swig::publish(const char* ior, const char* name)
 +{
 +  init();
  
-   if ( myCachedStudyId > 0 )
-   {
-     _PTR(Study) study = SalomeApp_Application::studyMgr()->GetStudyByID( myCachedStudyId );
-     CORBA::Object_var object = string2object( ior );
-     if ( study && !CORBA::is_nil( object ) )
 +  std::string uid;
-       SMESHGUI::GetSMESHGen()->PublishInStudy( _CAST(Study, study)->GetStudy(),
-                                                SALOMEDS::SObject::_nil(),
++  CORBA::Object_var object = string2object( ior );
++  if ( !CORBA::is_nil( object ) )
 +    {
 +      SALOMEDS::SObject_var sobject =
-       {
-       uid = sobject->GetID();
-       }
++      SMESHGUI::GetSMESHGen()->PublishInStudy( SALOMEDS::SObject::_nil(),
 +                                               object.in(),
 +                                               name );
 +      if ( !CORBA::is_nil( sobject ) )
-   }
++      {
++        uid = sobject->GetID();
++      }
 +      sobject->UnRegister();
 +    }
  
 -  //---------------------------------------------------------------
 -  void
 -  SetAlgorithms(const char*                       theMeshOrSubMeshEntry,
 -                const char*                       theDomainEntry,
 -                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 -  {
 -    SetDomain(theMeshOrSubMeshEntry,
 -              theDomainEntry,
 -              theStudyBuilder,
 -              SMESH::Tag_RefOnAppliedAlgorithms,
 -              QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"),
 -              "ICON_SMESH_TREE_ALGO");
 -  }
 +  return strdup( uid.c_str() );
  }
  
 +/////////////////////////////////////////////////////////////////
 +/// \brief Set new study name of given object.
 +/// \param uid Object's study UID or IOR.
 +/// \param name New name of the object.
 +/////////////////////////////////////////////////////////////////
 +void SMESH_Swig::rename(const char* uid, const char* name)
 +{
 +  init();
  
-   _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
 -//===============================================================
 -SMESH_Swig::SMESH_Swig()
++  _PTR(SObject) sobject = uid2object( uid );
 +  if ( sobject )
 +    sobject->SetAttrString( "AttributeName", name );
 +}
 +
 +/////////////////////////////////////////////////////////////////
 +/// \brief Display mesh object.
 +/// \param uid Object's study UID or IOR.
 +/// \param viewUid View window UID (0 means currently active view
 +///                window; if there's no view, it is created).
 +///                Default: 0.
 +/// \param updateViewer "Update view" flag. Default: \c true.
 +/////////////////////////////////////////////////////////////////
 +void SMESH_Swig::display(const char* uid, int viewUid, bool updateViewer)
  {
 -  class TEvent: public SALOME_Event
 +  class TDisplayEvent: public SALOME_Event
    {
 -    CORBA::ORB_var& myORB;
 +  private:
 +    const char* myUid;
 +    int myViewUid;
 +    bool myIsUpdate;
    public:
 +    TDisplayEvent(const char* uid, int viewUid, bool updateViewer)
 +      : myUid( uid ), myViewUid( viewUid ), myIsUpdate( updateViewer ) {}
 +    virtual void Execute()
 +    {
 +      SALOME_View* view = uid2wnd( myViewUid, true ); // create view if it's not present
 +      if ( view )
 +      LightApp_Displayer::FindDisplayer( "Mesh", true )->Display( myUid, myIsUpdate, view );
 +    }
 +  };
 +
 +  init();
  
-   _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
 -    TEvent(CORBA::ORB_var& theORB):
 -      myORB(theORB)
 -    {}
++  _PTR(SObject) sobject = uid2object( uid );
 +  if ( sobject )
 +    ProcessVoidEvent( new TDisplayEvent( sobject->GetID().c_str(), viewUid, updateViewer ) );
 +}
  
 -    virtual
 -    void
 -    Execute()
 +/////////////////////////////////////////////////////////////////
 +/// \brief Erase mesh object.
 +/// \param uid Object's study UID or IOR.
 +/// \param viewUid View window UID (0 means currently active view
 +///                window); -1 means "all view windows".
 +///                Default: 0.
 +/// \param updateViewer "Update view" flag. Default: \c true.
 +/////////////////////////////////////////////////////////////////
 +void SMESH_Swig::erase(const char* uid, int viewUid, bool updateViewer)
 +{
 +  class TEraseEvent: public SALOME_Event
 +  {
 +  private:
 +    const char* myUid;
 +    int myViewUid;
 +    bool myIsUpdate;
 +  public:
 +    TEraseEvent(const char* uid, int viewUid, bool updateViewer)
 +      : myUid( uid ), myViewUid( viewUid ), myIsUpdate( updateViewer ) {}
 +    virtual void Execute()
      {
 -      try {
 -        ORB_INIT &anORBInit = *SINGLETON_<ORB_INIT>::Instance();
 -        ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 -        myORB = anORBInit( 0, 0 );
 -      } catch (...) {
 -        INFOS("internal error : orb not found");
 +      if ( myViewUid == -1 )
 +      {
 +      QList<SALOME_View*> views = windows();
 +      foreach( SALOME_View* view, views )
 +        LightApp_Displayer::FindDisplayer( "Mesh", true )->Erase( myUid, true, myIsUpdate, view );
 +      }
 +      else
 +      {
 +      SALOME_View* view = uid2wnd( myViewUid );
 +      if ( view )
 +        LightApp_Displayer::FindDisplayer( "Mesh", true )->Erase( myUid, true, myIsUpdate, view );
        }
      }
    };
  
 -  //MESSAGE("Constructeur");
 -
 -  if(CORBA::is_nil(anORB))
 -    ProcessVoidEvent(new TEvent(anORB));
 +  init();
  
-   _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
 -  ASSERT(!CORBA::is_nil(anORB));
++  _PTR(SObject) sobject = uid2object( uid );
 +  if ( sobject )
 +    ProcessVoidEvent( new TEraseEvent( sobject->GetID().c_str(), viewUid, updateViewer ) );
  }
  
 -
 -//===============================================================
 -void
 -SMESH_Swig::Init()
 +/////////////////////////////////////////////////////////////////
 +/// \brief Update mesh object.
 +/// \param uid Object's study UID or IOR.
 +/////////////////////////////////////////////////////////////////
 +void SMESH_Swig::update(const char* uid)
  {
 -  class TEvent: public SALOME_Event
 +  class TUpdateEvent: public SALOME_Event
    {
 -    SALOMEDS::StudyBuilder_var& myStudyBuilder;
 -    SALOMEDS::SComponent_var&   mySComponentMesh;
 +  private:
 +    const char* myUid;
    public:
 -    TEvent(SALOMEDS::StudyBuilder_var& theStudyBuilder,
 -           SALOMEDS::SComponent_var&   theSComponentMesh):
 -      myStudyBuilder  (theStudyBuilder),
 -      mySComponentMesh(theSComponentMesh)
 -    {}
 -
 -    ~TEvent()
 +    TUpdateEvent( const char* uid ) : myUid( uid ) {}
 +    virtual void Execute()
      {
 -      if ( !mySComponentMesh->_is_nil() ) mySComponentMesh->UnRegister();
 +      Handle(SALOME_InteractiveObject) io = 
 +      new SALOME_InteractiveObject( myUid, "SMESH", "" );
 +      SMESH::Update( io, true );
      }
 +  };
  
 -    virtual
 -    void
 -    Execute()
 -    {
 -      SUIT_Session* aSession          = SUIT_Session::session();
 -      SUIT_Application* anApplication = aSession->activeApplication();
 -      SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 -
 -      SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
 +  init();
  
-   _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
 -      SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
++  _PTR(SObject) sobject = uid2object( uid );
 +  if ( sobject )
 +    ProcessVoidEvent( new TUpdateEvent( uid ) );
 +}
  
 -      myStudyBuilder = aStudy->NewBuilder();
 +/////////////////////////////////////////////////////////////////
 +/// \internal
 +class TGetPropsEvent: public SALOME_Event
 +{
 +public:
 +  typedef Properties TResult;
 +  TResult myResult;
 +  const char* myUid;
 +  int myViewUid;
  
 -      SALOMEDS::GenericAttribute_var anAttr;
 -      SALOMEDS::AttributeName_var    aName;
 -      SALOMEDS::AttributePixMap_var  aPixmap;
 +  TGetPropsEvent( const char* uid, int viewUid )
 +    : myUid( uid ), myViewUid( viewUid ) {}
  
 -      SALOMEDS::SComponent_var aSComponent = aStudy->FindComponent("SMESH");
 -      if ( aSComponent->_is_nil() )
 -      {
 -        bool aLocked = aStudy->GetProperties()->IsLocked();
 -        if (aLocked)
 -          aStudy->GetProperties()->SetLocked(false);
 -
 -        SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
 -        //SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
 -        if (!aSMESHGUI) {
 -          CAM_Module* aModule = anApp->module("Mesh");
 -          if(!aModule)
 -            aModule = anApp->loadModule("Mesh");
 -          aSMESHGUI = dynamic_cast<SMESHGUI*>(aModule);
 -        } //SRN: BugID IPAL9186: end of a fix
 -
 -        aSComponent = myStudyBuilder->NewComponent("SMESH");
 -
 -        anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributeName");
 -        aName  = SALOMEDS::AttributeName::_narrow(anAttr);
 -        aName->SetValue(aSMESHGUI->moduleName().toLatin1().data());
 -        aName->UnRegister();
 -
 -        anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributePixMap");
 -        aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 -        aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
 -        aPixmap->UnRegister();
 -
 -        SALOMEDS::UseCaseBuilder_var useCaseBuilder = KERNEL::getStudyServant()->GetUseCaseBuilder();
 -        useCaseBuilder->SetRootCurrent();
 -        useCaseBuilder->Append( aSComponent.in() );
 -  
 -        myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
 -        if (aLocked)
 -          KERNEL::getStudyServant()->GetProperties()->SetLocked(true);
 -      }
 +  virtual void Execute()
 +  {
 +    SALOME_View* view = uid2wnd( myViewUid );
 +    myResult = properties( view, myUid );
 +  }
 +};
  
 -      mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);
 +/////////////////////////////////////////////////////////////////
 +/// \brief Get mesh object's visual properties.
 +/// \param uid Mesh object's study UID or IOR.
 +/// \param viewUid View window UID (0 means currently active view
 +///                window); Default: 0.
 +/// \return Properties data structure.
 +/////////////////////////////////////////////////////////////////
 +Properties SMESH_Swig::properties(const char* uid, int viewUid)
 +{
 +  Properties props;
  
 -      qApp->processEvents(); // Workaround for bug 12662
 -    }
 -  };
 +  init();
  
-   _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
 -  //MESSAGE("Init");
++  _PTR(SObject) sobject = uid2object( uid );
 +  if ( sobject )
 +    props = ProcessEvent( new TGetPropsEvent( sobject->GetID().c_str(), viewUid ) );
  
 -  ProcessVoidEvent(new TEvent(myStudyBuilder,
 -                              mySComponentMesh));
 +  return props;
  }
  
 +/////////////////////////////////////////////////////////////////
 +/// \internal
 +/////////////////////////////////////////////////////////////////
 +class TSetPropsEvent: public SALOME_Event
 +{
 +public:
 +  const char* myUid;
 +  Properties myProps;
 +  int myViewUid;
  
 -//===============================================================
 -SMESH_Swig::~SMESH_Swig()
 +  TSetPropsEvent( const char* uid, const Properties& props, int viewUid )
 +    : myUid( uid ), myProps( props), myViewUid( viewUid ) {}
 +
 +  virtual void Execute()
 +  {
 +    if ( myViewUid == -1 )
 +    {
 +      QList<SALOME_View*> views = windows();
 +      foreach( SALOME_View* view, views )
 +      {
 +      setProperties( view, myUid, myProps );
 +      }
 +    }
 +    else
 +    {
 +      SALOME_View* view = uid2wnd( myViewUid );
 +      setProperties( view, myUid, myProps );
 +    }
 +  }
 +};
 +
 +/////////////////////////////////////////////////////////////////
 +/// \brief Set mesh object's visual properties.
 +/// \param uid Mesh object's study UID or IOR.
 +/// \param props Properties data structure.
 +/// \param viewUid View window UID (0 means currently active view
 +///                window); Default: 0.
 +/////////////////////////////////////////////////////////////////
 +void SMESH_Swig::setProperties(const char* uid, const Properties& props, int viewUid)
  {
 -  //MESSAGE("Destructeur");
 -}
 +  init();
  
-   _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++  _PTR(SObject) sobject = uid2object( uid );
 +  if ( sobject )
 +    ProcessVoidEvent( new TSetPropsEvent( sobject->GetID().c_str(), props, viewUid ) );
 +}
  
 -//===============================================================
 -const char* SMESH_Swig::AddNewMesh(const char* theIOR)
 +/////////////////////////////////////////////////////////////////
 +/// \internal
 +/////////////////////////////////////////////////////////////////
 +class TGetNodeNumberingEvent: public SALOME_Event
  {
 +public:
 +  typedef bool TResult;
 +  TResult myResult;
 +  const char* myUid;
 +  int myViewUid;
 +
 +  TGetNodeNumberingEvent( const char* uid, int viewUid )
 +    : myResult( false ), myUid( uid ), myViewUid( viewUid ) {}
  
 -  // VSR: added temporarily - to be removed - objects are published automatically by engine
 -  SALOMEDS::SObject_var aSObject = KERNEL::getStudyServant()->FindObjectIOR(theIOR);
 -  if (aSObject->_is_nil())
 +  virtual void Execute()
    {
 -    //Find or Create Hypothesis root
 -    SALOMEDS::SObject_var hroot = GetHypothesisRoot(mySComponentMesh,myStudyBuilder);
 -    SALOMEDS::SObject_var aroot = GetAlgorithmsRoot(mySComponentMesh,myStudyBuilder);
 -    hroot->UnRegister();
 -    aroot->UnRegister();