]> SALOME platform Git repositories - modules/smesh.git/commitdiff
Salome HOME
fight warnings, c++17. additional corrections
authorvsr <vsr@opencascade.com>
Tue, 13 Oct 2020 11:07:34 +0000 (14:07 +0300)
committervsr <vsr@opencascade.com>
Tue, 13 Oct 2020 12:14:18 +0000 (15:14 +0300)
86 files changed:
src/Controls/SMESH_ControlsDef.hxx
src/MEDWrapper/MED_Algorithm.hxx
src/SMDS/SMDS_Mesh.cxx
src/SMDS/SMDS_MeshVolume.cxx
src/SMDS/SMDS_MeshVolume.hxx
src/SMDS/SMDS_UnstructuredGrid.hxx
src/SMESH/SMESH_Algo.hxx
src/SMESH/SMESH_Gen.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_Mesh.hxx
src/SMESH/SMESH_MeshEditor.hxx
src/SMESH/SMESH_subMesh.hxx
src/SMESHGUI/SMESHGUI.h
src/SMESHGUI/SMESHGUI_FieldSelectorWdg.h
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
src/SMESH_I/SMESH_2smeshpy.hxx
src/SMESH_I/SMESH_Algo_i.hxx
src/SMESH_I/SMESH_Filter_i.hxx
src/SMESH_I/SMESH_Gen_i.cxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Group_i.hxx
src/SMESH_I/SMESH_MeshEditor_i.cxx
src/SMESH_I/SMESH_MeshEditor_i.hxx
src/SMESH_I/SMESH_Mesh_i.cxx
src/SMESH_I/SMESH_Mesh_i.hxx
src/SMESH_I/SMESH_subMesh_i.cxx
src/SMESH_I/SMESH_subMesh_i.hxx
src/StdMeshers/StdMeshers_Adaptive1D.hxx
src/StdMeshers/StdMeshers_Arithmetic1D.hxx
src/StdMeshers/StdMeshers_AutomaticLength.cxx
src/StdMeshers/StdMeshers_AutomaticLength.hxx
src/StdMeshers/StdMeshers_CartesianParameters3D.cxx
src/StdMeshers/StdMeshers_CartesianParameters3D.hxx
src/StdMeshers/StdMeshers_Deflection1D.hxx
src/StdMeshers/StdMeshers_FixedPoints1D.cxx
src/StdMeshers/StdMeshers_FixedPoints1D.hxx
src/StdMeshers/StdMeshers_Geometric1D.hxx
src/StdMeshers/StdMeshers_LayerDistribution.hxx
src/StdMeshers/StdMeshers_LocalLength.cxx
src/StdMeshers/StdMeshers_LocalLength.hxx
src/StdMeshers/StdMeshers_MEFISTO_2D.hxx
src/StdMeshers/StdMeshers_MaxLength.hxx
src/StdMeshers/StdMeshers_NotConformAllowed.hxx
src/StdMeshers/StdMeshers_NumberOfLayers.hxx
src/StdMeshers/StdMeshers_NumberOfSegments.cxx
src/StdMeshers/StdMeshers_NumberOfSegments.hxx
src/StdMeshers/StdMeshers_PolygonPerFace_2D.hxx
src/StdMeshers/StdMeshers_Prism_3D.hxx
src/StdMeshers/StdMeshers_ProjectionSource1D.hxx
src/StdMeshers/StdMeshers_ProjectionSource2D.cxx
src/StdMeshers/StdMeshers_ProjectionSource2D.hxx
src/StdMeshers/StdMeshers_ProjectionSource3D.hxx
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
src/StdMeshers/StdMeshers_SegmentLengthAroundVertex.hxx
src/StdMeshers/StdMeshers_StartEndLength.hxx
src/StdMeshers/StdMeshers_ViscousLayers.cxx
src/StdMeshers/StdMeshers_ViscousLayers.hxx
src/StdMeshers/StdMeshers_ViscousLayers2D.hxx
src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.h
src/StdMeshers_I/StdMeshers_Arithmetic1D_i.hxx
src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx
src/StdMeshers_I/StdMeshers_Deflection1D_i.hxx
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx
src/StdMeshers_I/StdMeshers_Geometric1D_i.hxx
src/StdMeshers_I/StdMeshers_LocalLength_i.hxx
src/StdMeshers_I/StdMeshers_MaxElementArea_i.hxx
src/StdMeshers_I/StdMeshers_MaxLength_i.hxx
src/StdMeshers_I/StdMeshers_NumberOfLayers_i.hxx
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.hxx
src/StdMeshers_I/StdMeshers_Prism_3D_i.hxx
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.cxx
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.hxx
src/StdMeshers_I/StdMeshers_ProjectionSource2D_i.cxx
src/StdMeshers_I/StdMeshers_ProjectionSource2D_i.hxx
src/StdMeshers_I/StdMeshers_ProjectionSource3D_i.cxx
src/StdMeshers_I/StdMeshers_ProjectionSource3D_i.hxx
src/StdMeshers_I/StdMeshers_Projection_1D_2D_3D_i.hxx
src/StdMeshers_I/StdMeshers_SegmentLengthAroundVertex_i.hxx
src/StdMeshers_I/StdMeshers_StartEndLength_i.hxx
src/StdMeshers_I/StdMeshers_ViscousLayers2D_i.cxx
src/StdMeshers_I/StdMeshers_ViscousLayers2D_i.hxx
src/StdMeshers_I/StdMeshers_ViscousLayers_i.cxx
src/StdMeshers_I/StdMeshers_ViscousLayers_i.hxx
src/StdMeshers_I/StdMeshers_i.cxx
src/Tools/MeshCut/MeshCut_Maillage.hxx

index e40eac14d212dc971fa5539ad6e4dd128b0de871..7d25f1dca9b27dfc95ad1653e34e42b92824fd41 100644 (file)
@@ -68,7 +68,7 @@ namespace SMESH{
     public:
       TSequenceOfXYZ();
 
-      explicit TSequenceOfXYZ(size_type n);                             
+      explicit TSequenceOfXYZ(size_type n);
 
       TSequenceOfXYZ(size_type n, const gp_XYZ& t);
 
index 2e6b0f5d9d3b4836ac1c996cbef69daafc8149c6..9f4093a7f676914c44b9ca21cd066a145e4a813a 100644 (file)
@@ -53,7 +53,7 @@ namespace MED
   //! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
   MEDWRAPPER_EXPORT
   TEntity2TGeom2ElemInfo
-  GetEntity2TGeom2ElemInfo(const PWrapper& /*theWrapper*/,
+  GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
                            const PMeshInfo& theMeshInfo,
                            const MED::TEntityInfo& theEntityInfo);
 
index 67a9359d1ed0e4b75a9e899b9afb911e2122d52c..f2aee846a6efbc854b55b3f766e3cdafa4c8d689 100644 (file)
@@ -68,7 +68,7 @@ int SMDS_Mesh::chunkSize = 1024;
  */
 //================================================================================
 
-int SMDS_Mesh::CheckMemory(const bool doNotRaise) 
+int SMDS_Mesh::CheckMemory(const bool doNotRaise)
 {
   return -1;
 #if !defined WIN32 && !defined __APPLE__
index 6f076fcf7d5ae03ed40ed32b0cc4b952031da271..67b3c773d2aef75e3505856b576e5f10209012e4 100644 (file)
@@ -201,7 +201,7 @@ int SMDS_MeshVolume::GetNodeIndex( const SMDS_MeshNode* node ) const
   }
   return -1;
 }
-bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/)
+bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes*/[], const int /*nbNodes*/)
 {
   return false;
 }
index 8f7803a6e4da12cd87ddafc6dd57badc147bd65d..02d95aa825cfd2308333d75a5e3283d799fdf456 100644 (file)
@@ -52,7 +52,7 @@ class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
   virtual int  NbFaces() const;
   virtual int  NbEdges() const;
   virtual int  GetNodeIndex( const SMDS_MeshNode* node ) const;
-  virtual bool ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/);
+  virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
   virtual bool IsMediumNode(const SMDS_MeshNode* node) const;
   virtual int  NbCornerNodes() const;
 
index e9ff8477521296c55f737ae33414ca80fe2dd099..e7ed86930eff89f429f374491584b97be0921e43 100644 (file)
@@ -85,7 +85,7 @@ public:
   int CellIdToDownId(int vtkCellId);
   void setCellIdToDownId(int vtkCellId, int downId);
   void CleanDownwardConnectivity();
-  void BuildDownwardConnectivity(bool /*withEdges*/);
+  void BuildDownwardConnectivity(bool withEdges);
   int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false);
   int GetParentVolumes(int* volVtkIds, int vtkId);
   int GetParentVolumes(int* volVtkIds, int downId, unsigned char downType);
@@ -115,7 +115,7 @@ public:
 protected:
   SMDS_UnstructuredGrid();
   ~SMDS_UnstructuredGrid();
-  void copyNodes(vtkPoints *newPoints, std::vector<int>& /*idNodesOldToNew*/, int& alreadyCopied, int start, int end);
+  void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end);
   void copyBloc(vtkUnsignedCharArray *newTypes,
                 const std::vector<int>& idCellsOldToNew,
                 const std::vector<int>& idNodesOldToNew,
index 6b5b4904ab5ed734b62e6e5041a9585106026931..72c17b7f972d7de7360c7a492ec366cae927daa8 100644 (file)
@@ -173,7 +173,7 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
    *              else, returns OK if at least one shape is OK
    *  \retval bool - \c true by default
    */
-  virtual bool IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const;
+  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
 
   /*!
    * \brief Sets _computeCanceled to true. It's usage depends on
@@ -480,7 +480,7 @@ public:
    *              else, returns OK if at least one shape is OK
    *  \retval bool - \c true by default
    */
-  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
+  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
 };
 
 class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo
@@ -494,7 +494,7 @@ public:
    *              else, returns OK if at least one shape is OK
    *  \retval bool - \c true by default
    */
-  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
+  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
   /*!
    * \brief Method in which an algorithm generating a structured mesh
    *        fixes positions of in-face nodes after there movement
@@ -515,7 +515,7 @@ public:
    *              else, returns OK if at least one shape is OK
    *  \retval bool - \c true by default
    */
-  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
+  virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
 };
 
 #endif
index 344877697100c8aab5eabd0477720159e9b76b38..3bc392f6cc118d514747b257b1f32f86bdc6e1e6 100644 (file)
@@ -66,8 +66,7 @@ public:
   SMESH_Gen();
   ~SMESH_Gen();
 
-  SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode)
-    ;
+  SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode);
 
   enum ComputeFlags
   {
@@ -91,10 +90,10 @@ public:
                const ::MeshDimension aDim=::MeshDim_3D,
                TSetOfInt*            aShapesId=0);
 
-  void PrepareCompute(::SMESH_Mesh &        /*aMesh*/,
-                      const TopoDS_Shape &  /*aShape*/);
-  void CancelCompute(::SMESH_Mesh &        /*aMesh*/,
-                     const TopoDS_Shape &  /*aShape*/);
+  void PrepareCompute(::SMESH_Mesh &        aMesh,
+                      const TopoDS_Shape &  aShape);
+  void CancelCompute(::SMESH_Mesh &        aMesh,
+                     const TopoDS_Shape &  aShape);
 
   const SMESH_subMesh* GetCurrentSubMesh() const;
 
index fe75ffe26ca9091558b4f433c4e2e89c8a6a5f49..d4e7c86fb4dfba9c8f3b7a977b7ff5508bcfc976 100644 (file)
@@ -618,7 +618,7 @@ SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName,
 SMESH_Hypothesis::Hypothesis_Status
 SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
                           int                  anHypId,
-                          std::string*         anError  ) 
+                          std::string*         anError  )
 {
   Unexpect aCatch(SalomeException);
   if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
@@ -713,7 +713,7 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
 
 SMESH_Hypothesis::Hypothesis_Status
 SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
-                             int                    anHypId) 
+                             int                    anHypId)
 {
   Unexpect aCatch(SalomeException);
   if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
@@ -784,7 +784,6 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
 
 const std::list<const SMESHDS_Hypothesis*>&
 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
-  
 {
   return _myMeshDS->GetHypothesis(aSubShape);
 }
@@ -993,7 +992,7 @@ SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const int anHypId) const
  */
 //=============================================================================
 
-const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() 
+const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog()
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetScript()->GetCommands();
@@ -1004,7 +1003,7 @@ const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog()
  * 
  */
 //=============================================================================
-void SMESH_Mesh::ClearLog() 
+void SMESH_Mesh::ClearLog()
 {
   Unexpect aCatch(SalomeException);
   _myMeshDS->GetScript()->Clear();
@@ -1017,7 +1016,6 @@ void SMESH_Mesh::ClearLog()
 //=============================================================================
 
 SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
-  
 {
   int index = _myMeshDS->ShapeToIndex(aSubShape);
   if ( !index && aSubShape.IsNull() )
@@ -1070,7 +1068,6 @@ SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
 //=============================================================================
 
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
-  
 {
   int index = _myMeshDS->ShapeToIndex(aSubShape);
   return GetSubMeshContaining( index );
@@ -1084,10 +1081,8 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
 //=============================================================================
 
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
-
 {
   SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
-
   return aSubMesh;
 }
 
@@ -1099,7 +1094,6 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
 
 std::list<SMESH_subMesh*>
 SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
-  
 {
   std::list<SMESH_subMesh*> found;
 
@@ -1273,13 +1267,13 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
  *  Auto color functionality
  */
 //=============================================================================
-void SMESH_Mesh::SetAutoColor(bool theAutoColor) 
+void SMESH_Mesh::SetAutoColor(bool theAutoColor)
 {
   Unexpect aCatch(SalomeException);
   _isAutoColor = theAutoColor;
 }
 
-bool SMESH_Mesh::GetAutoColor() 
+bool SMESH_Mesh::GetAutoColor()
 {
   Unexpect aCatch(SalomeException);
   return _isAutoColor;
@@ -1434,7 +1428,6 @@ void SMESH_Mesh::ExportMED(const char *        file,
                            bool                theAddODOnVertices,
                            double              theZTolerance,
                            bool                theAllElemsToGroup)
-
 {
   MESSAGE("MED_VERSION:"<< theVersion);
   SMESH_TRY;
@@ -1505,7 +1498,6 @@ void SMESH_Mesh::ExportMED(const char *        file,
 void SMESH_Mesh::ExportSAUV(const char *file, 
                             const char* theMeshName, 
                             bool theAutoGroups)
-  
 {
   std::string medfilename(file);
   medfilename += ".med";
@@ -1549,7 +1541,7 @@ void SMESH_Mesh::ExportSAUV(const char *file,
 //================================================================================
 
 void SMESH_Mesh::ExportDAT(const char *        file,
-                           const SMESHDS_Mesh* meshPart) 
+                           const SMESHDS_Mesh* meshPart)
 {
   Unexpect aCatch(SalomeException);
   DriverDAT_W_SMDS_Mesh myWriter;
@@ -1566,7 +1558,7 @@ void SMESH_Mesh::ExportDAT(const char *        file,
 //================================================================================
 
 void SMESH_Mesh::ExportUNV(const char *        file,
-                           const SMESHDS_Mesh* meshPart) 
+                           const SMESHDS_Mesh* meshPart)
 {
   Unexpect aCatch(SalomeException);
   DriverUNV_W_SMDS_Mesh myWriter;
@@ -1601,7 +1593,7 @@ void SMESH_Mesh::ExportUNV(const char *        file,
 void SMESH_Mesh::ExportSTL(const char *        file,
                            const bool          isascii,
                            const char *        name,
-                           const SMESHDS_Mesh* meshPart) 
+                           const SMESHDS_Mesh* meshPart)
 {
   Unexpect aCatch(SalomeException);
   DriverSTL_W_SMDS_Mesh myWriter;
@@ -1756,7 +1748,7 @@ double SMESH_Mesh::GetComputeProgress() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbNodes() const 
+int SMESH_Mesh::NbNodes() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->NbNodes();
@@ -1768,7 +1760,7 @@ int SMESH_Mesh::NbNodes() const
  */
 //================================================================================
 
-int SMESH_Mesh::Nb0DElements() const 
+int SMESH_Mesh::Nb0DElements() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().Nb0DElements();
@@ -1780,7 +1772,7 @@ int SMESH_Mesh::Nb0DElements() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbEdges(order);
@@ -1792,7 +1784,7 @@ int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbFaces(order);
@@ -1804,7 +1796,7 @@ int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTriangles(order);
@@ -1816,7 +1808,7 @@ int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbBiQuadTriangles() const 
+int SMESH_Mesh::NbBiQuadTriangles() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
@@ -1828,7 +1820,7 @@ int SMESH_Mesh::NbBiQuadTriangles() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
@@ -1840,7 +1832,7 @@ int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbBiQuadQuadrangles() const 
+int SMESH_Mesh::NbBiQuadQuadrangles() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
@@ -1852,7 +1844,7 @@ int SMESH_Mesh::NbBiQuadQuadrangles() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPolygons(order);
@@ -1864,7 +1856,7 @@ int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbVolumes(order);
@@ -1876,7 +1868,7 @@ int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTetras(order);
@@ -1888,7 +1880,7 @@ int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbHexas(order);
@@ -1900,7 +1892,7 @@ int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbTriQuadraticHexas() const 
+int SMESH_Mesh::NbTriQuadraticHexas() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
@@ -1912,7 +1904,7 @@ int SMESH_Mesh::NbTriQuadraticHexas() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPyramids(order);
@@ -1924,19 +1916,19 @@ int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const 
+int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPrisms(order);
 }
 
-int SMESH_Mesh::NbQuadPrisms() const 
+int SMESH_Mesh::NbQuadPrisms() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbQuadPrisms();
 }
 
-int SMESH_Mesh::NbBiQuadPrisms() const 
+int SMESH_Mesh::NbBiQuadPrisms() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
@@ -1949,7 +1941,7 @@ int SMESH_Mesh::NbBiQuadPrisms() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbHexagonalPrisms() const 
+int SMESH_Mesh::NbHexagonalPrisms() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbHexPrisms();
@@ -1961,7 +1953,7 @@ int SMESH_Mesh::NbHexagonalPrisms() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPolyhedrons() const 
+int SMESH_Mesh::NbPolyhedrons() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPolyhedrons();
@@ -1973,7 +1965,7 @@ int SMESH_Mesh::NbPolyhedrons() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbBalls() const 
+int SMESH_Mesh::NbBalls() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBalls();
@@ -1985,7 +1977,7 @@ int SMESH_Mesh::NbBalls() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbSubMesh() const 
+int SMESH_Mesh::NbSubMesh() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->NbSubMesh();
@@ -2054,7 +2046,7 @@ SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
  */
 //================================================================================
 
-SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) 
+SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS)
 {
   if ( !groupDS )
     throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase"));
index 257aed00d6a971775728b598b8ae532ddb3baa4c..4f9a3eea5520f131502c701a2054b47d508d4f9b 100644 (file)
@@ -132,16 +132,13 @@ class SMESH_EXPORT SMESH_Mesh
                                   bool        theMakeRequiredGroups = true );
 
   SMESH_Hypothesis::Hypothesis_Status
-  AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0)
-    ;
+  AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0);
   
   SMESH_Hypothesis::Hypothesis_Status
-  RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
-    ;
+  RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId);
   
   const std::list <const SMESHDS_Hypothesis * >&
-  GetHypothesisList(const TopoDS_Shape & aSubShape) const
-    ;
+  GetHypothesisList(const TopoDS_Shape & aSubShape) const;
 
   const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape &    aSubShape,
                                          const SMESH_HypoFilter& aFilter,
@@ -167,9 +164,9 @@ class SMESH_EXPORT SMESH_Mesh
 
   SMESH_Hypothesis * GetHypothesis(const int aHypID) const;
 
-  const std::list<SMESHDS_Command*> & GetLog() ;
+  const std::list<SMESHDS_Command*> & GetLog();
   
-  void ClearLog() ;
+  void ClearLog();
   
   int GetId() const          { return _id; }
   
@@ -183,19 +180,15 @@ class SMESH_EXPORT SMESH_Mesh
   
   SMESH_Gen *GetGen()        { return _gen; }
 
-  SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
-    ;
+  SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape);
   
-  SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
-    ;
+  SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const;
   
-  SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
-    ;
+  SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const;
   /*!
    * \brief Return submeshes of groups containing the given subshape
    */
-  std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
-    ;
+  std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const;
   /*!
    * \brief Say all submeshes that theChangedHyp has been modified
    */
@@ -220,9 +213,9 @@ class SMESH_EXPORT SMESH_Mesh
    */
   const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
 
-  void SetAutoColor(bool theAutoColor) ;
+  void SetAutoColor(bool theAutoColor);
 
-  bool GetAutoColor() ;
+  bool GetAutoColor();
 
   /*!
    * \brief Set the flag meaning that the mesh has been edited "manually".
@@ -263,17 +256,16 @@ class SMESH_EXPORT SMESH_Mesh
                  bool                theAutoDimension = false,
                  bool                theAddODOnVertices = false,
                  double              theZTolerance = -1.,
-                 bool                theAllElemsToGroup = false)
-    ;
+                 bool                theAllElemsToGroup = false);
 
   void ExportDAT(const char *        file,
-                 const SMESHDS_Mesh* meshPart = 0) ;
+                 const SMESHDS_Mesh* meshPart = 0);
   void ExportUNV(const char *        file,
-                 const SMESHDS_Mesh* meshPart = 0) ;
+                 const SMESHDS_Mesh* meshPart = 0);
   void ExportSTL(const char *        file,
                  const bool          isascii,
                  const char *        name = 0,
-                 const SMESHDS_Mesh* meshPart = 0) ;
+                 const SMESHDS_Mesh* meshPart = 0);
   void ExportCGNS(const char *        file,
                   const SMESHDS_Mesh* mesh,
                   const char *        meshName = 0,
@@ -283,35 +275,35 @@ class SMESH_EXPORT SMESH_Mesh
                  bool                withRequiredGroups = true );
   void ExportSAUV(const char *file, 
                   const char* theMeshName = NULL, 
-                  bool theAutoGroups = true) ;
+                  bool theAutoGroups = true);
 
   double GetComputeProgress() const;
   
-  int NbNodes() const ;
-  int Nb0DElements() const ;
-  int NbBalls() const ;
+  int NbNodes() const;
+  int Nb0DElements() const;
+  int NbBalls() const;
   
-  int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+  int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
   
-  int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbBiQuadQuadrangles() const ;
-  int NbBiQuadTriangles() const ;
-  int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+  int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbBiQuadQuadrangles() const;
+  int NbBiQuadTriangles() const;
+  int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
   
-  int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbTriQuadraticHexas() const ;
-  int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
-  int NbQuadPrisms() const ;
-  int NbBiQuadPrisms() const ;
-  int NbHexagonalPrisms() const ;
-  int NbPolyhedrons() const ;
+  int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbTriQuadraticHexas() const;
+  int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbQuadPrisms() const;
+  int NbBiQuadPrisms() const;
+  int NbHexagonalPrisms() const;
+  int NbPolyhedrons() const;
   
-  int NbSubMesh() const ;
+  int NbSubMesh() const;
   
   int NbGroup() const { return _mapGroup.size(); }
 
@@ -323,7 +315,7 @@ class SMESH_EXPORT SMESH_Mesh
                          const TopoDS_Shape&       theShape = TopoDS_Shape(),
                          const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr());
 
-  SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) ;
+  SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS);
 
   typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
   GroupIteratorPtr GetGroups() const;
index 158e8edc0bdc7f8ca020b8f1b95ff29bab1ff107..3a50a629a6b8b20280cbaf7c5f750a05a74a35e0 100644 (file)
@@ -395,10 +395,10 @@ public:
                              const SMDS_MeshNode*              srcNode,
                              std::list<const SMDS_MeshNode*> & newNodes,
                              const bool                        makeMediumNodes);
-    int makeNodesByNormal1D( SMESHDS_Mesh*                     /*mesh*/,
-                             const SMDS_MeshNode*              /*srcNode*/,
-                             std::list<const SMDS_MeshNode*> & /*newNodes*/,
-                             const bool                        /*makeMediumNodes*/);
+    int makeNodesByNormal1D( SMESHDS_Mesh*                     mesh,
+                             const SMDS_MeshNode*              srcNode,
+                             std::list<const SMDS_MeshNode*> & newNodes,
+                             const bool                        makeMediumNodes);
     int makeNodesAlongTrack( SMESHDS_Mesh*                     mesh,
                              const SMDS_MeshNode*              srcNode,
                              std::list<const SMDS_MeshNode*> & newNodes,
@@ -747,7 +747,7 @@ public:
    */
   int removeQuadElem( SMESHDS_SubMesh *    theSm,
                       SMDS_ElemIteratorPtr theItr,
-                      const int            /*theShapeID*/);
+                      const int            theShapeID);
   /*!
    * \brief Create groups of elements made during transformation
    * \param nodeGens - nodes making corresponding myLastCreatedNodes
index e1f6de3ff2349d9c738cdac2c266c16afba1c9ba..03dd98e491b9448c9cf04a8396f070004b62890f 100644 (file)
@@ -294,7 +294,7 @@ protected:
    * \brief Return a shape containing all sub-shapes of the MainShape that can be
    * meshed at once along with _subShape
    */
-  TopoDS_Shape getCollection(SMESH_Gen * /*theGen*/,
+  TopoDS_Shape getCollection(SMESH_Gen * theGen,
                              SMESH_Algo* theAlgo,
                              bool &      theSubComputed,
                              bool &      theSubFailed,
index 08f77c4e3d800521f807b13b1b79d96f283d3f2e..0105465a26087108612fcf349ab31fed70cb05c7 100644 (file)
@@ -202,7 +202,7 @@ protected:
   static void                     ProcessEvents( vtkObject* theObject, 
                                                  unsigned long theEvent,
                                                  void* theClientData, 
-                                                 void* /*theCallData*/ );
+                                                 void* theCallData );
 
 private:
   void                            OnEditDelete();
index 79ea1d3b57f35646abf1703503681582d768971c..37e28256a6f088c3ced35864148b3b4552ba9298 100644 (file)
@@ -50,7 +50,7 @@ class SMESHGUI_EXPORT SMESHGUI_FieldSelectorWdg : public QGroupBox
 
  private slots:
 
-  void onItemCheck(QTreeWidgetItem * item, int /*column*/);
+  void onItemCheck(QTreeWidgetItem * item, int column);
 
  private:
 
index f143bb17e1de6fdc2a809906a4b37aa7a9fe507a..d6ff130e1308f181edd90a0f143d3f2120e6d40c 100644 (file)
@@ -369,7 +369,6 @@ SMESH::NumericalFunctor_ptr SMESHGUI_MultiEditDlg::getNumericalFunctor()
     aNF = aFilterMgr->CreateMultiConnection2D();
   else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS"))
     aNF = aFilterMgr->CreateMaxElementLength2D();
-  //else;
 
   return aNF._retn();
 }
index 712d0c396d65a13aeb1c0459fe70e34d2ddaa3dc..c8c0a63748e1c2baab2a68514ba3c188b1b6ab18 100644 (file)
@@ -260,7 +260,7 @@ public:
   void SetCommandBefore( Handle(_pyCommand) theCmd,  Handle(_pyCommand) theBeforeCmd );
   Handle(_pyCommand)& GetLastCommand();
   std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
-  void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const;
+  void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
 
   _pyID GenerateNewID( const _pyID& theID );
   bool AddObject( Handle(_pyObject)& theObj );
@@ -600,7 +600,7 @@ public:
   virtual Handle(_pyMesh) GetMesh() { return myMesh; }
   virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
   void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
-  static bool CanBeArgOfMethod(const _AString& /*theMethodName*/);
+  static bool CanBeArgOfMethod(const _AString& theMethodName);
 
   DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject)
 };
index 03a8c8e794de09f0ea3f395cc14d35c24e40057d..0b07cc772815ddd5403862679a2ae6f78200b456 100644 (file)
@@ -56,12 +56,12 @@ public:
 
 
   // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
-  virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
-                                   std::vector< int >         & /*subIDArray*/ ) const;
+  virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
+                                   std::vector< int >         & subIDArray ) const;
 
   // Set new geometry instead of that returned by getObjectsDependOn()
-  virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
-                                   std::vector< int >         & /*subIDArray*/ );
+  virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
+                                   std::vector< int >         & subIDArray );
 };
 
 #endif
index dc4556d7576479e3c94e6bd9b111f0fd74deead1..3f786cd83633681b6c176bcfffc555c51a32d4d2 100644 (file)
@@ -822,13 +822,10 @@ namespace SMESH
 
     void                    SetElementType( ElementType theType );
     void                    SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z );
-    void                    SetVertex( GEOM::GEOM_Object_ptr vertex )
-      ;
-    void                    SetNode ( CORBA::Long nodeID )
-      ;
+    void                    SetVertex( GEOM::GEOM_Object_ptr vertex );
+    void                    SetNode ( CORBA::Long nodeID );
     void                    SetThreshold ( const char* threshold,
-                                           SMESH::ConnectedElements::ThresholdType type )
-      ;
+                                           SMESH::ConnectedElements::ThresholdType type );
     char*                   GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
 
   private:
index 0e5e819861e4c1ab6e325a35a331d516ee0f52e1..970de12bf6960d6535139a35d5fc48c48219ec22 100644 (file)
@@ -414,7 +414,6 @@ SMESH_Gen_i::~SMESH_Gen_i()
 GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
                                                               const char* theLibName,
                                                               std::string& thePlatformLibName)
-  
 {
   std::string aPlatformLibName;
   /* It's Need to translate lib name for WIN32 or X platform */
@@ -565,7 +564,6 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
@@ -814,7 +812,6 @@ StudyContext* SMESH_Gen_i::GetStudyContext()
 
 SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
                                                            const char* theLibName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   // Create hypothesis/algorithm
@@ -849,7 +846,6 @@ SMESH_Gen_i::CreateHypothesisByAverageLength( const char*    theHypType,
                                               const char*    theLibName,
                                               CORBA::Double  theAverageLength,
                                               CORBA::Boolean theQuadDominated)
-  
 {
   SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
                                       theAverageLength, theQuadDominated };
@@ -890,7 +886,6 @@ SMESH_Gen_i::GetHypothesisParameterValues( const char*                 theHypTyp
                                            SMESH::SMESH_Mesh_ptr       theMesh,
                                            GEOM::GEOM_Object_ptr       theGeom,
                                            const SMESH::HypInitParams& theParams)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -1080,7 +1075,6 @@ CORBA::Boolean SMESH_Gen_i::GetSoleSubMeshUsingHyp( SMESH::SMESH_Hypothesis_ptr
 //=============================================================================
 
 void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
-  
 {
   if ( theNbSegments > 0 )
     myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
@@ -1095,7 +1089,6 @@ void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
 //=============================================================================
 
 void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
-  
 {
   if ( theNbSegments > 0 )
     myGen.SetDefaultNbSegments( int(theNbSegments) );
@@ -1201,7 +1194,6 @@ char* SMESH_Gen_i::GetOption(const char* name)
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
@@ -1236,7 +1228,6 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObj
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
@@ -1266,7 +1257,7 @@ namespace
    */
   //================================================================================
 
-  void checkFileReadable( const char* theFileName ) 
+  void checkFileReadable( const char* theFileName )
   {
     SMESH_File f ( theFileName );
     if ( !f )
@@ -1290,7 +1281,6 @@ namespace
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -1421,7 +1411,6 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa
 
 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char*                  theFileName,
                                                      SMESH::DriverMED_ReadStatus& theStatus)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1441,7 +1430,6 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char*
 
 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char*                  theFileName,
                                                       SMESH::DriverMED_ReadStatus& theStatus)
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1484,7 +1472,6 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char*
 //=============================================================================
 
 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1525,7 +1512,6 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName
 
 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char*                  theFileName,
                                                       SMESH::DriverMED_ReadStatus& theStatus)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1613,7 +1599,6 @@ SMESH::SMESH_Mesh_ptr
 SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
                                   CORBA::Boolean          theMakeRequiredGroups,
                                   SMESH::ComputeError_out theError)
-    
 {
   Unexpect aCatch(SALOME_SalomeException);
   checkFileReadable( theFileName );
@@ -1657,7 +1642,6 @@ SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
 
 CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
                                               GEOM::GEOM_Object_ptr theShapeObject )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
@@ -1732,7 +1716,6 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::GetAlgoSO(const ::SMESH_Algo* algo)
 
 SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
                                                            GEOM::GEOM_Object_ptr theSubObject )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
@@ -1807,7 +1790,6 @@ SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr
 SMESH::MeshPreviewStruct*
 SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                   CORBA::Short          theSubShapeID )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
@@ -1895,7 +1877,6 @@ SMESH::ListOfGroups*
 SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                            CORBA::Short          theSubShapeID,
                                            const char*           theGroupName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -1930,7 +1911,6 @@ SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
 
 SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
                                                     GEOM::GEOM_Object_ptr theSubObject )
-      
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
@@ -1992,7 +1972,6 @@ SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMes
 SMESH::long_array*
 SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
                              const SMESH::object_array& theListOfSubShapeObject )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
@@ -2066,7 +2045,6 @@ SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
 
 CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
                                      GEOM::GEOM_Object_ptr theShapeObject )
-     
 {
   //MEMOSTAT;
   Unexpect aCatch(SALOME_SalomeException);
@@ -2163,7 +2141,6 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh
                                                    GEOM::GEOM_Object_ptr theShapeObject,
                                                    SMESH::Dimension      theDimension,
                                                    SMESH::long_array&    theShapesId)
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
@@ -2351,7 +2328,6 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh
 SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
                                          GEOM::GEOM_Object_ptr theShapeObject)
 //                                     SMESH::long_array& theNbElems)
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
@@ -2439,7 +2415,6 @@ GEOM::GEOM_Object_ptr
 SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                        CORBA::Long            theElementID,
                                        const char*            theGeomName)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -2503,7 +2478,6 @@ SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
 GEOM::GEOM_Object_ptr
 SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                         CORBA::Long            theElementID)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( CORBA::is_nil( theMesh ) )
@@ -2579,7 +2553,6 @@ SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray,
                          CORBA::Boolean                theMergeNodesAndElements,
                          CORBA::Double                 theMergeTolerance,
                          SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
-  
 {
   return ConcatenateCommon(theMeshesArray,
                            theUniteIdenticalGroups,
@@ -2604,7 +2577,6 @@ SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray,
                                    CORBA::Boolean                theMergeNodesAndElements,
                                    CORBA::Double                 theMergeTolerance,
                                    SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
-  
 {
   return ConcatenateCommon(theMeshesArray,
                            theUniteIdenticalGroups,
@@ -2629,7 +2601,6 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
                                CORBA::Double                 theMergeTolerance,
                                CORBA::Boolean                theCommonGroups,
                                SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
-  
 {
   std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
   TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
@@ -2909,7 +2880,6 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
                                             const char*               meshName,
                                             CORBA::Boolean            toCopyGroups,
                                             CORBA::Boolean            toKeepIDs)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -3684,7 +3654,6 @@ CORBA::Boolean SMESH_Gen_i::CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr       theSou
                                               SMESH::submesh_array_out    theNewSubmeshes,
                                               SMESH::ListOfHypothesis_out theNewHypotheses,
                                               SMESH::string_array_out     theInvalidEntries)
-
 {
   if ( CORBA::is_nil( theSourceMesh ) ||
        CORBA::is_nil( theNewGeometry ))
index 1aa3836fc20000a6f818966d41f1f8086310d99a..6ac1117b7db8ae9c8948f8a293d444e83558203a 100644 (file)
@@ -167,14 +167,12 @@ public:
 
   // Create hypothesis/algorithm of given type
   SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
-                                                const char* theLibName)
-    ;
+                                                const char* theLibName);
 
   SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char*    theHypType,
                                                                const char*    theLibName,
                                                                CORBA::Double  theAverageLength,
-                                                               CORBA::Boolean theQuadDominated)
-    ;
+                                                               CORBA::Boolean theQuadDominated);
 
   // Return hypothesis of given type holding parameter values of the existing mesh
   SMESH::SMESH_Hypothesis_ptr
@@ -182,8 +180,7 @@ public:
                                   const char*                 theLibName,
                                   SMESH::SMESH_Mesh_ptr       theMesh,
                                   GEOM::GEOM_Object_ptr       theGeom,
-                                  const SMESH::HypInitParams& theWay)
-    ;
+                                  const SMESH::HypInitParams& theWay);
 
   /*
    * Returns True if a hypothesis is assigned to a sole sub-mesh in a current Study
@@ -198,11 +195,11 @@ public:
    * Sets number of segments per diagonal of boundary box of geometry by which
    * default segment length of appropriate 1D hypotheses is defined
    */
-  void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) ;
+  void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments );
   /*!
    * \brief Sets default number of segments per edge
    */
-  void SetDefaultNbSegments(CORBA::Long theNbSegments) ;
+  void SetDefaultNbSegments(CORBA::Long theNbSegments);
 
   /*!
     Set an option value
@@ -220,48 +217,39 @@ public:
 
 
   // Create empty mesh on a shape
-  SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
-    ;
+  SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject );
 
   // Create empty mesh
-  SMESH::SMESH_Mesh_ptr CreateEmptyMesh()
-    ;
+  SMESH::SMESH_Mesh_ptr CreateEmptyMesh();
 
   //  Create a mesh and import data from an UNV file
-  SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName )
-    ;
+  SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName );
 
   //  Create mesh(es) and import data from MED file
   SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName,
-                                          SMESH::DriverMED_ReadStatus& theStatus )
-    ;
+                                          SMESH::DriverMED_ReadStatus& theStatus );
 
   //  Create mesh(es) and import data from MED file
   SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName,
-                                           SMESH::DriverMED_ReadStatus& theStatus )
-    ;
+                                           SMESH::DriverMED_ReadStatus& theStatus );
 
   //  Create a mesh and import data from a STL file
-  SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName )
-    ;
+  SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName );
 
   //  Create mesh(es) and import data from CGNS file
   SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName,
-                                           SMESH::DriverMED_ReadStatus& theStatus )
-    ;
+                                           SMESH::DriverMED_ReadStatus& theStatus );
 
   //  Create a mesh and import data from a GMF file
   SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char*             theFileName,
                                              CORBA::Boolean          theMakeRequiredGroups,
-                                             SMESH::ComputeError_out theError)
-    ;
+                                             SMESH::ComputeError_out theError);
 
   // Copy a part of mesh
   SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
                                  const char*               meshName,
                                  CORBA::Boolean            toCopyGroups,
-                                 CORBA::Boolean            toKeepIDs)
-    ;
+                                 CORBA::Boolean            toKeepIDs);
 
   // Create a mesh by copying definitions of another mesh to a given geometry
   CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr       sourceMesh,
@@ -274,13 +262,11 @@ public:
                                    SMESH::ListOfGroups_out     newGroups,
                                    SMESH::submesh_array_out    newSubmeshes,
                                    SMESH::ListOfHypothesis_out newHypotheses,
-                                   SMESH::string_array_out     invalidEntries)
-    ;
+                                   SMESH::string_array_out     invalidEntries);
 
     // Compute mesh on a shape
   CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
-                          GEOM::GEOM_Object_ptr theShapeObject )
-    ;
+                          GEOM::GEOM_Object_ptr theShapeObject );
 
   // Cancel Compute mesh on a shape
   void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
@@ -290,8 +276,7 @@ public:
    * \brief Return errors of mesh computation
    */
   SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh,
-                                               GEOM::GEOM_Object_ptr  theShapeObject )
-    ;
+                                               GEOM::GEOM_Object_ptr  theShapeObject );
 
   /*!
    * Evaluate mesh on a shape and
@@ -299,13 +284,11 @@ public:
    * Result array of number enityties
    */
   SMESH::long_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
-                              GEOM::GEOM_Object_ptr theShapeObject)
-    ;
+                              GEOM::GEOM_Object_ptr theShapeObject);
 
   // Returns true if mesh contains enough data to be computed
   CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
-                                   GEOM::GEOM_Object_ptr theShapeObject )
-    ;
+                                   GEOM::GEOM_Object_ptr theShapeObject );
 
   /*!
    * Calculate Mesh as preview till indicated dimension on shape
@@ -315,40 +298,33 @@ public:
   SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh,
                                         GEOM::GEOM_Object_ptr theSubObject,
                                         SMESH::Dimension      theDimension,
-                                        SMESH::long_array&    theShapesId )
-    ;
+                                        SMESH::long_array&    theShapesId );
 
   // Returns errors of hypotheses definition
   SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
-                                         GEOM::GEOM_Object_ptr theSubObject )
-    ;
+                                         GEOM::GEOM_Object_ptr theSubObject );
 
   // Return mesh elements preventing computation of a subshape
   SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
-                                                 CORBA::Short          theSubShapeID )
-    ;
+                                                 CORBA::Short          theSubShapeID );
 
   // Create groups of elements preventing computation of a sub-shape
   SMESH::ListOfGroups* MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
                                                      CORBA::Short          theSubShapeID,
-                                                     const char*           theGroupName)
-    ;
+                                                     const char*           theGroupName);
 
   // Get sub-shapes unique ID's list
   SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
-                                     const SMESH::object_array& theListOfSubShape )
-    ;
+                                     const SMESH::object_array& theListOfSubShape );
 
   // Return geometrical object the given element is built on. Publish it in study.
   GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
                                                   CORBA::Long            theElementID,
-                                                  const char*            theGeomName)
-    ;
+                                                  const char*            theGeomName);
 
   // Return geometrical object the given element is built on. Don't publish it in study.
   GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
-                                                   CORBA::Long            theElementID)
-    ;
+                                                   CORBA::Long            theElementID);
 
   // Concatenate the given meshes into one mesh
   SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray,
@@ -356,16 +332,14 @@ public:
                                           CORBA::Boolean                mergeNodesAndElements,
                                           CORBA::Double                 mergeTolerance,
                                           CORBA::Boolean                commonGroups,
-                                          SMESH::SMESH_Mesh_ptr         meshToAppendTo)
-    ;
+                                          SMESH::SMESH_Mesh_ptr         meshToAppendTo);
 
   // Concatenate the given meshes into one mesh
   SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray,
                                     CORBA::Boolean                uniteIdenticalGroups,
                                     CORBA::Boolean                mergeNodesAndElements,
                                     CORBA::Double                 mergeTolerance,
-                                    SMESH::SMESH_Mesh_ptr         meshToAppendTo)
-    ;
+                                    SMESH::SMESH_Mesh_ptr         meshToAppendTo);
 
   // Concatenate the given meshes into one mesh
   // Create the groups of all elements from initial meshes
@@ -373,8 +347,7 @@ public:
                                               CORBA::Boolean                uniteIdenticalGroups,
                                               CORBA::Boolean                mergeNodesAndElements,
                                               CORBA::Double                 mergeTolerance,
-                                              SMESH::SMESH_Mesh_ptr         meshToAppendTo)
-    ;
+                                              SMESH::SMESH_Mesh_ptr         meshToAppendTo);
 
   // Get version of MED format being used.
   char* GetMEDFileVersion();
@@ -445,8 +418,7 @@ public:
   // Publish object in the study
   SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject,
                                         CORBA::Object_ptr     theObject,
-                                        const char*           theName )
-    ;
+                                        const char*           theName );
 
   // Copy-paste methods - returns true if object can be copied to the clipboard
   CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr /*theObject*/ ) { return false; }
@@ -635,14 +607,12 @@ private:
   // Get hypothesis creator
   GenericHypothesisCreator_i* getHypothesisCreator( const char*  theHypName,
                                                     const char*  theLibName,
-                                                    std::string& thePlatformLibName)
-  ;
+                                                    std::string& thePlatformLibName);
   // Create hypothesis of given type
   SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName,
                                                 const char* theLibName);
   // Create empty mesh on shape
-  SMESH::SMESH_Mesh_ptr createMesh()
-    ;
+  SMESH::SMESH_Mesh_ptr createMesh();
 
   // Check mesh icon
   bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );
index e938c123a11e953704f3e9c7fef1578aec92c3a6..92a34a24806afec599061acee35cf212b3bb071b 100644 (file)
@@ -196,7 +196,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
   static SMESH_PredicatePtr GetPredicate( SMESH::Filter_ptr );
 
   // CORBA interface implementation
-  void SetFilter(SMESH::Filter_ptr theFilter) ;
+  void SetFilter(SMESH::Filter_ptr theFilter);
   SMESH::Filter_ptr GetFilter();
   virtual CORBA::Boolean IsUpToDate();
   virtual SMESH::long_array* GetListOfID();
@@ -206,7 +206,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
   virtual bool IsMeshInfoCorrect();
 
   // method of SMESH::NotifyerAndWaiter to update self when myFilter changes
-  virtual void OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool);
+  virtual void OnBaseObjModified(NotifyerAndWaiter* filter, bool);
 
  private:
   SMESH::Filter_var myFilter;
index a74dce08cb043d48295fa72039c7c83027c91ce7..f20ffec66497868c4b59faa2d36637ef442d7b01 100644 (file)
@@ -523,7 +523,6 @@ TPreviewMesh * SMESH_MeshEditor_i::getPreviewMesh(SMDSAbs_ElementType previewEle
 //================================================================================
 
 SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
-  
 {
   SMESH_TRY;
   const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
@@ -617,7 +616,6 @@ SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
 //================================================================================
 
 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
-  
 {
   SMESH_TRY;
   SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
@@ -640,7 +638,6 @@ SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
 //================================================================================
 
 SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
-  
 {
   SMESH_TRY;
   SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
@@ -660,7 +657,7 @@ SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
 //purpose  : Clears sequences of last created elements and nodes 
 //=======================================================================
 
-void SMESH_MeshEditor_i::ClearLastCreated() 
+void SMESH_MeshEditor_i::ClearLastCreated()
 {
   SMESH_TRY;
   getEditor().ClearLastCreated();
@@ -675,7 +672,6 @@ void SMESH_MeshEditor_i::ClearLastCreated()
 //=======================================================================
 
 SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
-  
 {
   SMESH_TRY;
   SMESH::ComputeError_var errOut = new SMESH::ComputeError;
@@ -787,7 +783,6 @@ CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idS
 
 CORBA::Boolean
 SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
-  
 {
   SMESH_TRY;
   initData();
@@ -817,7 +812,6 @@ SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
 //=============================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
-  
 {
   SMESH_TRY;
   initData();
@@ -845,7 +839,6 @@ CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNo
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
-  
 {
   SMESH_TRY;
   initData();
@@ -879,7 +872,6 @@ CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
-  
 {
   SMESH_TRY;
   initData();
@@ -905,7 +897,6 @@ CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::
 
 CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long    IDOfNode,
                                              CORBA::Boolean DuplicateElements)
-  
 {
   SMESH_TRY;
   initData();
@@ -935,7 +926,6 @@ CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long    IDOfNode,
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
-  
 {
   SMESH_TRY;
   initData();
@@ -965,7 +955,6 @@ CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diam
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
-  
 {
   SMESH_TRY;
   initData();
@@ -1009,7 +998,6 @@ CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
-  
 {
   SMESH_TRY;
   initData();
@@ -1058,7 +1046,6 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
-  
 {
   SMESH_TRY;
   initData();
@@ -1094,7 +1081,6 @@ CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsO
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
-  
 {
   SMESH_TRY;
   initData();
@@ -1130,7 +1116,6 @@ CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array &
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
-  
 {
   SMESH_TRY;
   initData();
@@ -1191,7 +1176,6 @@ CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
 //=============================================================================
 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
                                                      const SMESH::long_array & Quantities)
-  
 {
   SMESH_TRY;
   initData();
@@ -1230,7 +1214,6 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I
 //=============================================================================
 
 CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
-  
 {
   SMESH_TRY;
   initData();
@@ -1278,7 +1261,6 @@ SMESH::SMESH_IDSource_ptr
 SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
                                                const char*               theGroupName,
                                                CORBA::Boolean            theDuplicateElements)
-  
 {
   SMESH_TRY;
   initData();
@@ -1348,7 +1330,6 @@ SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObje
 //=============================================================================
 
 void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
-  
 {
   SMESH_TRY;
 
@@ -1383,7 +1364,6 @@ void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexI
 
 void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
                                        CORBA::Double paramOnEdge)
-  
 {
   SMESH_TRY;
 
@@ -1427,7 +1407,6 @@ void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
 
 void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
                                        CORBA::Double u, CORBA::Double v)
-  
 {
   SMESH_TRY;
   SMESHDS_Mesh * mesh = getMeshDS();
@@ -1472,7 +1451,6 @@ void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
 //=============================================================================
 
 void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
-  
 {
   SMESH_TRY;
   SMESHDS_Mesh * mesh = getMeshDS();
@@ -1503,7 +1481,6 @@ void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID
 
 void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
                                                CORBA::Long ShapeID)
-  
 {
   SMESH_TRY;
   SMESHDS_Mesh * mesh = getMeshDS();
@@ -1536,7 +1513,6 @@ void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
 
 CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
                                                CORBA::Long NodeID2)
-  
 {
   SMESH_TRY;
   initData();
@@ -1567,7 +1543,6 @@ CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
 
 CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
                                               CORBA::Long NodeID2)
-  
 {
   SMESH_TRY;
   initData();
@@ -1599,7 +1574,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
 //=============================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
-  
 {
   SMESH_TRY;
   initData();
@@ -1628,7 +1602,6 @@ CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfEleme
 //=============================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
-  
 {
   SMESH_TRY;
   initData();
@@ -1665,7 +1638,6 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
                                            const SMESH::DirStruct&   theDirection,
                                            CORBA::Long               theFace,
                                            const SMESH::PointStruct& thePoint)
-  
 {
   SMESH_TRY;
   initData(/*deleteSearchers=*/false);
@@ -1749,7 +1721,6 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
 CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
                                                SMESH::SMESH_IDSource_ptr     volumeGroup,
                                                CORBA::Boolean                outsideNormal)
-  
 {
   SMESH_TRY;
   initData();
@@ -1800,7 +1771,6 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& fac
 CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array &   IDsOfElements,
                                               SMESH::NumericalFunctor_ptr Criterion,
                                               CORBA::Double               MaxAngle)
-  
 {
   SMESH_TRY;
   initData();
@@ -1849,7 +1819,6 @@ CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array &   IDsOfE
 CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
                                                     SMESH::NumericalFunctor_ptr Criterion,
                                                     CORBA::Double               MaxAngle)
-  
 {
   SMESH_TRY;
   initData();
@@ -1883,7 +1852,6 @@ CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr
 
 CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array &   IDsOfElements,
                                               SMESH::NumericalFunctor_ptr Criterion)
-  
 {
   SMESH_TRY;
   initData();
@@ -1921,7 +1889,6 @@ CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array &   IDsOfE
 
 CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr   theObject,
                                                     SMESH::NumericalFunctor_ptr Criterion)
-  
 {
   SMESH_TRY;
   initData();
@@ -1953,7 +1920,6 @@ CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr
 //================================================================================
 
 void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
-  
 {
   SMESH_TRY;
   initData();
@@ -1977,7 +1943,6 @@ void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
 
 CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
                                               CORBA::Boolean            Diag13)
-  
 {
   SMESH_TRY;
   initData();
@@ -2007,7 +1972,6 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfEle
 
 CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
                                                     CORBA::Boolean            Diag13)
-  
 {
   SMESH_TRY;
   initData();
@@ -2042,7 +2006,6 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr th
 
 CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long                 IDOfQuad,
                                            SMESH::NumericalFunctor_ptr Criterion)
-  
 {
   SMESH_TRY;
   initData();
@@ -2075,7 +2038,6 @@ CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long                 IDOfQuad,
 
 void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
                                                 CORBA::Short              methodFlags)
-  
 {
   SMESH_TRY;
   initData();
@@ -2113,7 +2075,6 @@ void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms( SMESH::SMESH_IDSource_ptr  el
                                                    const SMESH::DirStruct&    facetToSplitNormal,
                                                    CORBA::Short               methodFlags,
                                                    CORBA::Boolean             allDomains)
-  
 {
   SMESH_TRY;
   initData();
@@ -2174,7 +2135,6 @@ void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms( SMESH::SMESH_IDSource_ptr  el
 //================================================================================
 
 void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems)
-  
 {
   SMESH_TRY;
   initData();
@@ -2210,7 +2170,6 @@ SMESH_MeshEditor_i::Smooth(const SMESH::long_array &              IDsOfElements,
                            CORBA::Long                            MaxNbOfIterations,
                            CORBA::Double                          MaxAspectRatio,
                            SMESH::SMESH_MeshEditor::Smooth_Method Method)
-  
 {
   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
                  MaxAspectRatio, Method, false );
@@ -2228,7 +2187,6 @@ SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array &              IDsO
                                      CORBA::Long                            MaxNbOfIterations,
                                      CORBA::Double                          MaxAspectRatio,
                                      SMESH::SMESH_MeshEditor::Smooth_Method Method)
-  
 {
   return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
                  MaxAspectRatio, Method, true );
@@ -2246,7 +2204,6 @@ SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr              theObjec
                                  CORBA::Long                            MaxNbOfIterations,
                                  CORBA::Double                          MaxAspectRatio,
                                  SMESH::SMESH_MeshEditor::Smooth_Method Method)
-  
 {
   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
                        MaxAspectRatio, Method, false);
@@ -2264,7 +2221,6 @@ SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr
                                            CORBA::Long                            MaxNbOfIterations,
                                            CORBA::Double                          MaxAspectRatio,
                                            SMESH::SMESH_MeshEditor::Smooth_Method Method)
-  
 {
   return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
                        MaxAspectRatio, Method, true);
@@ -2284,7 +2240,6 @@ SMESH_MeshEditor_i::smooth(const SMESH::long_array &              IDsOfElements,
                            CORBA::Double                          MaxAspectRatio,
                            SMESH::SMESH_MeshEditor::Smooth_Method Method,
                            bool                                   IsParametric)
-  
 {
   SMESH_TRY;
   initData();
@@ -2338,7 +2293,6 @@ SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr              theObjec
                                  CORBA::Double                          MaxAspectRatio,
                                  SMESH::SMESH_MeshEditor::Smooth_Method Method,
                                  bool                                   IsParametric)
-  
 {
   SMESH_TRY;
   initData();
@@ -2372,7 +2326,6 @@ SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr              theObjec
 //=============================================================================
 
 void SMESH_MeshEditor_i::RenumberNodes()
-  
 {
   SMESH_TRY;
   // Update Python script
@@ -2390,7 +2343,6 @@ void SMESH_MeshEditor_i::RenumberNodes()
 //=============================================================================
 
 void SMESH_MeshEditor_i::RenumberElements()
-  
 {
   SMESH_TRY;
   // Update Python script
@@ -2408,7 +2360,6 @@ void SMESH_MeshEditor_i::RenumberElements()
 //=======================================================================
 
 SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
-  
 {
   SMESH_TRY;
   if ( !groupIDs )
@@ -2434,7 +2385,6 @@ SMESH_MeshEditor_i::RotationSweepObjects(const SMESH::ListOfIDSources & theNodes
                                          CORBA::Long                    theNbOfSteps,
                                          CORBA::Double                  theTolerance,
                                          const bool                     theMakeGroups)
-  
 {
   SMESH_TRY;
   initData();
@@ -2637,7 +2587,6 @@ SMESH_MeshEditor_i::ExtrusionSweepObjects(const SMESH::ListOfIDSources & theNode
                                           const SMESH::double_array &    theBasePoint,
                                           const SMESH::double_array &    theAngles,
                                           CORBA::Boolean                 theAnglesVariation)
-  
 {
   SMESH_TRY;
   initData();
@@ -2720,7 +2669,6 @@ SMESH_MeshEditor_i::ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
                                       CORBA::Boolean                useInputElemsOnly,
                                       CORBA::Boolean                makeGroups,
                                       CORBA::Short                  dim)
-  
 {
   SMESH_TRY;
   initData();
@@ -2797,7 +2745,6 @@ SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements
                                       CORBA::Long               theExtrFlags,
                                       CORBA::Double             theSewTolerance,
                                       CORBA::Boolean            theMakeGroups)
-  
 {
   SMESH_TRY;
   initData();
@@ -2884,7 +2831,6 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & the
                                               const SMESH::double_array &    theScaleFactors,
                                               CORBA::Boolean                 theScalesVariation,
                                               SMESH::SMESH_MeshEditor::Extrusion_Error& theError)
-  
 {
   SMESH_TRY;
   initData();
@@ -3109,7 +3055,6 @@ SMESH_MeshEditor_i::mirror(TIDSortedElemSet &                  theElements,
                            CORBA::Boolean                      theCopy,
                            bool                                theMakeGroups,
                            ::SMESH_Mesh*                       theTargetMesh)
-  
 {
   SMESH_TRY;
   initData();
@@ -3175,7 +3120,6 @@ void SMESH_MeshEditor_i::Mirror(const SMESH::long_array &           theIDsOfElem
                                 const SMESH::AxisStruct &           theAxis,
                                 SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
                                 CORBA::Boolean                      theCopy)
-  
 {
   if ( !myIsPreviewMode ) {
     TPythonDump() << this << ".Mirror( "
@@ -3202,7 +3146,6 @@ void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr           theObj
                                       const SMESH::AxisStruct &           theAxis,
                                       SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
                                       CORBA::Boolean                      theCopy)
-  
 {
   if ( !myIsPreviewMode ) {
     TPythonDump() << this << ".MirrorObject( "
@@ -3228,7 +3171,6 @@ SMESH::ListOfGroups*
 SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array&            theIDsOfElements,
                                      const SMESH::AxisStruct&            theMirror,
                                      SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -3258,7 +3200,6 @@ SMESH::ListOfGroups*
 SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr           theObject,
                                            const SMESH::AxisStruct&            theMirror,
                                            SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -3289,7 +3230,6 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array&            theIDsOfE
                                    SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
                                    CORBA::Boolean                      theCopyGroups,
                                    const char*                         theMeshName)
-  
 {
   SMESH_Mesh_i* mesh_i;
   SMESH::SMESH_Mesh_var mesh;
@@ -3337,7 +3277,6 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr           the
                                          SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
                                          CORBA::Boolean                      theCopyGroups,
                                          const char*                         theMeshName)
-  
 {
   SMESH_Mesh_i* mesh_i;
   SMESH::SMESH_Mesh_var mesh;
@@ -3384,7 +3323,6 @@ SMESH_MeshEditor_i::translate(TIDSortedElemSet        & theElements,
                               CORBA::Boolean            theCopy,
                               bool                      theMakeGroups,
                               ::SMESH_Mesh*             theTargetMesh)
-  
 {
   SMESH_TRY;
   initData();
@@ -3438,7 +3376,6 @@ SMESH_MeshEditor_i::translate(TIDSortedElemSet        & theElements,
 void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
                                    const SMESH::DirStruct &  theVector,
                                    CORBA::Boolean            theCopy)
-  
 {
   if (!myIsPreviewMode) {
     TPythonDump() << this << ".Translate( "
@@ -3461,7 +3398,6 @@ void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
 void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
                                          const SMESH::DirStruct &  theVector,
                                          CORBA::Boolean            theCopy)
-  
 {
   if (!myIsPreviewMode) {
     TPythonDump() << this << ".TranslateObject( "
@@ -3485,7 +3421,6 @@ void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
 SMESH::ListOfGroups*
 SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
                                         const SMESH::DirStruct&  theVector)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -3512,7 +3447,6 @@ SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElement
 SMESH::ListOfGroups*
 SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
                                               const SMESH::DirStruct&   theVector)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -3540,7 +3474,6 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
                                       const SMESH::DirStruct&  theVector,
                                       CORBA::Boolean           theCopyGroups,
                                       const char*              theMeshName)
-  
 {
   SMESH_Mesh_i* mesh_i;
   SMESH::SMESH_Mesh_var mesh;
@@ -3587,7 +3520,6 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
                                             const SMESH::DirStruct&   theVector,
                                             CORBA::Boolean            theCopyGroups,
                                             const char*               theMeshName)
-  
 {
   SMESH_TRY;
   SMESH_Mesh_i* mesh_i;
@@ -3637,7 +3569,6 @@ SMESH_MeshEditor_i::rotate(TIDSortedElemSet &        theElements,
                            CORBA::Boolean            theCopy,
                            bool                      theMakeGroups,
                            ::SMESH_Mesh*             theTargetMesh)
-  
 {
   SMESH_TRY;
   initData();
@@ -3690,7 +3621,6 @@ void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
                                 const SMESH::AxisStruct & theAxis,
                                 CORBA::Double             theAngle,
                                 CORBA::Boolean            theCopy)
-  
 {
   if (!myIsPreviewMode) {
     TPythonDump() << this << ".Rotate( "
@@ -3716,7 +3646,6 @@ void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
                                       const SMESH::AxisStruct & theAxis,
                                       CORBA::Double             theAngle,
                                       CORBA::Boolean            theCopy)
-  
 {
   if ( !myIsPreviewMode ) {
     TPythonDump() << this << ".RotateObject( "
@@ -3740,7 +3669,6 @@ SMESH::ListOfGroups*
 SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
                                      const SMESH::AxisStruct& theAxis,
                                      CORBA::Double            theAngle)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -3770,7 +3698,6 @@ SMESH::ListOfGroups*
 SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
                                            const SMESH::AxisStruct&  theAxis,
                                            CORBA::Double             theAngle)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -3800,7 +3727,6 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
                                    CORBA::Double            theAngleInRadians,
                                    CORBA::Boolean           theCopyGroups,
                                    const char*              theMeshName)
-  
 {
   SMESH_TRY;
   SMESH::SMESH_Mesh_var mesh;
@@ -3853,7 +3779,6 @@ SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
                                          CORBA::Double             theAngleInRadians,
                                          CORBA::Boolean            theCopyGroups,
                                          const char*               theMeshName)
-  
 {
   SMESH_TRY;
   SMESH::SMESH_Mesh_var mesh;
@@ -3906,7 +3831,6 @@ SMESH_MeshEditor_i::scale(SMESH::SMESH_IDSource_ptr  theObject,
                           CORBA::Boolean             theCopy,
                           bool                       theMakeGroups,
                           ::SMESH_Mesh*              theTargetMesh)
-  
 {
   SMESH_TRY;
   initData();
@@ -4003,7 +3927,6 @@ SMESH::ListOfGroups*
 SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr  theObject,
                                     const SMESH::PointStruct&  thePoint,
                                     const SMESH::double_array& theScaleFact)
-  
 {
   TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
 
@@ -4030,7 +3953,6 @@ SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr  theObject,
                                   const SMESH::double_array& theScaleFact,
                                   CORBA::Boolean             theCopyGroups,
                                   const char*                theMeshName)
-  
 {
   SMESH_Mesh_i* mesh_i;
   SMESH::SMESH_Mesh_var mesh;
@@ -4081,7 +4003,6 @@ SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::Offset( SMESH::SMESH_IDSource_ptr theO
                                                   CORBA::Boolean            theCopyElements,
                                                   const char*               theMeshName,
                                                   SMESH::ListOfGroups_out   theGroups)
-  
 {
   SMESH_TRY;
   initData();
@@ -4195,7 +4116,6 @@ void SMESH_MeshEditor_i::
 FindCoincidentNodes (CORBA::Double                  Tolerance,
                      SMESH::array_of_long_array_out GroupsOfNodes,
                      CORBA::Boolean                 SeparateCornersAndMedium)
-  
 {
   SMESH_TRY;
   initData();
@@ -4220,7 +4140,6 @@ FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr      theObject,
                           CORBA::Double                  Tolerance,
                           SMESH::array_of_long_array_out GroupsOfNodes,
                           CORBA::Boolean                 SeparateCornersAndMedium)
-  
 {
   SMESH_TRY;
   initData();
@@ -4252,7 +4171,6 @@ FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources&  theObjects,
                              SMESH::array_of_long_array_out theGroupsOfNodes,
                              const SMESH::ListOfIDSources&  theExceptSubMeshOrGroups,
                              CORBA::Boolean                 theSeparateCornersAndMedium)
-  
 {
   SMESH_TRY;
   initData();
@@ -4289,7 +4207,6 @@ FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources&  theObjects,
 void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
                                      const SMESH::ListOfIDSources&     NodesToKeep,
                                      CORBA::Boolean                    AvoidMakingHoles)
-  
 {
   SMESH_TRY;
   initData();
@@ -4349,7 +4266,6 @@ void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfN
 void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources&  theObjects,
                                            const SMESH::ListOfIDSources&  theExceptObjects,
                                            SMESH::array_of_long_array_out theGroupsOfElementsID)
-  
 {
   SMESH_TRY;
   initData();
@@ -4409,7 +4325,6 @@ void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources&  theObj
 
 void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID,
                                        const SMESH::ListOfIDSources&     theElementsToKeep)
-  
 {
   SMESH_TRY;
   initData();
@@ -4464,7 +4379,6 @@ void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGrou
 //=======================================================================
 
 void SMESH_MeshEditor_i::MergeEqualElements()
-  
 {
   SMESH_TRY;
   initData();
@@ -4488,7 +4402,6 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long   NodeID,
                                             CORBA::Double x,
                                             CORBA::Double y,
                                             CORBA::Double z)
-  
 {
   SMESH_TRY;
   initData(/*deleteSearchers=*/false);
@@ -4545,7 +4458,6 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long   NodeID,
 CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
                                                   CORBA::Double y,
                                                   CORBA::Double z)
-  
 {
   SMESH_TRY;
   theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
@@ -4572,7 +4484,6 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
                                                        CORBA::Double y,
                                                        CORBA::Double z,
                                                        CORBA::Long   theNodeID)
-  
 {
   SMESH_TRY;
   // We keep theNodeSearcher until any mesh modification:
@@ -4650,7 +4561,6 @@ SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double      x,
                                                            CORBA::Double      y,
                                                            CORBA::Double      z,
                                                            SMESH::ElementType type)
-  
 {
   SMESH_TRY;
   SMESH::long_array_var res = new SMESH::long_array;
@@ -4686,7 +4596,6 @@ SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementID
                                              CORBA::Double             y,
                                              CORBA::Double             z,
                                              SMESH::ElementType        type)
-  
 {
   SMESH_TRY;
   SMESH::long_array_var res = new SMESH::long_array;
@@ -4759,7 +4668,6 @@ CORBA::Long SMESH_MeshEditor_i::ProjectPoint(CORBA::Double             x,
                                              SMESH::ElementType        type,
                                              SMESH::SMESH_IDSource_ptr meshObject,
                                              SMESH::double_array_out   projecton)
-  
 {
   if ( CORBA::is_nil( meshObject ))
     THROW_SALOME_CORBA_EXCEPTION("NULL meshObject", SALOME::BAD_PARAM);
@@ -4820,7 +4728,6 @@ CORBA::Long SMESH_MeshEditor_i::ProjectPoint(CORBA::Double             x,
 CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
                                                CORBA::Double y,
                                                CORBA::Double z)
-  
 {
   SMESH_TRY;
   theSearchersDeleter.Set( myMesh );
@@ -4839,7 +4746,6 @@ CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
 //=======================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
-  
 {
   bool isManifold = true;
 
@@ -4860,7 +4766,6 @@ CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
 //=======================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D()
-  
 {
   bool isGoodOri = true;
 
@@ -4889,7 +4794,6 @@ SMESH::array_of_long_array*
 SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr      theEdges,
                                    CORBA::Long                    theStartNode,
                                    SMESH::array_of_long_array_out theNodeGroups )
-  
 {
   if ( CORBA::is_nil( theEdges ))
     THROW_SALOME_CORBA_EXCEPTION("Get1DBranches(): NULL group given", SALOME::BAD_PARAM);
@@ -4936,7 +4840,6 @@ SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr      theEdges,
 
 SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double  theAngle,
                                                        CORBA::Boolean theAddExisting)
-  
 {
   SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges;
   SMESH_TRY;
@@ -4987,7 +4890,6 @@ SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double  theAngle,
 //=======================================================================
 
 SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly)
-  
 {
   SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders;
   SMESH_TRY;
@@ -5018,7 +4920,6 @@ SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean clo
 SMESH::SMESH_Group_ptr 
 SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole,
                              const char*              theGroupName)
-  
 {
   initData();
 
@@ -5214,7 +5115,6 @@ CORBA::Short SMESH_MeshEditor_i::
 SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
                          CORBA::Boolean                      createPolygons,
                          CORBA::Boolean                      createPolyhedra)
-  
 {
   CORBA::Short nbSewed = 0;
 
@@ -5383,7 +5283,6 @@ SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
                                    CORBA::Long LastNodeID2,
                                    CORBA::Boolean CreatePolygons,
                                    CORBA::Boolean CreatePolyedrs)
-  
 {
   SMESH_TRY;
   initData();
@@ -5447,7 +5346,6 @@ SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
                                           CORBA::Long LastNodeID1,
                                           CORBA::Long FirstNodeID2,
                                           CORBA::Long SecondNodeID2)
-  
 {
   SMESH_TRY;
   initData();
@@ -5507,7 +5405,6 @@ SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
                                     CORBA::Long LastNodeIDOnSide,
                                     CORBA::Boolean CreatePolygons,
                                     CORBA::Boolean CreatePolyedrs)
-  
 {
   SMESH_TRY;
   initData();
@@ -5569,7 +5466,6 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
                                     CORBA::Long NodeID1OfSide2ToMerge,
                                     CORBA::Long NodeID2OfSide1ToMerge,
                                     CORBA::Long NodeID2OfSide2ToMerge)
-  
 {
   SMESH_TRY;
   initData();
@@ -5625,7 +5521,6 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
 
 CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
                                                    const SMESH::long_array& newIDs)
-  
 {
   SMESH_TRY;
   initData();
@@ -5663,7 +5558,6 @@ CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
 void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean            theForce3d,
                                             CORBA::Boolean            theToBiQuad,
                                             SMESH::SMESH_IDSource_ptr theObject)
-  
 {
   SMESH_TRY;
   initData();
@@ -5695,7 +5589,6 @@ void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean            theForce3d
 //=======================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
-  
 {
   SMESH_TRY;
   initData();
@@ -5715,7 +5608,6 @@ CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
 //=======================================================================
 
 void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
-  
 {
   convertToQuadratic( theForce3d, false );
   TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
@@ -5729,7 +5621,6 @@ void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
 
 void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean            theForce3d,
                                                   SMESH::SMESH_IDSource_ptr theObject)
-  
 {
   convertToQuadratic( theForce3d, false, theObject );
   TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
@@ -5743,7 +5634,6 @@ void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean            theF
 
 void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean            theForce3d,
                                               SMESH::SMESH_IDSource_ptr theObject)
-  
 {
   convertToQuadratic( theForce3d, true, theObject );
   TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
@@ -5756,7 +5646,6 @@ void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean            theForce
 //================================================================================
 
 void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
-  
 {
   SMESH_TRY;
   initData();
@@ -5950,7 +5839,6 @@ bool SMESH_MeshEditor_i::idSourceToSet(SMESH::SMESH_IDSource_ptr  theIDSource,
 SMESH::SMESH_Group_ptr
 SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
                                    const char*               theGroupName)
-  
 {
   SMESH::SMESH_Group_var newGroup;
 
@@ -6018,7 +5906,6 @@ SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
 
 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
                                                 const SMESH::long_array& theModifiedElems )
-  
 {
   SMESH_TRY;
   initData();
@@ -6058,7 +5945,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNode
 
 CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long              theNodeId,
                                                const SMESH::long_array& theModifiedElems )
-  
 {
   SMESH_TRY;
   SMESH::long_array_var aNodes = new SMESH::long_array;
@@ -6090,7 +5976,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long              theNodeI
 
 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
                                                    SMESH::SMESH_GroupBase_ptr theModifiedElems )
-  
 {
   SMESH_TRY;
   if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
@@ -6129,7 +6014,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr th
 SMESH::SMESH_Group_ptr
 SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
                                         SMESH::SMESH_GroupBase_ptr theModifiedElems )
-  
 {
   SMESH_TRY;
   SMESH::SMESH_Group_var aNewGroup;
@@ -6185,7 +6069,6 @@ SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
 
 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
                                                     const SMESH::ListOfGroups& theModifiedElems )
-  
 {
   SMESH_TRY;
   initData();
@@ -6241,7 +6124,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& t
 SMESH::SMESH_Group_ptr
 SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
                                          const SMESH::ListOfGroups& theModifiedElems )
-  
 {
   SMESH::SMESH_Group_var aNewGroup;
 
@@ -6285,7 +6167,6 @@ SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
                                                    const SMESH::long_array& theNodesNot,
                                                    const SMESH::long_array& theAffectedElems )
-  
 {
   SMESH_TRY;
   initData();
@@ -6326,7 +6207,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theE
 CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
                                                             const SMESH::long_array& theNodesNot,
                                                             GEOM::GEOM_Object_ptr    theShape )
-  
 {
   SMESH_TRY;
   initData();
@@ -6367,7 +6247,6 @@ CORBA::Boolean
 SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
                                         SMESH::SMESH_GroupBase_ptr theNodesNot,
                                         SMESH::SMESH_GroupBase_ptr theAffectedElems)
-  
 {
   SMESH_TRY;
   if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
@@ -6412,7 +6291,6 @@ SMESH::SMESH_Group_ptr
 SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems,
                                            SMESH::SMESH_GroupBase_ptr theNodesNot,
                                            SMESH::SMESH_GroupBase_ptr theAffectedElems)
-  
 {
   TPythonDump pyDump;
   SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
@@ -6449,7 +6327,6 @@ SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
                                             SMESH::SMESH_GroupBase_ptr theAffectedElems,
                                             CORBA::Boolean             theElemGroupNeeded,
                                             CORBA::Boolean             theNodeGroupNeeded)
-  
 {
   SMESH_TRY;
   SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
@@ -6534,7 +6411,6 @@ CORBA::Boolean
 SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
                                                 SMESH::SMESH_GroupBase_ptr theNodesNot,
                                                 GEOM::GEOM_Object_ptr      theShape )
-  
 {
   SMESH_TRY;
   if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
@@ -6607,7 +6483,6 @@ CORBA::Boolean
 SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
                                          const SMESH::ListOfGroups& theNodesNot,
                                          const SMESH::ListOfGroups& theAffectedElems)
-  
 {
   SMESH_TRY;
   initData();
@@ -6649,7 +6524,6 @@ SMESH::SMESH_Group_ptr
 SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
                                             const SMESH::ListOfGroups& theNodesNot,
                                             const SMESH::ListOfGroups& theAffectedElems)
-  
 {
   TPythonDump pyDump;
   SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
@@ -6686,7 +6560,6 @@ SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems
                                              const SMESH::ListOfGroups& theAffectedElems,
                                              CORBA::Boolean             theElemGroupNeeded,
                                              CORBA::Boolean             theNodeGroupNeeded)
-  
 {
   SMESH_TRY;
   SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
@@ -6767,7 +6640,6 @@ CORBA::Boolean
 SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
                                                  const SMESH::ListOfGroups& theNodesNot,
                                                  GEOM::GEOM_Object_ptr      theShape )
-  
 {
   SMESH_TRY;
   initData();
@@ -6810,7 +6682,6 @@ SMESH::ListOfGroups*
 SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
                                                 const SMESH::ListOfGroups& theNodesNot,
                                                 GEOM::GEOM_Object_ptr      theShape )
-  
 {
   SMESH_TRY;
   SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
@@ -6910,7 +6781,6 @@ SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theEl
 //================================================================================
 
 CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
-  
 {
   SMESH_TRY;
   initData();
@@ -6952,7 +6822,6 @@ CORBA::Boolean
 SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
                                                   CORBA::Boolean             createJointElems,
                                                   CORBA::Boolean             onAllBoundaries )
-  
 {
   bool isOK = false;
 
@@ -7010,7 +6879,6 @@ SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& the
 
 CORBA::Boolean
 SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
-  
 {
   SMESH_TRY;
   initData();
@@ -7063,7 +6931,6 @@ void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double                  radius,
                                         const char*                    groupName,
                                         const SMESH::double_array&     theNodesCoords,
                                         SMESH::array_of_long_array_out GroupsOfNodes)
-  
 {
   SMESH_TRY;
 
@@ -7131,7 +6998,6 @@ SMESH_MeshEditor_i::MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr idSource,
                                      CORBA::Boolean            toCopyElements,
                                      CORBA::Boolean            toCopyExistingBondary,
                                      SMESH::SMESH_Group_out    group)
-  
 {
   SMESH_TRY;
   initData();
@@ -7228,7 +7094,6 @@ CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
                                                      const SMESH::ListOfIDSources& groups,
                                                      SMESH::SMESH_Mesh_out mesh,
                                                      SMESH::SMESH_Group_out group)
-  
 {
   SMESH_TRY;
   initData();
@@ -7383,7 +7248,6 @@ CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
 
 void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
                                       const char*                theGroupName)
-  
 {
   if ( theSegments.length() == 0 )
     THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM );
@@ -7509,7 +7373,6 @@ void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
 
 SMESH::ListOfEdges* SMESH_MeshEditor_i::MakeSlot(SMESH::SMESH_GroupBase_ptr theSegments,
                                                  CORBA::Double              theWidth)
-
 {
   if ( CORBA::is_nil( theSegments ) ||
        theSegments->GetType() != SMESH::EDGE )
index d2f563f5420161292376fb34088f73dd267f8690..b0b9dd2707e881f02ea23072ed0b21d843586a31 100644 (file)
@@ -65,27 +65,27 @@ public:
   /*!
    * Return data of mesh edition preview
    */
-  SMESH::MeshPreviewStruct* GetPreviewData() ;
+  SMESH::MeshPreviewStruct* GetPreviewData();
   /*!
    * If during last operation of MeshEditor some nodes were
    * created this method returns list of their IDs, if new nodes
    * not created - returns an empty list
    */
-  SMESH::long_array* GetLastCreatedNodes() ;
+  SMESH::long_array* GetLastCreatedNodes();
   /*!
    * If during last operation of MeshEditor some elements were
    * created this method returns list of their IDs, if new elements
    * not created - returns an empty list
    */
-  SMESH::long_array* GetLastCreatedElems() ;
+  SMESH::long_array* GetLastCreatedElems();
   /*!
    * \brief Clears sequences of last created elements and nodes 
    */
-  void ClearLastCreated() ;
+  void ClearLastCreated();
   /*!
    * \brief Returns description of an error/warning occurred during the last operation
    */
-  SMESH::ComputeError* GetLastError() ;
+  SMESH::ComputeError* GetLastError();
 
   /*!
    * \brief Wrap a sequence of ids in a SMESH_IDSource
@@ -100,38 +100,25 @@ public:
    */
   std::string GenerateGroupName(const std::string& thePrefix);
 
-  CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements)
-    ;
-  CORBA::Boolean RemoveNodes   (const SMESH::long_array & IDsOfNodes)
-    ;
-  CORBA::Long    RemoveOrphanNodes()
-    ;
+  CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
+  CORBA::Boolean RemoveNodes   (const SMESH::long_array & IDsOfNodes);
+  CORBA::Long    RemoveOrphanNodes();
 
   /*!
    * Methods for creation new elements.
    * Returns ID of created element or 0 if element not created
    */
-  CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-    ;
-  CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements)
-    ;
-  CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter)
-    ;
-  CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes)
-    ;
-  CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes)
-    ;
-  CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes)
-    ;
-  CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes)
-    ;
-  CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes)
-    ;
+  CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
+  CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements);
+  CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter);
+  CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes);
+  CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes);
+  CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
+  CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes);
+  CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes);
   CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
-                                  const SMESH::long_array & Quantities)
-    ;
-  CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces)
-    ;
+                                  const SMESH::long_array & Quantities);
+  CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces);
 
   /*!
    * \brief Create 0D elements on all nodes of the given object except those 
@@ -145,16 +132,14 @@ public:
    */
   SMESH::SMESH_IDSource_ptr Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
                                                        const char*               theGroupName,
-                                                       CORBA::Boolean            theDuplicateElements)
-    ;
+                                                       CORBA::Boolean            theDuplicateElements);
 
   /*!
    * \brief Bind a node to a vertex
    * \param NodeID - node ID
    * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
    */
-  void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
-    ;
+  void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID);
   /*!
    * \brief Store node position on an edge
    * \param NodeID - node ID
@@ -162,8 +147,7 @@ public:
    * \param paramOnEdge - parameter on edge where the node is located
    */
   void SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
-                     CORBA::Double paramOnEdge)
-    ;
+                     CORBA::Double paramOnEdge);
   /*!
    * \brief Store node position on a face
    * \param NodeID - node ID
@@ -172,36 +156,28 @@ public:
    * \param v - V parameter on face where the node is located
    */
   void SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
-                     CORBA::Double u, CORBA::Double v)
-    ;
+                     CORBA::Double u, CORBA::Double v);
   /*!
    * \brief Bind a node to a solid
    * \param NodeID - node ID
    * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
    */
-  void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
-    ;
+  void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID);
   /*!
    * \brief Bind an element to a shape
    * \param ElementID - element ID
    * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
    */
-  void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID)
-    ;
+  void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID);
 
 
   CORBA::Boolean MoveNode(CORBA::Long NodeID,
-                          CORBA::Double x, CORBA::Double y, CORBA::Double z)
-    ;
-
-  CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
-    ;
-  CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
-    ;
-  CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements)
-    ;
-  CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
-    ;
+                          CORBA::Double x, CORBA::Double y, CORBA::Double z);
+
+  CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
+  CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
+  CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements);
+  CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject);
 
   /*!
    * \brief Reorient faces contained in \a the2Dgroup.
@@ -215,7 +191,7 @@ public:
   CORBA::Long Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
                          const SMESH::DirStruct&   theDirection,
                          CORBA::Long               theFace,
-                         const SMESH::PointStruct& thePoint) ;
+                         const SMESH::PointStruct& thePoint);
   /*!
    * \brief Reorient faces basing on orientation of adjacent volumes.
    * \param faces - a list of objects containing face to reorient
@@ -226,101 +202,78 @@ public:
    */
   CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
                              SMESH::SMESH_IDSource_ptr      volumes,
-                             CORBA::Boolean                 outsideNormal)
-    ;
+                             CORBA::Boolean                 outsideNormal);
 
   // Split/Join
   CORBA::Boolean TriToQuad       (const SMESH::long_array &   IDsOfElements,
                                   SMESH::NumericalFunctor_ptr Criterion,
-                                  CORBA::Double               MaxAngle)
-    ;
+                                  CORBA::Double               MaxAngle);
   CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
                                   SMESH::NumericalFunctor_ptr Criterion,
-                                  CORBA::Double               MaxAngle)
-    ;
+                                  CORBA::Double               MaxAngle);
   CORBA::Boolean QuadToTri       (const SMESH::long_array &   IDsOfElements,
-                                  SMESH::NumericalFunctor_ptr Criterion)
-    ;
+                                  SMESH::NumericalFunctor_ptr Criterion);
   CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr   theObject,
-                                  SMESH::NumericalFunctor_ptr Criterion)
-    ;
-  void           QuadTo4Tri      (SMESH::SMESH_IDSource_ptr   theObject)
-    ;
+                                  SMESH::NumericalFunctor_ptr Criterion);
+  void           QuadTo4Tri      (SMESH::SMESH_IDSource_ptr   theObject);
   CORBA::Boolean SplitQuad       (const SMESH::long_array &   IDsOfElements,
-                                  CORBA::Boolean              Diag13)
-    ;
+                                  CORBA::Boolean              Diag13);
   CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr   theObject,
-                                  CORBA::Boolean              Diag13)
-    ;
+                                  CORBA::Boolean              Diag13);
   CORBA::Long    BestSplit       (CORBA::Long                 IDOfQuad,
-                                  SMESH::NumericalFunctor_ptr Criterion)
-    ;
+                                  SMESH::NumericalFunctor_ptr Criterion);
   void           SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
-                                       CORBA::Short             methodFlags)
-    ;
+                                       CORBA::Short             methodFlags);
   void           SplitHexahedraIntoPrisms(SMESH::SMESH_IDSource_ptr  elems,
                                           const SMESH::PointStruct & startHexPoint,
                                           const SMESH::DirStruct&    facetToSplitNormal,
                                           CORBA::Short               methodFlags,
-                                          CORBA::Boolean             allDomains)
-    ;
-  void           SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems)
-    ;
+                                          CORBA::Boolean             allDomains);
+  void           SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems);
 
   CORBA::Boolean Smooth(const SMESH::long_array &              IDsOfElements,
                         const SMESH::long_array &              IDsOfFixedNodes,
                         CORBA::Long                            MaxNbOfIterations,
                         CORBA::Double                          MaxAspectRatio,
-                        SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    ;
+                        SMESH::SMESH_MeshEditor::Smooth_Method Method);
   CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr              theObject,
                               const SMESH::long_array &              IDsOfFixedNodes,
                               CORBA::Long                            MaxNbOfIterations,
                               CORBA::Double                          MaxAspectRatio,
-                              SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    ;
+                              SMESH::SMESH_MeshEditor::Smooth_Method Method);
   CORBA::Boolean SmoothParametric(const SMESH::long_array &              IDsOfElements,
                                   const SMESH::long_array &              IDsOfFixedNodes,
                                   CORBA::Long                            MaxNbOfIterations,
                                   CORBA::Double                          MaxAspectRatio,
-                                  SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    ;
+                                  SMESH::SMESH_MeshEditor::Smooth_Method Method) ;
   CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr              theObject,
                                         const SMESH::long_array &              IDsOfFixedNodes,
                                         CORBA::Long                            MaxNbOfIterations,
                                         CORBA::Double                          MaxAspectRatio,
-                                        SMESH::SMESH_MeshEditor::Smooth_Method Method)
-    ;
+                                        SMESH::SMESH_MeshEditor::Smooth_Method Method);
   CORBA::Boolean smooth(const SMESH::long_array &              IDsOfElements,
                         const SMESH::long_array &              IDsOfFixedNodes,
                         CORBA::Long                            MaxNbOfIterations,
                         CORBA::Double                          MaxAspectRatio,
                         SMESH::SMESH_MeshEditor::Smooth_Method Method,
-                        bool                                   IsParametric)
-    ;
+                        bool                                   IsParametric);
   CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr              theObject,
                               const SMESH::long_array &              IDsOfFixedNodes,
                               CORBA::Long                            MaxNbOfIterations,
                               CORBA::Double                          MaxAspectRatio,
                               SMESH::SMESH_MeshEditor::Smooth_Method Method,
-                              bool                                   IsParametric)
-    ;
-
-  CORBA::Boolean ConvertFromQuadratic()
-    ;
-  void           ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
-    ;
-  void           ConvertToQuadratic(CORBA::Boolean Force3d)
-    ;
+                              bool                                   IsParametric);
+
+  CORBA::Boolean ConvertFromQuadratic();
+  void           ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject);
+  void           ConvertToQuadratic(CORBA::Boolean Force3d);
   void           ConvertToQuadraticObject(CORBA::Boolean            theForce3d,
-                                          SMESH::SMESH_IDSource_ptr theObject)
-    ;
+                                          SMESH::SMESH_IDSource_ptr theObject);
   void           ConvertToBiQuadratic(CORBA::Boolean            theForce3d,
-                                      SMESH::SMESH_IDSource_ptr theObject)
-    ;
+                                      SMESH::SMESH_IDSource_ptr theObject);
 
-  void RenumberNodes() ;
-  void RenumberElements() ;
+  void RenumberNodes();
+  void RenumberElements();
 
   SMESH::ListOfGroups* RotationSweepObjects(const SMESH::ListOfIDSources & Nodes,
                                             const SMESH::ListOfIDSources & Edges,
@@ -329,8 +282,7 @@ public:
                                             CORBA::Double                  AngleInRadians,
                                             CORBA::Long                    NbOfSteps,
                                             CORBA::Double                  Tolerance,
-                                            CORBA::Boolean                 ToMakeGroups)
-    ;
+                                            CORBA::Boolean                 ToMakeGroups);
 
   SMESH::ListOfGroups* ExtrusionSweepObjects(const SMESH::ListOfIDSources & Nodes,
                                              const SMESH::ListOfIDSources & Edges,
@@ -342,8 +294,7 @@ public:
                                              CORBA::Boolean                 ScalesVariation,
                                              const SMESH::double_array &    BasePoint,
                                              const SMESH::double_array &    Angles,
-                                             CORBA::Boolean                 AnglesVariation)
-    ;
+                                             CORBA::Boolean                 AnglesVariation);
 
   SMESH::ListOfGroups* ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
                                          CORBA::Double                 stepSize,
@@ -351,15 +302,13 @@ public:
                                          CORBA::Boolean                byAverageNormal,
                                          CORBA::Boolean                useInputElemsOnly,
                                          CORBA::Boolean                makeGroups,
-                                         CORBA::Short                  dim)
-    ;
+                                         CORBA::Short                  dim);
   SMESH::ListOfGroups*  AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
                                           const SMESH::DirStruct &  theStepVector,
                                           CORBA::Long               theNbOfSteps,
                                           CORBA::Long               theExtrFlags,
                                           CORBA::Double             theSewTolerance,
-                                          CORBA::Boolean            theMakeGroups)
-    ;
+                                          CORBA::Boolean            theMakeGroups);
 
   SMESH::ListOfGroups*
     ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & Nodes,
@@ -376,8 +325,7 @@ public:
                               bool                           MakeGroups,
                               const SMESH::double_array &    ScaleFactors,
                               CORBA::Boolean                 ScalesVariation,
-                              SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
-    ;
+                              SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
 
   SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr       PathMesh,
                                                GEOM::GEOM_Object_ptr       PathShape,
@@ -386,156 +334,125 @@ public:
   void Mirror(const SMESH::long_array &           IDsOfElements,
               const SMESH::AxisStruct &           Axis,
               SMESH::SMESH_MeshEditor::MirrorType MirrorType,
-              CORBA::Boolean                      Copy)
-    ;
+              CORBA::Boolean                      Copy);
   void MirrorObject(SMESH::SMESH_IDSource_ptr           theObject,
                     const SMESH::AxisStruct &           Axis,
                     SMESH::SMESH_MeshEditor::MirrorType MirrorType,
-                    CORBA::Boolean                      Copy)
-    ;
+                    CORBA::Boolean                      Copy);
   void Translate(const SMESH::long_array & IDsOfElements,
                  const SMESH::DirStruct &   Vector,
-                 CORBA::Boolean            Copy)
-    ;
+                 CORBA::Boolean            Copy);
   void TranslateObject(SMESH::SMESH_IDSource_ptr  theObject,
                        const SMESH::DirStruct &   Vector,
-                       CORBA::Boolean             Copy)
-    ;
+                       CORBA::Boolean             Copy);
   void Rotate(const SMESH::long_array & IDsOfElements,
               const SMESH::AxisStruct &  Axis,
               CORBA::Double             Angle,
-              CORBA::Boolean            Copy)
-    ;
+              CORBA::Boolean            Copy);
   void RotateObject(SMESH::SMESH_IDSource_ptr  theObject,
                     const SMESH::AxisStruct &  Axis,
                     CORBA::Double              Angle,
-                    CORBA::Boolean             Copy)
-    ;
+                    CORBA::Boolean             Copy);
 
   SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array&            IDsOfElements,
                                         const SMESH::AxisStruct&            Mirror,
-                                        SMESH::SMESH_MeshEditor::MirrorType MirrorType)
-    ;
+                                        SMESH::SMESH_MeshEditor::MirrorType MirrorType);
   SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr           Object,
                                               const SMESH::AxisStruct&            Mirror,
-                                              SMESH::SMESH_MeshEditor::MirrorType MirrorType)
-    ;
+                                              SMESH::SMESH_MeshEditor::MirrorType MirrorType);
   SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
-                                           const SMESH::DirStruct&  Vector)
-    ;
+                                           const SMESH::DirStruct&  Vector);
   SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
-                                                 const SMESH::DirStruct&   Vector)
-    ;
+                                                 const SMESH::DirStruct&   Vector);
   SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
                                         const SMESH::AxisStruct& Axis,
-                                        CORBA::Double            AngleInRadians)
-    ;
+                                        CORBA::Double            AngleInRadians);
   SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
                                               const SMESH::AxisStruct&  Axis,
-                                              CORBA::Double             AngleInRadians)
-    ;
+                                              CORBA::Double             AngleInRadians);
 
   SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array&            IDsOfElements,
                                        const SMESH::AxisStruct&            Mirror,
                                        SMESH::SMESH_MeshEditor::MirrorType MirrorType,
                                        CORBA::Boolean                      CopyGroups,
-                                       const char*                         MeshName)
-    ;
+                                       const char*                         MeshName);
   SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr           Object,
                                              const SMESH::AxisStruct&            Mirror,
                                              SMESH::SMESH_MeshEditor::MirrorType MirrorType,
                                              CORBA::Boolean                      CopyGroups,
-                                             const char*                         MeshName)
-    ;
+                                             const char*                         MeshName);
   SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
                                           const SMESH::DirStruct&  Vector,
                                           CORBA::Boolean           CopyGroups,
-                                          const char*              MeshName)
-    ;
+                                          const char*              MeshName);
   SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
                                                 const SMESH::DirStruct&   Vector,
                                                 CORBA::Boolean            CopyGroups,
-                                                const char*               MeshName)
-    ;
+                                                const char*               MeshName);
   SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements,
                                        const SMESH::AxisStruct& Axis,
                                        CORBA::Double            AngleInRadians,
                                        CORBA::Boolean           CopyGroups,
-                                       const char*              MeshName)
-    ;
+                                       const char*              MeshName);
   SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
                                              const SMESH::AxisStruct&  Axis,
                                              CORBA::Double             AngleInRadians,
                                              CORBA::Boolean            CopyGroups,
-                                             const char*               MeshName)
-    ;
+                                             const char*               MeshName);
 
   void Scale(SMESH::SMESH_IDSource_ptr  theObject,
              const SMESH::PointStruct&  thePoint,
              const SMESH::double_array& theScaleFact,
-             CORBA::Boolean             theCopy)
-    ;
+             CORBA::Boolean             theCopy);
 
   SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr  theObject,
                                        const SMESH::PointStruct&  thePoint,
-                                       const SMESH::double_array& theScaleFact)
-    ;
+                                       const SMESH::double_array& theScaleFact);
 
   SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr  Object,
                                       const SMESH::PointStruct&  Point,
                                       const SMESH::double_array& theScaleFact,
                                       CORBA::Boolean             CopyGroups,
-                                      const char*                MeshName)
-    ;
+                                      const char*                MeshName);
 
   SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject,
                                 CORBA::Double             Value,
                                 CORBA::Boolean            CopyGroups,
                                 CORBA::Boolean            CopyElements,
                                 const char*               MeshName,
-                                SMESH::ListOfGroups_out   Groups)
-    ;
+                                SMESH::ListOfGroups_out   Groups);
 
   void FindCoincidentNodes (CORBA::Double                  Tolerance,
                             SMESH::array_of_long_array_out GroupsOfNodes,
-                            CORBA::Boolean                 SeparateCornersAndMedium)
-    ;
+                            CORBA::Boolean                 SeparateCornersAndMedium);
   void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr      Object,
                                  CORBA::Double                  Tolerance,
                                  SMESH::array_of_long_array_out GroupsOfNodes,
-                                 CORBA::Boolean                 SeparateCornersAndMedium)
-    ;
+                                 CORBA::Boolean                 SeparateCornersAndMedium);
   void FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources&  Objects,
                                     CORBA::Double                  Tolerance,
                                     SMESH::array_of_long_array_out GroupsOfNodes,
                                     const SMESH::ListOfIDSources&  ExceptSubMeshOrGroups,
-                                    CORBA::Boolean                 SeparateCornersAndMedium)
-    ;
+                                    CORBA::Boolean                 SeparateCornersAndMedium);
   void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
                    const SMESH::ListOfIDSources&     NodesToKeep,
-                   CORBA::Boolean                    AvoidMakingHoles )
-    ;
+                   CORBA::Boolean                    AvoidMakingHoles );
   void FindEqualElements(const SMESH::ListOfIDSources&  Objects,
                          const SMESH::ListOfIDSources&  ExceptSubMeshOrGroups,
-                         SMESH::array_of_long_array_out GroupsOfElementsID)
-    ;
+                         SMESH::array_of_long_array_out GroupsOfElementsID);
   void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID,
-                     const SMESH::ListOfIDSources&     ElementsToKeep)
-    ;
-  void MergeEqualElements()
-    ;
+                     const SMESH::ListOfIDSources&     ElementsToKeep);
+  void MergeEqualElements();
   CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
                                      CORBA::Double y,
                                      CORBA::Double z,
-                                     CORBA::Long   nodeID)
-    ;
+                                     CORBA::Long   nodeID);
   /*!
    * \brief Return ID of node closest to a given point
    */
   CORBA::Long FindNodeClosestTo(CORBA::Double x,
                                 CORBA::Double y,
-                                CORBA::Double z)
-    ;
+                                CORBA::Double z);
   /*!
    * Return elements of given type where the given point is IN or ON.
    * 'ALL' type means elements of any type excluding nodes
@@ -543,8 +460,7 @@ public:
   SMESH::long_array* FindElementsByPoint(CORBA::Double      x,
                                          CORBA::Double      y,
                                          CORBA::Double      z,
-                                         SMESH::ElementType type)
-    ;
+                                         SMESH::ElementType type);
   /*!
    * Searching among the given elements, return elements of given type
    * where the given point is IN or ON.
@@ -554,8 +470,7 @@ public:
                                               CORBA::Double             x,
                                               CORBA::Double             y,
                                               CORBA::Double             z,
-                                              SMESH::ElementType        type)
-    ;
+                                              SMESH::ElementType        type);
 
   /*!
    * Project a point to a mesh object.
@@ -568,27 +483,23 @@ public:
                            CORBA::Double             z,
                            SMESH::ElementType        type,
                            SMESH::SMESH_IDSource_ptr meshObject,
-                           SMESH::double_array_out   projecton)
-    ;
+                           SMESH::double_array_out   projecton);
 
   /*!
    * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
    * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
    */
-  CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-    ;
+  CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z);
 
   /*!
    * Check if a 2D mesh is manifold
    */
-  CORBA::Boolean IsManifold()
-    ;
+  CORBA::Boolean IsManifold();
 
   /*!
    * Check if orientation of 2D elements is coherent
    */
-  CORBA::Boolean IsCoherentOrientation2D()
-    ;
+  CORBA::Boolean IsCoherentOrientation2D();
 
   /*!
    * Partition given 1D elements into groups of contiguous edges.
@@ -599,34 +510,29 @@ public:
    */
   SMESH::array_of_long_array* Get1DBranches( SMESH::SMESH_IDSource_ptr      edges,
                                              CORBA::Long                    startNode,
-                                             SMESH::array_of_long_array_out nodeGroups)
-    ;
+                                             SMESH::array_of_long_array_out nodeGroups);
 
   /*!
    * Return sharp edges of faces and non-manifold ones. Optionally adds existing edges.
    */
-  SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting)
-    ;
+  SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting);
 
   /*!
    * Returns all or only closed FreeBorder's.
    */
-  SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly)
-    ;
+  SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly);
 
   /*!
    * Fill with 2D elements a hole defined by a FreeBorder.
    * Optionally add new faces to a given group, which is returned
    */
   SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole,
-                                  const char*              groupName)
-    ;
+                                  const char*              groupName);
 
   SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
   CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
                                         CORBA::Boolean                      createPolygons,
-                                        CORBA::Boolean                      createPolyedrs)
-    ;
+                                        CORBA::Boolean                      createPolyedrs);
 
   SMESH::SMESH_MeshEditor::Sew_Error
     SewFreeBorders(CORBA::Long FirstNodeID1,
@@ -636,13 +542,13 @@ public:
                    CORBA::Long SecondNodeID2,
                    CORBA::Long LastNodeID2,
                    CORBA::Boolean CreatePolygons,
-                   CORBA::Boolean CreatePolyedrs) ;
+                   CORBA::Boolean CreatePolyedrs);
   SMESH::SMESH_MeshEditor::Sew_Error
     SewConformFreeBorders(CORBA::Long FirstNodeID1,
                           CORBA::Long SecondNodeID1,
                           CORBA::Long LastNodeID1,
                           CORBA::Long FirstNodeID2,
-                          CORBA::Long SecondNodeID2) ;
+                          CORBA::Long SecondNodeID2);
   SMESH::SMESH_MeshEditor::Sew_Error
     SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
                     CORBA::Long SecondNodeIDOnFreeBorder,
@@ -650,38 +556,33 @@ public:
                     CORBA::Long FirstNodeIDOnSide,
                     CORBA::Long LastNodeIDOnSide,
                     CORBA::Boolean CreatePolygons,
-                    CORBA::Boolean CreatePolyedrs) ;
+                    CORBA::Boolean CreatePolyedrs);
   SMESH::SMESH_MeshEditor::Sew_Error
     SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
                     const SMESH::long_array& IDsOfSide2Elements,
                     CORBA::Long NodeID1OfSide1ToMerge,
                     CORBA::Long NodeID1OfSide2ToMerge,
                     CORBA::Long NodeID2OfSide1ToMerge,
-                    CORBA::Long NodeID2OfSide2ToMerge) ;
+                    CORBA::Long NodeID2OfSide2ToMerge);
 
   /*!
    * Set new nodes for given element.
    * If number of nodes is not corresponded to type of
    * element - returns false
    */
-  CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs)
-    ;
+  CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs);
 
   SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
-                                        const char*               theGroupName)
-    ;
+                                        const char*               theGroupName);
 
   CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
-                              const SMESH::long_array& theModifiedElems )
-    ;
+                              const SMESH::long_array& theModifiedElems );
 
   CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
-                             const SMESH::long_array& theModifiedElems )
-    ;
+                             const SMESH::long_array& theModifiedElems );
 
   CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
-                                  SMESH::SMESH_GroupBase_ptr theModifiedElems )
-    ;
+                                  SMESH::SMESH_GroupBase_ptr theModifiedElems );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
@@ -692,16 +593,13 @@ public:
    * \sa DoubleNodeGroup()
    */
   SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
-                                             SMESH::SMESH_GroupBase_ptr theModifiedElems )
-    ;
+                                             SMESH::SMESH_GroupBase_ptr theModifiedElems );
 
   CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
-                                   const SMESH::ListOfGroups& theModifiedElems )
-    ;
+                                   const SMESH::ListOfGroups& theModifiedElems );
 
   SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
-                                              const SMESH::ListOfGroups& theModifiedElems )
-    ;
+                                              const SMESH::ListOfGroups& theModifiedElems );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -715,8 +613,7 @@ public:
    */
   CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems, 
                                  const SMESH::long_array& theNodesNot,
-                                 const SMESH::long_array& theAffectedElems )
-    ;
+                                 const SMESH::long_array& theAffectedElems );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -731,8 +628,7 @@ public:
    */
   CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems, 
                                          const SMESH::long_array& theNodesNot,
-                                         GEOM::GEOM_Object_ptr    theShape )
-    ;
+                                         GEOM::GEOM_Object_ptr    theShape );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -745,8 +641,7 @@ public:
    */
   CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
                                       SMESH::SMESH_GroupBase_ptr theNodesNot,
-                                      SMESH::SMESH_GroupBase_ptr theAffectedElems )
-    ;
+                                      SMESH::SMESH_GroupBase_ptr theAffectedElems );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -760,15 +655,13 @@ public:
    */
   SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems,
                                                  SMESH::SMESH_GroupBase_ptr theNodesNot,
-                                                 SMESH::SMESH_GroupBase_ptr theAffectedElems )
-    ;
+                                                 SMESH::SMESH_GroupBase_ptr theAffectedElems );
 
   SMESH::ListOfGroups*   DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
                                                  SMESH::SMESH_GroupBase_ptr theNodesNot,
                                                  SMESH::SMESH_GroupBase_ptr theAffectedElems,
                                                  CORBA::Boolean             theElemGroupNeeded,
-                                                 CORBA::Boolean             theNodeGroupNeeded)
-    ;
+                                                 CORBA::Boolean             theNodeGroupNeeded);
   
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -782,8 +675,7 @@ public:
    */
   CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
                                               SMESH::SMESH_GroupBase_ptr theNodesNot,
-                                              GEOM::GEOM_Object_ptr      theShape )
-    ;
+                                              GEOM::GEOM_Object_ptr      theShape );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -797,8 +689,7 @@ public:
    */
   CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
                                        const SMESH::ListOfGroups& theNodesNot,
-                                       const SMESH::ListOfGroups& theAffectedElems )
-    ;
+                                       const SMESH::ListOfGroups& theAffectedElems );
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -812,15 +703,13 @@ public:
    */
   SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems,
                                                   const SMESH::ListOfGroups& theNodesNot,
-                                                  const SMESH::ListOfGroups& theAffectedElems )
-    ;
+                                                  const SMESH::ListOfGroups& theAffectedElems );
 
   SMESH::ListOfGroups*   DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
                                                   const SMESH::ListOfGroups& theNodesNot,
                                                   const SMESH::ListOfGroups& theAffectedElems,
                                                   CORBA::Boolean             theElemGroupNeeded,
-                                                  CORBA::Boolean             theNodeGroupNeeded)
-    ;
+                                                  CORBA::Boolean             theNodeGroupNeeded);
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -835,8 +724,7 @@ public:
    */
   CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
                                                const SMESH::ListOfGroups& theNodesNot,
-                                               GEOM::GEOM_Object_ptr      theShape )
-    ;
+                                               GEOM::GEOM_Object_ptr      theShape );
 
   /*!
    * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed.
@@ -851,8 +739,7 @@ public:
    */
   SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
                                                    const SMESH::ListOfGroups& theNodesNot,
-                                                   GEOM::GEOM_Object_ptr      theShape )
-    ;
+                                                   GEOM::GEOM_Object_ptr      theShape );
 
   /*!
    * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
@@ -868,8 +755,7 @@ public:
    */
   CORBA::Boolean DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
                                                CORBA::Boolean             createJointElems,
-                                               CORBA::Boolean             onAllBoundaries )
-    ;
+                                               CORBA::Boolean             onAllBoundaries );
   /*!
    * \brief Double nodes on some external faces and create flat elements.
    * Flat elements are mainly used by some types of mechanic calculations.
@@ -879,8 +765,7 @@ public:
    * @param theGroupsOfFaces - list of groups of faces
    * @return TRUE if operation has been completed successfully, FALSE otherwise
    */
-  CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
-    ;
+  CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces );
 
   /*!
    *  \brief identify all the elements around a geom shape, get the faces delimiting the hole
@@ -892,16 +777,14 @@ public:
                       GEOM::GEOM_Object_ptr theShape,
                       const char* groupName,
                       const SMESH::double_array& theNodesCoords,
-                      SMESH::array_of_long_array_out GroupsOfNodes)
-    ;
+                      SMESH::array_of_long_array_out GroupsOfNodes);
 
   /*!
    * \brief Generated skin mesh (containing 2D cells) from 3D mesh
    * The created 2D mesh elements based on nodes of free faces of boundary volumes
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    */
-  CORBA::Boolean Make2DMeshFrom3D()
-    ;
+  CORBA::Boolean Make2DMeshFrom3D();
 
   SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
                                          SMESH::Bnd_Dimension      dimension,
@@ -909,8 +792,7 @@ public:
                                          const char*               meshName,
                                          CORBA::Boolean            toCopyElements,
                                          CORBA::Boolean            toCopyMissingBondary,
-                                         SMESH::SMESH_Group_out    group)
-    ;
+                                         SMESH::SMESH_Group_out    group);
 
   CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
                                    const char* groupName,
@@ -918,8 +800,7 @@ public:
                                    CORBA::Boolean toCopyAll,
                                    const SMESH::ListOfIDSources& groups,
                                    SMESH::SMESH_Mesh_out mesh,
-                                   SMESH::SMESH_Group_out group)
-    ;
+                                   SMESH::SMESH_Group_out group);
 
   /*!
    * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
@@ -938,8 +819,7 @@ public:
    *        be added.
    */
   void MakePolyLine(SMESH::ListOfPolySegments& segments,
-                    const char*                groupName)
-    ;
+                    const char*                groupName);
 
   /*!
    * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
@@ -948,8 +828,7 @@ public:
    * \return Edges located at the slot boundary
    */
   SMESH::ListOfEdges* MakeSlot(SMESH::SMESH_GroupBase_ptr segments,
-                               CORBA::Double              width)
-    ;
+                               CORBA::Double              width);
 
 
  private: //!< private methods
@@ -970,42 +849,36 @@ public:
   /*!
    * \brief Return groups by their IDs
    */
-  SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
-    ;
+  SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs);
 
   SMESH::ListOfGroups* mirror(TIDSortedElemSet &                  IDsOfElements,
                               const SMESH::AxisStruct &           Axis,
                               SMESH::SMESH_MeshEditor::MirrorType MirrorType,
                               CORBA::Boolean                      Copy,
                               bool                                MakeGroups,
-                              ::SMESH_Mesh*                       TargetMesh=0)
-    ;
+                              ::SMESH_Mesh*                       TargetMesh=0);
   SMESH::ListOfGroups* translate(TIDSortedElemSet        & IDsOfElements,
                                  const SMESH::DirStruct &  Vector,
                                  CORBA::Boolean            Copy,
                                  bool                      MakeGroups,
-                                 ::SMESH_Mesh*             TargetMesh=0)
-    ;
+                                 ::SMESH_Mesh*             TargetMesh=0);
   SMESH::ListOfGroups* rotate(TIDSortedElemSet &           IDsOfElements,
                               const SMESH::AxisStruct &  Axis,
                               CORBA::Double             Angle,
                               CORBA::Boolean            Copy,
                               bool                      MakeGroups,
-                              ::SMESH_Mesh*             TargetMesh=0)
-    ;
+                              ::SMESH_Mesh*             TargetMesh=0);
 
   SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr   theObject,
                              const SMESH::PointStruct&   thePoint,
                              const SMESH::double_array&  theScaleFact,
                              CORBA::Boolean              theCopy,
                              bool                        theMakeGroups,
-                             ::SMESH_Mesh*               theTargetMesh=0)
-    ;
+                             ::SMESH_Mesh*               theTargetMesh=0);
 
   void convertToQuadratic(CORBA::Boolean            theForce3d,
                           CORBA::Boolean            theToBiQuad,
-                          SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil())
-    ;
+                          SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil());
 
   SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName);
 
index ede26913c7c15f675ea5a65ed20098308d75a778..498a7a74ef1b92f9dd469df52e8f908e6df69288 100644 (file)
@@ -183,7 +183,6 @@ SMESH_Mesh_i::~SMESH_Mesh_i()
 //=============================================================================
 
 void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
-    
 {
   Unexpect aCatch(SALOME_SalomeException);
   try {
@@ -206,7 +205,6 @@ void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
 //================================================================================
 
 CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   bool res = false;
@@ -226,7 +224,6 @@ CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
 //================================================================================
 
 GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   GEOM::GEOM_Object_var aShapeObj;
@@ -263,7 +260,7 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
  */
 //================================================================================
 
-CORBA::Boolean SMESH_Mesh_i::IsLoaded() 
+CORBA::Boolean SMESH_Mesh_i::IsLoaded()
 {
   Unexpect aCatch(SALOME_SalomeException);
   return !_preMeshInfo;
@@ -275,7 +272,7 @@ CORBA::Boolean SMESH_Mesh_i::IsLoaded()
  */
 //================================================================================
 
-void SMESH_Mesh_i::Load() 
+void SMESH_Mesh_i::Load()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -288,7 +285,7 @@ void SMESH_Mesh_i::Load()
  */
 //================================================================================
 
-void SMESH_Mesh_i::Clear() 
+void SMESH_Mesh_i::Clear()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -315,7 +312,6 @@ void SMESH_Mesh_i::Clear()
 //================================================================================
 
 void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -432,7 +428,6 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
 SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char*  theFileName,
                                                           const int    theMeshIndex,
                                                           std::string& theMeshName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   int status;
@@ -498,7 +493,6 @@ SMESH::long_array* SMESH_Mesh_i::GetMEDVersionsCompatibleForAppend()
 //=============================================================================
 
 int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
-  
 {
   SMESH_TRY;
 
@@ -528,7 +522,6 @@ int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
 //=============================================================================
 
 int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
-  
 {
   SMESH_TRY;
 
@@ -573,7 +566,6 @@ namespace
 
 SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
                                                   bool        theMakeRequiredGroups )
-  
 {
   SMESH_ComputeErrorPtr error;
 
@@ -645,7 +637,6 @@ SMESH::Hypothesis_Status
 SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                             SMESH::SMESH_Hypothesis_ptr anHyp,
                             CORBA::String_out           anErrorText)
-
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -738,7 +729,6 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
 
 SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                                                         SMESH::SMESH_Hypothesis_ptr anHyp)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -817,7 +807,6 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
 
 SMESH::ListOfHypothesis *
 SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (MYDEBUG) MESSAGE("GetHypothesisList");
@@ -857,7 +846,7 @@ SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
  */
 //================================================================================
 
-SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() 
+SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (MYDEBUG) MESSAGE("GetSubMeshes");
@@ -901,7 +890,6 @@ SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
 
 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
                                                   const char*           theName )
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (CORBA::is_nil(aSubShape))
@@ -953,7 +941,6 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap
 //================================================================================
 
 void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
-  
 {
   SMESH_TRY;
 
@@ -997,7 +984,6 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
 
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
                                                   const char*        theName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -1029,7 +1015,6 @@ SMESH::SMESH_GroupOnGeom_ptr
 SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType    theElemType,
                                    const char*           theName,
                                    GEOM::GEOM_Object_ptr theGeomObj)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -1071,7 +1056,6 @@ SMESH::SMESH_GroupOnFilter_ptr
 SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
                                     const char*        theName,
                                     SMESH::Filter_ptr  theFilter )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -1111,7 +1095,6 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
 //================================================================================
 
 void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
-  
 {
   if ( theGroup->_is_nil() )
     return;
@@ -1151,7 +1134,6 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
 //=============================================================================
 
 void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
-  
 {
   SMESH_TRY;
   if ( _preMeshInfo )
@@ -1225,7 +1207,7 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup
  */
 //================================================================================
 
-SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() 
+SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if (MYDEBUG) MESSAGE("GetGroups");
@@ -1264,7 +1246,7 @@ SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
  */
 //=============================================================================
 
-CORBA::Long SMESH_Mesh_i::NbGroups() 
+CORBA::Long SMESH_Mesh_i::NbGroups()
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _mapGroups.size();
@@ -1279,7 +1261,6 @@ CORBA::Long SMESH_Mesh_i::NbGroups()
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                                   SMESH::SMESH_GroupBase_ptr theGroup2,
                                                   const char*                theName )
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1323,7 +1304,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr the
 
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
                                                        const char*                theName )
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1386,7 +1366,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                                       SMESH::SMESH_GroupBase_ptr theGroup2,
                                                       const char*                theName )
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1452,7 +1431,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr
 SMESH::SMESH_Group_ptr
 SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
                                     const char*                theName )
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1536,7 +1514,6 @@ SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                                 SMESH::SMESH_GroupBase_ptr theGroup2,
                                                 const char*                theName )
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1603,7 +1580,6 @@ SMESH::SMESH_Group_ptr
 SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
                               const SMESH::ListOfGroups& theToolGroups,
                               const char*                theName )
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1736,7 +1712,6 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups,
                              const char*                   theName,
                              SMESH::NB_COMMON_NODES_ENUM   theNbCommonNodes,
                              CORBA::Boolean                theUnderlyingOnly)
-  
 {
   SMESH::SMESH_Group_var aResGrp;
 
@@ -1917,7 +1892,6 @@ SMESH::ListOfGroups*
 SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double  theSharpAngle,
                                           CORBA::Boolean theCreateEdges,
                                           CORBA::Boolean theUseExistingEdges )
-  
 {
   if ( theSharpAngle < 0 || theSharpAngle > 180 )
     THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees",
@@ -2045,7 +2019,6 @@ void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj)
 //================================================================================
 
 void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
-  
 {
   // check if geometry changed
   bool geomChanged = true;
@@ -3040,7 +3013,6 @@ void SMESH_Mesh_i::CheckGeomGroupModif()
 //=============================================================================
 
 SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
-  
 {
   SMESH::SMESH_Group_var aGroup;
 
@@ -3342,7 +3314,6 @@ void SMESH_Mesh_i::removeGroup( const int theId )
 //================================================================================
 
 SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
-  
 {
   SMESH::log_array_var aLog;
 
@@ -3395,7 +3366,7 @@ SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
  */
 //================================================================================
 
-void SMESH_Mesh_i::ClearLog() 
+void SMESH_Mesh_i::ClearLog()
 {
   SMESH_TRY;
   _impl->ClearLog();
@@ -3509,7 +3480,6 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
 //=============================================================================
 
 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
-  
 {
   SMESH::SMESH_MeshEditor_var aMeshEdVar;
 
@@ -3538,7 +3508,6 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
 //=============================================================================
 
 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
-  
 {
   SMESH::SMESH_MeshEditor_var aMeshEdVar;
 
@@ -3562,7 +3531,7 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
  */
 //================================================================================
 
-CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() 
+CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard()
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _impl->HasModificationsToDiscard();
@@ -3610,7 +3579,7 @@ static SALOMEDS::Color getUniqueColor( const std::list<SALOMEDS::Color>& theRese
  */
 //=============================================================================
 
-void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) 
+void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor)
 {
   Unexpect aCatch(SALOME_SalomeException);
   _impl->SetAutoColor(theAutoColor);
@@ -3634,7 +3603,7 @@ void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor)
  */
 //=============================================================================
 
-CORBA::Boolean SMESH_Mesh_i::GetAutoColor() 
+CORBA::Boolean SMESH_Mesh_i::GetAutoColor()
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _impl->GetAutoColor();
@@ -3751,7 +3720,6 @@ void SMESH_Mesh_i::ExportMED(const char*        file,
                              CORBA::Long        version,
                              CORBA::Boolean     overwrite,
                              CORBA::Boolean     autoDimension)
-  
 {
   //MESSAGE("MED minor version: "<< minor);
   SMESH_TRY;
@@ -3780,7 +3748,6 @@ void SMESH_Mesh_i::ExportMED(const char*        file,
 
 void SMESH_Mesh_i::ExportSAUV (const char* file,
                                CORBA::Boolean auto_groups)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3800,7 +3767,6 @@ void SMESH_Mesh_i::ExportSAUV (const char* file,
 //================================================================================
 
 void SMESH_Mesh_i::ExportDAT (const char *file)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3823,7 +3789,6 @@ void SMESH_Mesh_i::ExportDAT (const char *file)
 //================================================================================
 
 void SMESH_Mesh_i::ExportUNV (const char *file)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3846,7 +3811,6 @@ void SMESH_Mesh_i::ExportUNV (const char *file)
 //================================================================================
 
 void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -3883,7 +3847,6 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                                    const GEOM::ListOfFields& fields,
                                    const char*               geomAssocFields,
                                    CORBA::Double             ZTolerance)
-  
 {
   MESSAGE("MED version: "<< version);
   SMESH_TRY;
@@ -4268,7 +4231,6 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
 
 void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*                 file)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4290,7 +4252,6 @@ void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
 
 void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*                 file)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4313,7 +4274,6 @@ void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
 void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*                 file,
                                    ::CORBA::Boolean            isascii)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4343,7 +4303,6 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
                               const char*                 file,
                               CORBA::Boolean              overwrite,
                               CORBA::Boolean              groupElemsByType)
-  
 {
 #ifdef WITH_CGNS
   Unexpect aCatch(SALOME_SalomeException);
@@ -4382,7 +4341,6 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
 void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
                              const char*                 file,
                              bool                        withRequiredGroups)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4466,7 +4424,7 @@ CORBA::Long SMESH_Mesh_i::Nb0DElements()
  */
 //================================================================================
 
-CORBA::Long SMESH_Mesh_i::NbBalls() 
+CORBA::Long SMESH_Mesh_i::NbBalls()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4497,7 +4455,6 @@ CORBA::Long SMESH_Mesh_i::NbEdges()
 //================================================================================
 
 CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4569,7 +4526,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()
   return _impl->NbBiQuadQuadrangles();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPolygons() 
+CORBA::Long SMESH_Mesh_i::NbPolygons()
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4578,7 +4535,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygons()
   return _impl->NbPolygons();
 }
 
-CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) 
+CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4588,7 +4545,6 @@ CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4598,7 +4554,6 @@ CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4608,7 +4563,6 @@ CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4692,7 +4646,6 @@ CORBA::Long SMESH_Mesh_i::NbPolyhedrons()
 }
 
 CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4702,7 +4655,6 @@ CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4712,7 +4664,6 @@ CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4722,7 +4673,6 @@ CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4732,7 +4682,6 @@ CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
 }
 
 CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4784,7 +4733,6 @@ SMESH::long_array* SMESH_Mesh_i::GetIDs()
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetElementsId()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4813,7 +4761,6 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId()
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
-    
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4853,7 +4800,6 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetNodesId()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   if ( _preMeshInfo )
@@ -4881,7 +4827,6 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId()
 //=============================================================================
 
 SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
-  
 {
   SMESH::ElementType type = SMESH::ALL;
   SMESH_TRY;
@@ -4903,7 +4848,6 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo
 //=============================================================================
 
 SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
-  
 {
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -4922,7 +4866,6 @@ SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
 //=============================================================================
 
 SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
-  
 {
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -4941,7 +4884,6 @@ SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
 //=============================================================================
 
 SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
-     
 {
   SMESH::long_array_var aResult = new SMESH::long_array();
 
@@ -4978,7 +4920,6 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
 
 SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
                                                    CORBA::Boolean    all)
-  
 {
   SMESH::long_array_var aResult = new SMESH::long_array();
 
@@ -5030,7 +4971,6 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
 //=============================================================================
 
 SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
-  
 {
   SMESH::ElementType type = SMESH::ALL;
 
@@ -5690,7 +5630,6 @@ SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id)
 SMESH::ListOfGroups*
 SMESH_Mesh_i::MakeGroupsOfBadInputElements( int         theSubShapeID,
                                             const char* theGroupName )
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
index 1c3cee17d76b192db1797865ca2ebe07382cd554..56edeee76b2d030a91b718027fc92ab40f8bd897 100644 (file)
@@ -65,131 +65,100 @@ public:
 
   // --- CORBA
 
-  void SetShape( GEOM::GEOM_Object_ptr theShapeObject )
-    ;
+  void SetShape( GEOM::GEOM_Object_ptr theShapeObject );
 
-  CORBA::Boolean HasShapeToMesh()
-    ;
+  CORBA::Boolean HasShapeToMesh();
 
-  GEOM::GEOM_Object_ptr GetShapeToMesh()
-    ;
+  GEOM::GEOM_Object_ptr GetShapeToMesh();
 
-  virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
-    ;
+  virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom);
 
-  CORBA::Boolean IsLoaded()
-    ;
+  CORBA::Boolean IsLoaded();
 
-  void Load()
-    ;
+  void Load();
 
-  void Clear()
-    ;
+  void Clear();
 
-  void ClearSubMesh(CORBA::Long ShapeID)
-    ;
+  void ClearSubMesh(CORBA::Long ShapeID);
 
   SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
                                          SMESH::SMESH_Hypothesis_ptr anHyp,
-                                         CORBA::String_out           anErrorText)
-    ;
+                                         CORBA::String_out           anErrorText);
 
   SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
-                                            SMESH::SMESH_Hypothesis_ptr anHyp)
-    ;
+                                            SMESH::SMESH_Hypothesis_ptr anHyp);
 
-  SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-    ;
+  SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape);
 
-  SMESH::submesh_array* GetSubMeshes()
-    ;
+  SMESH::submesh_array* GetSubMeshes();
 
-  SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName)
-    ;
+  SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName);
 
-  void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
-    ;
+  void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh );
 
-  SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName )
-    ;
+  SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName );
 
   SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType    theElemType,
                                                    const char*           theName,
-                                                   GEOM::GEOM_Object_ptr theGeomObj )
-    ;
+                                                   GEOM::GEOM_Object_ptr theGeomObj );
 
   SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
                                                        const char*        theName,
-                                                       SMESH::Filter_ptr  theFilter )
-    ;
+                                                       SMESH::Filter_ptr  theFilter );
 
-  void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
-    ;
+  void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup );
 
-  void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
-    ;
+  void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup );
 
-  SMESH::ListOfGroups* GetGroups()
-    ;
+  SMESH::ListOfGroups* GetGroups();
 
-  CORBA::Long NbGroups()
-    ;
+  CORBA::Long NbGroups();
 
   SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                       SMESH::SMESH_GroupBase_ptr theGroup2,
-                                      const char* theName )
-    ;
+                                      const char* theName );
 
   SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
-                                            const char* theName)
-    ;
+                                            const char* theName);
 
   SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                           SMESH::SMESH_GroupBase_ptr theGroup2,
-                                          const char* theName )
-    ;
+                                          const char* theName );
 
   SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups&  theGroups,
-                                                const char* theName )
-    ;
+                                                const char* theName );
 
   SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
                                     SMESH::SMESH_GroupBase_ptr theGroup2,
-                                    const char* theName )
-    ;
+                                    const char* theName );
 
   SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
                                           const SMESH::ListOfGroups& theToolGroups,
-                                          const char* theName )
-    ;
+                                          const char* theName );
 
   SMESH::SMESH_Group_ptr CreateDimGroup( const SMESH::ListOfIDSources& theGroups,
                                          SMESH::ElementType            theElemType,
                                          const char*                   theName,
                                          SMESH::NB_COMMON_NODES_ENUM   theNbCommonNodes,
-                                         CORBA::Boolean                theUnderlyingOnly )
-    ;
+                                         CORBA::Boolean                theUnderlyingOnly );
 
   SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double  theSharpAngle,
                                                    CORBA::Boolean theCreateEdges,
-                                                   CORBA::Boolean theUseExistingEdges )
-    ;
+                                                   CORBA::Boolean theUseExistingEdges );
 
-  SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn )
-    ;
+  SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn );
 
-  SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
-    ;
+  SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet);
 
-  SMESH::SMESH_MeshEditor_ptr GetMeshEditor() ;
+  SMESH::SMESH_MeshEditor_ptr GetMeshEditor();
 
-  SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() ;
+  SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer();
 
-  CORBA::Boolean HasModificationsToDiscard() ;
+  CORBA::Boolean HasModificationsToDiscard();
 
-  void ClearLog() ;
+  void ClearLog();
 
-  CORBA::Long GetId() ;
+  CORBA::Long GetId();
 
   // --- C++ interface
 
@@ -198,35 +167,28 @@ public:
 
   SMESH_Gen_i* GetGen() { return _gen_i; }
 
-  int ImportUNVFile( const char* theFileName )
-    ;
+  int ImportUNVFile( const char* theFileName );
 
-  int ImportSTLFile( const char* theFileName )
-    ;
+  int ImportSTLFile( const char* theFileName );
 
   SMESH::ComputeError* ImportGMFFile( const char* theFileName,
-                                      bool        theMakeRequiredGroups)
-    ;
+                                      bool        theMakeRequiredGroups);
 
   /*!
    * consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
    */
-  SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName )
-    ;
+  SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName );
 
   SMESH::DriverMED_ReadStatus ImportCGNSFile( const char*  theFileName,
                                               const int    theMeshIndex,
-                                              std::string& theMeshName)
-    ;
+                                              std::string& theMeshName);
 
   /*!
    *  Auto color
    */
-  void SetAutoColor(CORBA::Boolean theAutoColor)
-    ;
+  void SetAutoColor(CORBA::Boolean theAutoColor);
 
-  CORBA::Boolean GetAutoColor()
-    ;
+  CORBA::Boolean GetAutoColor();
 
   /*! Check group names for duplications.
    *  Consider maximum group name length stored in MED file.
@@ -248,20 +210,20 @@ public:
                   CORBA::Boolean     auto_groups,
                   CORBA::Long        version,
                   CORBA::Boolean     overwrite,
-                  CORBA::Boolean     autoDimension = true) ;
+                  CORBA::Boolean     autoDimension = true);
 
-  void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) ;
+  void ExportSAUV( const char* file, CORBA::Boolean auto_groups );
 
-  void ExportDAT( const char* file ) ;
-  void ExportUNV( const char* file ) ;
-  void ExportSTL( const char* file, bool isascii ) ;
+  void ExportDAT( const char* file );
+  void ExportUNV( const char* file );
+  void ExportSTL( const char* file, bool isascii );
   void ExportCGNS(SMESH::SMESH_IDSource_ptr meshPart,
                   const char*               file,
                   CORBA::Boolean            overwrite,
-                  CORBA::Boolean            groupElemsByType) ;
+                  CORBA::Boolean            groupElemsByType);
   void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
                  const char*               file,
-                 CORBA::Boolean            withRequiredGroups) ;
+                 CORBA::Boolean            withRequiredGroups);
 
   void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                        const char*               file,
@@ -271,151 +233,111 @@ public:
                        CORBA::Boolean            autoDim,
                        const GEOM::ListOfFields& fields,
                        const char*               geomAssocFields,
-                       CORBA::Double             ZTolerance) ;
+                       CORBA::Double             ZTolerance);
   void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
-                       const char*               file) ;
+                       const char*               file);
   void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
-                       const char*               file) ;
+                       const char*               file);
   void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
                        const char*               file,
-                       CORBA::Boolean            isascii) ;
+                       CORBA::Boolean            isascii);
 
   CORBA::Double GetComputeProgress();
 
-  CORBA::Long NbNodes()
-    ;
+  CORBA::Long NbNodes();
 
-  CORBA::Long NbElements()
-    ;
+  CORBA::Long NbElements();
 
-  CORBA::Long Nb0DElements()
-    ;
+  CORBA::Long Nb0DElements();
 
-  CORBA::Long NbBalls()
-    ;
+  CORBA::Long NbBalls();
 
-  CORBA::Long NbEdges()
-    ;
+  CORBA::Long NbEdges();
 
-  CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbFaces()
-    ;
+  CORBA::Long NbFaces();
 
-  CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbTriangles()
-    ;
+  CORBA::Long NbTriangles();
 
-  CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbBiQuadTriangles()
-    ;
+  CORBA::Long NbBiQuadTriangles();
 
-  CORBA::Long NbQuadrangles()
-    ;
+  CORBA::Long NbQuadrangles();
 
-  CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbBiQuadQuadrangles()
-    ;
+  CORBA::Long NbBiQuadQuadrangles();
 
-  CORBA::Long NbPolygons()
-    ;
+  CORBA::Long NbPolygons();
 
-  CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
-    ;
+  CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY);
 
-  CORBA::Long NbVolumes()
-    ;
+  CORBA::Long NbVolumes();
 
-  CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbTetras()
-    ;
+  CORBA::Long NbTetras();
 
-  CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbHexas()
-    ;
+  CORBA::Long NbHexas();
 
-  CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbTriQuadraticHexas()
-    ;
+  CORBA::Long NbTriQuadraticHexas();
 
-  CORBA::Long NbPyramids()
-    ;
+  CORBA::Long NbPyramids();
 
-  CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbPrisms()
-    ;
+  CORBA::Long NbPrisms();
 
-  CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
-    ;
+  CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order);
 
-  CORBA::Long NbHexagonalPrisms()
-    ;
+  CORBA::Long NbHexagonalPrisms();
 
-  CORBA::Long NbPolyhedrons()
-    ;
+  CORBA::Long NbPolyhedrons();
 
-  CORBA::Long NbSubMesh()
-    ;
+  CORBA::Long NbSubMesh();
 
-  SMESH::long_array* GetElementsId()
-    ;
+  SMESH::long_array* GetElementsId();
 
-  SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
-    ;
+  SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
 
-  SMESH::long_array* GetNodesId()
-    ;
+  SMESH::long_array* GetNodesId();
 
-  SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
-    ;
+  SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
 
-  SMESH::EntityType GetElementGeomType( CORBA::Long id )
-    ;
+  SMESH::EntityType GetElementGeomType( CORBA::Long id );
 
-  SMESH::GeometryType GetElementShape( CORBA::Long id )
-    ;
+  SMESH::GeometryType GetElementShape( CORBA::Long id );
 
   /*!
    * Returns ID of elements for given submesh
    */
-  SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID)
-    ;
+  SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID);
 
   /*!
    * Returns ID of nodes for given submesh
    * If param all==true - returns all nodes, else -
    * returns only nodes on shapes.
    */
-  SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all)
-    ;
+  SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all);
 
   /*!
    * Returns type of elements for given submesh
    */
-  SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID)
-    ;
+  SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID);
 
   char* Dump();
 
   // Create groups of elements preventing computation of a sub-shape
   SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int         theSubShapeID,
-                                                     const char* theGroupName)
-    ;
+                                                     const char* theGroupName);
 
   // ===================================================
   // Internal methods not available through CORBA
index 385029fdfa450fe5319069c779f90242dc48bc55..5982ff089b339981cff994dd71183106d91d0dae 100644 (file)
@@ -141,7 +141,6 @@ bool getSubMeshes(::SMESH_subMesh*  theSubMesh,
 //=============================================================================
 
 CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -172,7 +171,6 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
 //=============================================================================
 
 CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -220,7 +218,6 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
 //=============================================================================
 
 SMESH::long_array* SMESH_subMesh_i::GetElementsId()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -265,7 +262,6 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsId()
 //=============================================================================
 
 SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theElemType )
-    
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -351,7 +347,6 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theEle
 //=============================================================================
   
 SMESH::long_array* SMESH_subMesh_i::GetNodesId()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
 
@@ -366,7 +361,6 @@ SMESH::long_array* SMESH_subMesh_i::GetNodesId()
 //=============================================================================
   
 SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather()
-  
 {
   Unexpect aCatch(SALOME_SalomeException);
   return _mesh_i->_this();
@@ -389,7 +383,6 @@ CORBA::Long SMESH_subMesh_i::GetId()
 //=======================================================================
 
 GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape()
-     
 {
   Unexpect aCatch(SALOME_SalomeException);
   GEOM::GEOM_Object_var aShapeObj;
@@ -428,7 +421,6 @@ SMESH::long_array* SMESH_subMesh_i::GetIDs()
  */
 //=============================================================================
 SMESH::ElementType SMESH_subMesh_i::GetElementType( const CORBA::Long id, const bool iselem )
-  
 {
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -607,7 +599,6 @@ SMESH_Invalid_subMesh_i::SMESH_Invalid_subMesh_i( PortableServer::POA_ptr thePOA
 //=======================================================================
 
 GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape()
-  
 {
   return GEOM::GEOM_Object::_duplicate( _geom );
 }
index c51d1cdb333296350d96f9db0888f10ad3f1403c..97c940b996ce1551b3cce122c72ead5e0ea2b92e 100644 (file)
@@ -53,29 +53,21 @@ public:
                    int                     localId );
   ~SMESH_subMesh_i();
 
-  CORBA::Long GetNumberOfElements()
-    ;
+  CORBA::Long GetNumberOfElements();
   
-  CORBA::Long  GetNumberOfNodes( CORBA::Boolean all )
-    ;
+  CORBA::Long  GetNumberOfNodes( CORBA::Boolean all );
   
-  SMESH::long_array* GetElementsId()
-    ;
+  SMESH::long_array* GetElementsId();
 
-  SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
-    ;
+  SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
   
-  SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
-    ;
+  SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
   
-  SMESH::long_array* GetNodesId()
-    ;
+  SMESH::long_array* GetNodesId();
   
-  SMESH::SMESH_Mesh_ptr GetFather()
-    ;
+  SMESH::SMESH_Mesh_ptr GetFather();
   
-  GEOM::GEOM_Object_ptr GetSubShape()
-    ;
+  GEOM::GEOM_Object_ptr GetSubShape();
 
   CORBA::Long GetId();
 
@@ -144,8 +136,7 @@ class SMESH_I_EXPORT SMESH_Invalid_subMesh_i:
                            int                     localId,
                            GEOM::GEOM_Object_ptr   shape);
 
-  virtual GEOM::GEOM_Object_ptr GetSubShape()
-    ;
+  virtual GEOM::GEOM_Object_ptr GetSubShape();
 
  protected:
 
index 6e849f7047d7f6e2c366db70a29c4243878fa2bb..3fc573469a67dc9f35c36ff2a9f566a40494bb51 100644 (file)
@@ -43,20 +43,20 @@ class STDMESHERS_EXPORT StdMeshers_Adaptive1D : public SMESH_Hypothesis
   /*!
    * Sets minimal allowed segment length
    */
-  void SetMinSize( double minSegLen ) ;
+  void SetMinSize( double minSegLen );
   double GetMinSize() const { return myMinSize; }
 
   /*!
    * Sets maximal allowed segment length
    */
-  void SetMaxSize( double maxSegLen ) ;
+  void SetMaxSize( double maxSegLen );
   double GetMaxSize() const { return myMaxSize; }
 
   /*!
    * Sets <deflection> parameter value, 
    * i.e. a maximal allowed distance between a segment and an edge.
    */
-  void SetDeflection(double value) ;
+  void SetDeflection(double value);
   double GetDeflection() const { return myDeflection; }
   
   virtual std::ostream & SaveTo(std::ostream & save);
index 38811195a57e426520008ae8caf06ef52fa3665f..f6c700c487e8a4229bb68efee1338e4efa68efff 100644 (file)
@@ -42,7 +42,7 @@ public:
   StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen);
   virtual ~StdMeshers_Arithmetic1D();
 
-  void SetLength(double length, bool isStartLength) ;
+  void SetLength(double length, bool isStartLength);
 
   double GetLength(bool isStartLength) const;
 
index 03a5a057059a33b7a01428e502fa27fa53923ddc..b9964faef8f995cdd834921c819fa4f5757ad386 100644 (file)
@@ -84,7 +84,6 @@ const double theCoarseConst = 0.5;
 const double theFineConst   = 4.5;
 
 void StdMeshers_AutomaticLength::SetFineness(double theFineness)
-  
 {
   if ( theFineness < 0.0 || theFineness > 1.0 )
     throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]"));
@@ -239,7 +238,6 @@ namespace {
 
 double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
                                              const double      theEdgeLength)
-  
 {
   if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
 
@@ -261,7 +259,6 @@ double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
 
 double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh*   theMesh,
                                              const TopoDS_Shape& anEdge)
-  
 {
   if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
 
index 578617392b942f65bfeadbe7725feab23b6b9c54..6aec22d49c48728347a08ccf754bfb04d1b5a74d 100644 (file)
@@ -55,14 +55,12 @@ public:
   /*!
    * \brief Computes segment for a given edge
    */
-  double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge)
-    ;
+  double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge);
 
   /*!
    * \brief Computes segment length for an edge of given length
    */
-  double GetLength(const SMESH_Mesh* aMesh, const double edgeLength)
-    ;
+  double GetLength(const SMESH_Mesh* aMesh, const double edgeLength);
 
   /*!
    * \brief Set Fineness
@@ -74,8 +72,7 @@ public:
    * The "Initial Number of Elements on the Shortest Edge" (S0)
    * is divided by (0.5 + 4.5 x theFineness)
    */
-  void SetFineness(double theFineness)
-    ;
+  void SetFineness(double theFineness);
 
   /*!
    * \brief Return mesh Fineness
index 4693b38d5c2f3a479161e593198a46d277087f58..6b3e24ed40333b95b7fe6402b071c38486e5595d 100644 (file)
@@ -133,7 +133,6 @@ namespace
   void checkGridSpacing(std::vector<std::string>& spaceFunctions,
                         std::vector<double>&      internalPoints,
                         const std::string&        axis)
-    
   {
     if ( spaceFunctions.empty() )
       throw SALOME_Exception(SMESH_Comment("Empty space function for ") << axis );
@@ -170,7 +169,6 @@ namespace
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int axis)
-  
 {
   checkAxis( axis );
 
@@ -198,7 +196,6 @@ void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int
 void StdMeshers_CartesianParameters3D::SetGridSpacing(std::vector<string>& xSpaceFuns,
                                                       std::vector<double>& xInternalPoints,
                                                       const int            axis)
-  
 {
   checkAxis( axis );
 
@@ -252,7 +249,6 @@ bool StdMeshers_CartesianParameters3D::GetFixedPoint(double p[3]) const
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
-  
 {
   if ( threshold <= 1.0 )
     throw SALOME_Exception(LOCALIZED("threshold must be > 1.0"));
@@ -272,7 +268,6 @@ void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
 void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>& spaceFunctions,
                                                       std::vector<double>&      internalPoints,
                                                       const int                 axis) const
-  
 {
   if ( !IsGridBySpacing(axis) )
     throw SALOME_Exception(LOCALIZED("The grid is defined by coordinates and not by spacing"));
@@ -286,7 +281,6 @@ void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>&
 //=======================================================================
 
 bool StdMeshers_CartesianParameters3D::IsGridBySpacing(const int axis) const
-  
 {
   checkAxis(axis);
   return !_spaceFunctions[axis].empty();
@@ -305,7 +299,6 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double    x0,
                                                           vector<double>& coords,
                                                           const string&   axis,
                                                           const double*   xForced )
-  
 {
   checkGridSpacing( theSpaceFuns, thePoints, axis );
 
@@ -404,7 +397,6 @@ void StdMeshers_CartesianParameters3D::GetCoordinates(std::vector<double>& xNode
                                                       std::vector<double>& yNodes,
                                                       std::vector<double>& zNodes,
                                                       const Bnd_Box&       bndBox) const
-  
 {
   double x0,y0,z0, x1,y1,z1;
   if ( IsGridBySpacing(0) || IsGridBySpacing(1) || IsGridBySpacing(2))
@@ -655,7 +647,6 @@ ComputeOptimalAxesDirs(const TopoDS_Shape& shape,
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
-  
 {
   gp_Vec x( the9DirComps[0],
             the9DirComps[1],
@@ -697,7 +688,6 @@ void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
 //=======================================================================
 
 void StdMeshers_CartesianParameters3D::GetGrid(std::vector<double>& coords, int axis) const
-  
 {
   if ( IsGridBySpacing(axis) )
     throw SALOME_Exception(LOCALIZED("The grid is defined by spacing and not by coordinates"));
index 3b48609dc89929c8810c06547658d14e67c125c3..466d9598498355d383c9dffb6e8fd0438232ad0a 100644 (file)
@@ -54,11 +54,11 @@ public:
   /*!
    * Sets coordinates of node positions along an axis (countered from 0)
    */
-  void SetGrid(std::vector<double>& xNodes, int axis) ;
+  void SetGrid(std::vector<double>& xNodes, int axis);
   /*!
    * Return coordinates of node positions along the three axes
    */
-  void GetGrid(std::vector<double>& xNodes, int axis) const ;
+  void GetGrid(std::vector<double>& xNodes, int axis) const;
 
   /*!
    * \brief Set grid spacing along the three axes
@@ -70,13 +70,13 @@ public:
    */
   void SetGridSpacing(std::vector<std::string>& spaceFunctions,
                       std::vector<double>&      internalPoints,
-                      const int                 axis) ;
+                      const int                 axis);
 
   void GetGridSpacing(std::vector<std::string>& spaceFunctions,
                       std::vector<double>&      internalPoints,
-                      const int                 axis) const ;
+                      const int                 axis) const;
 
-  bool IsGridBySpacing(const int axis) const ;
+  bool IsGridBySpacing(const int axis) const;
 
   /*!
    * Set/unset a fixed point, at which a node will be created provided that grid
@@ -99,7 +99,7 @@ public:
                                  std::vector<double>&      points,
                                  std::vector<double>&      coords,
                                  const std::string&        axis,
-                                 const double*             xForced=0) ;
+                                 const double*             xForced=0);
   /*!
    * Return coordinates of node positions along the three axes.
    * If the grid is defined by spacing functions, the coordinates are computed
@@ -107,12 +107,12 @@ public:
   void GetCoordinates(std::vector<double>& xNodes,
                       std::vector<double>& yNodes,
                       std::vector<double>& zNodes,
-                      const Bnd_Box&       bndBox) const ;
+                      const Bnd_Box&       bndBox) const;
 
   /*!
    * \brief Set custom direction of axes
    */
-  void SetAxisDirs(const double* the9DirComps) ;
+  void SetAxisDirs(const double* the9DirComps);
   const double* GetAxisDirs() const { return _axisDirs; }
   /*!
    * \brief Returns axes at which number of hexahedra is maximal
@@ -125,7 +125,7 @@ public:
    * hexahedron by geometry boundary is considered small and is removed if
    * it's size is \athreshold times less than the size of the initial hexahedron.
    */
-  void SetSizeThreshold(const double threshold) ;
+  void SetSizeThreshold(const double threshold);
   /*!
    * \brief Return size threshold
    */
index f1e3f9958061758d82e3070179b282a3c4b2588d..2497a4e70ad98a9f4bd84644b0f15a0d44facc12 100644 (file)
@@ -38,7 +38,7 @@ class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
   StdMeshers_Deflection1D(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_Deflection1D();
 
-  void SetDeflection(double value) ;
+  void SetDeflection(double value);
 
   double GetDeflection() const;
   
index 449988c8447471a1b9b9c858ff49a8a16d621cbb..881e07ae367d1128bae60d237831127d95c8e655 100644 (file)
@@ -61,7 +61,6 @@ StdMeshers_FixedPoints1D::~StdMeshers_FixedPoints1D()
 //=============================================================================
 
 void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
-  
 {
   _params = listParams;
   NotifySubMeshesHypothesisModification();
@@ -74,7 +73,6 @@ void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
 //=============================================================================
 
 void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg) 
-  
 {
   _nbsegs = listNbSeg;
   NotifySubMeshesHypothesisModification();
index d350e4dac9b71d21bd399262eddf44f84b6d90cd..431ef1e9e47c1fc2dd27de05e678b608524ec579 100644 (file)
@@ -41,11 +41,9 @@ public:
   StdMeshers_FixedPoints1D(int hypId, SMESH_Gen* gen);
   virtual ~StdMeshers_FixedPoints1D();
 
-  void SetPoints(const std::vector<double>& listParams)
-    ;
+  void SetPoints(const std::vector<double>& listParams);
 
-  void SetNbSegments(const std::vector<int>& listNbSeg) 
-    ;
+  void SetNbSegments(const std::vector<int>& listNbSeg) ;
 
   const std::vector<double>& GetPoints() const { return _params; }
 
index fc0da883e8c6ec1495f6d4b1fb96c98ae1755452..1e3d86ac10fa5eebab103fb9ab8f8c9e6a5cfafa 100644 (file)
@@ -37,8 +37,8 @@ class STDMESHERS_EXPORT StdMeshers_Geometric1D: public StdMeshers_Reversible1D
 public:
   StdMeshers_Geometric1D(int hypId, SMESH_Gen* gen);
 
-  void SetStartLength(double length) ;
-  void SetCommonRatio(double factor) ;
+  void SetStartLength(double length);
+  void SetCommonRatio(double factor);
 
   double GetStartLength() const;
   double GetCommonRatio() const;
index 1ac12309d06b063ebbdf8f580bfa42bf72229aa3..1a51e9919620e5a37a1d189194908f9cfbd2944d 100644 (file)
@@ -59,8 +59,7 @@ public:
    * \brief Sets  1D hypothesis specifying distribution of layers
     * \param hyp1D - 1D hypothesis
    */
-  void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
-    ;
+  void SetLayerDistribution(SMESH_Hypothesis* hyp1D);
 
   /*!
    * \brief Returns 1D hypothesis specifying distribution of layers
index b32c22822b7e1e227529ee1b39fdcac432e04ff2..70b04d10829a686cec6b88d3735af47a5a6d8669 100644 (file)
@@ -77,7 +77,7 @@ StdMeshers_LocalLength::~StdMeshers_LocalLength()
  */
 //=============================================================================
 
-void StdMeshers_LocalLength::SetLength(double length) 
+void StdMeshers_LocalLength::SetLength(double length)
 {
   double oldLength = _length;
   if (length <= 0)
@@ -104,7 +104,7 @@ double StdMeshers_LocalLength::GetLength() const
  *  
  */
 //=============================================================================
-void StdMeshers_LocalLength::SetPrecision (double thePrecision) 
+void StdMeshers_LocalLength::SetPrecision (double thePrecision)
 {
   double oldPrecision = _precision;
   if (_precision < 0)
index 4805dfe23696506ee0bc3b3310775513741fbc5e..55140e47ca571a74e0b29e4fee18446b411be738 100644 (file)
@@ -40,8 +40,8 @@ class STDMESHERS_EXPORT StdMeshers_LocalLength: public SMESH_Hypothesis
   StdMeshers_LocalLength(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_LocalLength();
 
-  void SetLength(double length) ;
-  void SetPrecision(double precision) ;
+  void SetLength(double length);
+  void SetPrecision(double precision);
 
   double GetLength() const;
   double GetPrecision() const;
index f56cbb8e448226ad1e50355974faf3f1e4cb1759..fca6c2fa50a3cefd7245f748f131856ea1934e9f 100644 (file)
@@ -68,7 +68,7 @@ public:
                   std::vector< const SMDS_MeshNode*>& mefistoToDS,
                   double scalex, double               scaley);
 
-  void ComputeScaleOnFace(SMESH_Mesh& /*aMesh*/,
+  void ComputeScaleOnFace(SMESH_Mesh& aMesh,
                           const TopoDS_Face& aFace,
                           double& scalex,
                           double& scaley);
index 068caceef3144aca33d927bcf9e45c429a15de1b..ba345adafa01efc1d7fea84bf12c1fcae51478db 100644 (file)
@@ -35,7 +35,7 @@ class STDMESHERS_EXPORT StdMeshers_MaxLength: public SMESH_Hypothesis
   StdMeshers_MaxLength(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_MaxLength();
 
-  void SetLength(double length) ;
+  void SetLength(double length);
   double GetLength() const;
 
   bool HavePreestimatedLength() const  { return _preestimated > 0.; }
index 49f205cc88cbb58cf4a352600d852e5b26d9924a..de129efe10949c2274955dfc74156a74c1267a16 100644 (file)
@@ -42,8 +42,8 @@ public:
 
   virtual std::ostream & SaveTo(std::ostream & save);
   virtual std::istream & LoadFrom(std::istream & load);
-  friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & /*hyp*/);
-  friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & /*hyp*/);
+  friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & hyp);
+  friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & hyp);
 
   /*!
    * \brief Initialize my parameter values by the mesh built on the geometry
index 1e96af79b55d5e51a4a5ae5a19f1c1172ea68b8c..5b26622bc1f975185d321177a091c19581d9795b 100644 (file)
@@ -54,7 +54,7 @@ public:
   virtual ~StdMeshers_NumberOfLayers();
 
   // Sets <number of segments> parameter value
-  void SetNumberOfLayers(int numberOfLayers) ;
+  void SetNumberOfLayers(int numberOfLayers);
 
   // Returns <number of layers> parameter value
   int GetNumberOfLayers() const;
index e2e77d36ea7e6b16a86a6c4f556ae3ff3794edb1..1dfa663e70ffba5730aa3ae76dac2cf0539d45e5 100644 (file)
@@ -87,7 +87,6 @@ StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
 //=============================================================================
 const vector<double>&
 StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
-  
 {
   if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
     _distr.resize( 0 );
@@ -98,7 +97,6 @@ const vector<double>&
 StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
                                                    int nbSeg,
                                                    int conv )
-  
 {
   if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
     _distr.resize( 0 );
@@ -112,7 +110,6 @@ StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
 //=============================================================================
 
 void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
-
 {
   int oldNumberOfSegments = _numberOfSegments;
   if (segmentsNumber <= 0)
@@ -141,7 +138,6 @@ int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
-  
 {
   if (typ < DT_Regular || typ > DT_ExprFunc)
     throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
@@ -171,7 +167,6 @@ StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
-  
 {
   if (scaleFactor < PRECISION)
     throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
@@ -197,7 +192,6 @@ void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
 //================================================================================
 
 double StdMeshers_NumberOfSegments::GetScaleFactor() const
-  
 {
   if (_distrType != DT_Scale)
     throw SALOME_Exception(LOCALIZED("not a scale distribution"));
@@ -211,7 +205,6 @@ double StdMeshers_NumberOfSegments::GetScaleFactor() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
-  
 {
   if (_distrType != DT_TabFunc)
     _distrType = DT_TabFunc;
@@ -276,7 +269,6 @@ void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
 //================================================================================
 
 const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
-  
 {
   if (_distrType != DT_TabFunc)
     throw SALOME_Exception(LOCALIZED("not a table function distribution"));
@@ -380,7 +372,6 @@ bool process( const TCollection_AsciiString& str, int convMode,
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
-  
 {
   if (_distrType != DT_ExprFunc)
     _distrType = DT_ExprFunc;
@@ -402,7 +393,6 @@ void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
 std::string
 StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
                                                       const int          convMode)
-    
 {
   // remove white spaces
   TCollection_AsciiString str((Standard_CString)expr.c_str());
@@ -442,7 +432,6 @@ StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
 //================================================================================
 
 const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
-  
 {
   if (_distrType != DT_ExprFunc)
     throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
@@ -456,7 +445,6 @@ const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
-  
 {
 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
@@ -475,7 +463,6 @@ void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
 //================================================================================
 
 int StdMeshers_NumberOfSegments::ConversionMode() const
-  
 {
 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
index 2d797105846ed47eb425da1891c4d454651f52ca..c726488ea083c1f2cde2a7b1080074dfcf4c3e01 100644 (file)
@@ -48,15 +48,14 @@ public:
   virtual ~StdMeshers_NumberOfSegments();
 
   // Builds point distribution according to passed function
-  const std::vector<double>& BuildDistributionExpr( const char*, int, int ) ;
-  const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) ;
+  const std::vector<double>& BuildDistributionExpr( const char*, int, int );
+  const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int );
 
   /*!
    * \brief Set the number of segments
     * \param segmentsNumber - must be greater than zero
    */
-  void SetNumberOfSegments(int segmentsNumber)
-    ;
+  void SetNumberOfSegments(int segmentsNumber);
 
   /*!
    * \brief Get the number of segments
@@ -77,8 +76,7 @@ public:
   /*!
    * \brief Set distribution type
    */
-  void SetDistrType(DistrType typ)
-    ;
+  void SetDistrType(DistrType typ);
 
   /*!
    * \brief Get distribution type
@@ -92,16 +90,14 @@ public:
    * Throws SALOME_Exception if distribution type is not DT_Scale,
    * or scaleFactor is not a positive value different from 1
    */
-  virtual void SetScaleFactor(double scaleFactor)
-    ;
+  virtual void SetScaleFactor(double scaleFactor);
 
   /*!
    * \brief Get scale factor for scale distribution
    * 
    * Throws SALOME_Exception if distribution type is not DT_Scale
    */
-  double GetScaleFactor() const
-    ;
+  double GetScaleFactor() const;
 
   /*!
    * \brief Set table function for distribution DT_TabFunc
@@ -112,16 +108,14 @@ public:
    * 
    * Throws SALOME_Exception if distribution type is not DT_TabFunc
    */
-  void SetTableFunction(const std::vector<double>& table)
-    ;
+  void SetTableFunction(const std::vector<double>& table);
 
   /*!
    * \brief Get table function for distribution DT_TabFunc
    * 
    * Throws SALOME_Exception if distribution type is not DT_TabFunc
    */
-  const std::vector<double>& GetTableFunction() const
-    ;
+  const std::vector<double>& GetTableFunction() const;
 
   /*!
    * \brief Set expression function for distribution DT_ExprFunc
@@ -130,16 +124,14 @@ public:
    * 
    * Throws SALOME_Exception if distribution type is not DT_ExprFunc
    */
-  void SetExpressionFunction( const char* expr)
-    ;
+  void SetExpressionFunction( const char* expr);
 
   /*!
    * \brief Get expression function for distribution DT_ExprFunc
    * 
    * Throws SALOME_Exception if distribution type is not DT_ExprFunc
    */
-  const char* GetExpressionFunction() const
-    ;
+  const char* GetExpressionFunction() const;
 
   /*!
    * \brief Checks validity of  the expression of the function f(t), e.g. "sin(t)".
@@ -147,8 +139,7 @@ public:
    *  \param convMode - 0 for "Exponent mode", 1 for "Cut negative mode"
    */
   static std::string CheckExpressionFunction( const std::string& expr,
-                                              const int          convMode)
-    ;
+                                              const int          convMode);
 
   /*!
    * \brief Set conversion mode. When it is 0, it means "exponent mode":
@@ -159,16 +150,14 @@ public:
    * 
    * Throws SALOME_Exception if distribution type is not functional
    */
-  void SetConversionMode( int conv )
-    ;
+  void SetConversionMode( int conv );
 
   /*!
    * \brief Returns conversion mode
    * 
    * Throws SALOME_Exception if distribution type is not functional
    */
-  int ConversionMode() const
-    ;
+  int ConversionMode() const;
 
   /*!
    * \brief Initialize number of segments by the mesh built on the geometry
index f2d47e1ec75dd83b1263818c8a9ae449795868b3..d2486b56d624f78d54c60ea9830d2610d7c76fe6 100644 (file)
@@ -34,8 +34,8 @@ class STDMESHERS_EXPORT StdMeshers_PolygonPerFace_2D: public SMESH_2D_Algo
  public:
   StdMeshers_PolygonPerFace_2D(int hypId, SMESH_Gen* gen);
 
-  virtual bool CheckHypothesis(SMESH_Mesh&                          /*aMesh*/,
-                               const TopoDS_Shape&                  /*aShape*/,
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
                                SMESH_Hypothesis::Hypothesis_Status& aStatus);
 
   virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
index b821c057a016b8d40ec790e6cadf1e9c3f46e7aa..d910bdd27343e228d397c3f92ca9c2e52efec89d 100644 (file)
@@ -482,8 +482,8 @@ public:
   StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen);
   virtual ~StdMeshers_Prism_3D();
 
-  virtual bool CheckHypothesis(SMESH_Mesh&                          /*aMesh*/,
-                               const TopoDS_Shape&                  /*aShape*/,
+  virtual bool CheckHypothesis(SMESH_Mesh&                          aMesh,
+                               const TopoDS_Shape&                  aShape,
                                SMESH_Hypothesis::Hypothesis_Status& aStatus);
 
   virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
index 09053b505bf04c0f87ee75772c37fc401806a629..c1d5a4999667c087a22e9a23cec912c13f121a7e 100644 (file)
@@ -56,8 +56,7 @@ public:
   /*!
    * Sets source <edge> to take a mesh pattern from
    */
-  void SetSourceEdge(const TopoDS_Shape& edge)
-    ;
+  void SetSourceEdge(const TopoDS_Shape& edge);
 
   /*!
    * Returns the source edge or a group containing edges
@@ -85,8 +84,7 @@ public:
    * This parameter is optional
    */
   void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
-                            const TopoDS_Shape& targetVertex)
-    ;
+                            const TopoDS_Shape& targetVertex);
 
   /*!
    * Returns the vertex associated with the target vertex.
index b2b1e86eee1ca487d71e0774a7f3fedc9052b18f..d3334e295ad367f9ed0f496078f59a8e03c885d1 100644 (file)
@@ -99,7 +99,7 @@ void StdMeshers_ProjectionSource2D::SetSourceFace(const TopoDS_Shape& Face)
 void StdMeshers_ProjectionSource2D::SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
                                                          const TopoDS_Shape& sourceVertex2,
                                                          const TopoDS_Shape& targetVertex1,
-                                                         const TopoDS_Shape& targetVertex2) 
+                                                         const TopoDS_Shape& targetVertex2)
 {
   if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
        sourceVertex2.IsNull() != targetVertex2.IsNull() )
index 4d3674e3fb96145ae038e7615846470bb7d65782..ae8bd395e45d19b0c3f5eaad787ccee89637a341 100644 (file)
@@ -56,8 +56,7 @@ public:
   /*!
    * Sets a source <face> to take a mesh pattern from
    */
-  void SetSourceFace(const TopoDS_Shape& face)
-    ;
+  void SetSourceFace(const TopoDS_Shape& face);
 
   /*!
    * Returns the source face or a group containing faces
@@ -88,22 +87,21 @@ public:
   void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
                             const TopoDS_Shape& sourceVertex2,
                             const TopoDS_Shape& targetVertex1,
-                            const TopoDS_Shape& targetVertex2)
-    ;
+                            const TopoDS_Shape& targetVertex2);
 
   /*!
    * Returns the <i>-th source vertex associated with the <i>-th target vertex.
    * Result may be nil if association not set.
    * Valid indices are 1 and 2
    */
-  TopoDS_Vertex GetSourceVertex(int i) const ;
+  TopoDS_Vertex GetSourceVertex(int i) const;
 
   /*!
    * Returns the <i>-th target vertex associated with the <i>-th source vertex.
    * Result may be nil if association not set.
    * Valid indices are 1 and 2
    */
-  TopoDS_Vertex GetTargetVertex(int i) const ;
+  TopoDS_Vertex GetTargetVertex(int i) const;
 
   /*!
    * \brief Test if vertex association defined
index 9a4264b8bfcd6af53852d25c12deeb1b2ce724fa..799a0ec49d673625581a02ce5280b902c34bc7e3 100644 (file)
@@ -56,8 +56,7 @@ public:
   /*!
    * Sets a source <shape> to take a mesh pattern from
    */
-  void SetSource3DShape(const TopoDS_Shape& shape)
-    ;
+  void SetSource3DShape(const TopoDS_Shape& shape);
 
   /*!
    * Returns the source shape
@@ -82,20 +81,19 @@ public:
   void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
                             const TopoDS_Shape& sourceVertex2,
                             const TopoDS_Shape& targetVertex1,
-                            const TopoDS_Shape& targetVertex2)
-    ;
+                            const TopoDS_Shape& targetVertex2);
 
   /*!
    * Returns the <i>-th source vertex associated with the <i>-th target vertex.
    * Result may be nil if association not set.
    */
-  TopoDS_Vertex GetSourceVertex(int i) const ;
+  TopoDS_Vertex GetSourceVertex(int i) const;
 
   /*!
    * Returns the <i>-th target vertex associated with the <i>-th source vertex.
    * Result may be nil if association not set.
    */
-  TopoDS_Vertex GetTargetVertex(int i) const ;
+  TopoDS_Vertex GetTargetVertex(int i) const;
 
   /*!
    * \brief Test if vertex association defined
index c120323f880c23f54c6ef0bc53ec77aa6af192f7..caec612922820b29a027d2a76452e0baeb14b10e 100644 (file)
@@ -174,8 +174,8 @@ class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
 
   bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
 
-  void splitQuadFace(SMESHDS_Mesh *       /*theMeshDS*/,
-                     const int            /*theFaceID*/,
+  void splitQuadFace(SMESHDS_Mesh *       theMeshDS,
+                     const int            theFaceID,
                      const SMDS_MeshNode* theNode1,
                      const SMDS_MeshNode* theNode2,
                      const SMDS_MeshNode* theNode3,
index 7e07378508d6403530392dd2391fc5bd76c7c6b7..60f00dcc7eda57e11134d20edfb8d01539cbbfd5 100644 (file)
@@ -43,7 +43,7 @@ class STDMESHERS_EXPORT StdMeshers_SegmentLengthAroundVertex:public SMESH_Hypoth
   StdMeshers_SegmentLengthAroundVertex(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_SegmentLengthAroundVertex();
 
-  void SetLength(double length) ;
+  void SetLength(double length);
 
   double GetLength() const;
 
index a40540d8eed63bdcceeaa48408ca390a109109a0..d07d1e17d3dc23893e827ba6b56e38db7eb60eaa 100644 (file)
@@ -41,7 +41,7 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength: public StdMeshers_Reversible1
   StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen);
   virtual ~ StdMeshers_StartEndLength();
 
-  void SetLength(double length, bool isStartLength) ;
+  void SetLength(double length, bool isStartLength);
 
   double GetLength(bool isStartLength) const;
 
index 82f0f5fbeb328de1ae2feea13379f829d0bfafbc..d761b9855a3424fe54241d924cc9f189a0c5b8e0 100644 (file)
@@ -440,7 +440,7 @@ namespace VISCOUS_3D
     std::string DumpFlags() const; // debug
 
     void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper );
-    bool SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
+    bool SetNewLength2d( Handle(Geom_Surface)& surface,
                          const TopoDS_Face&    F,
                          _EdgesOnShape&        eos,
                          SMESH_MesherHelper&   helper );
@@ -451,7 +451,7 @@ namespace VISCOUS_3D
     void Block( _SolidData& data );
     void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false );
     void ChooseSmooFunction(const set< TGeomID >& concaveVertices,
-                            const TNode2Edge&     /*n2eMap*/);
+                            const TNode2Edge&     n2eMap);
     void SmoothPos( const vector< double >& segLen, const double tol );
     int  GetSmoothedPos( const double tol );
     int  Smooth(const int step, const bool isConcaveFace, bool findBest);
@@ -937,7 +937,7 @@ namespace VISCOUS_3D
                          bool                 shiftInside=false);
     bool getFaceNormalAtSingularity(const gp_XY&        uv,
                                     const TopoDS_Face&  face,
-                                    SMESH_MesherHelper& /*helper*/,
+                                    SMESH_MesherHelper& helper,
                                     gp_Dir&             normal );
     gp_XYZ getWeigthedNormal( const _LayerEdge*                edge );
     gp_XYZ getNormalByOffset( _LayerEdge*                      edge,
@@ -975,15 +975,15 @@ namespace VISCOUS_3D
                                                 SMESH_MesherHelper& helper );
     void limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper );
     void limitMaxLenByCurvature( _LayerEdge* e1, _LayerEdge* e2,
-                                 _EdgesOnShape& /*eos1*/, _EdgesOnShape& /*eos2*/,
-                                 const bool /*isSmoothable*/ );
-    bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double /*stepSize*/ );
+                                 _EdgesOnShape& eos1, _EdgesOnShape& eos2,
+                                 const bool isSmoothable );
+    bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double stepSize );
     bool updateNormalsOfConvexFaces( _SolidData&         data,
                                      SMESH_MesherHelper& helper,
                                      int                 stepNb );
     void updateNormalsOfC1Vertices( _SolidData& data );
     bool updateNormalsOfSmoothed( _SolidData&         data,
-                                  SMESH_MesherHelper& /*helper*/,
+                                  SMESH_MesherHelper& helper,
                                   const int           nbSteps,
                                   const double        stepSize );
     bool isNewNormalOk( _SolidData&   data,
@@ -993,7 +993,7 @@ namespace VISCOUS_3D
     bool shrink(_SolidData& data);
     bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos,
                               SMESH_MesherHelper& helper,
-                              const SMESHDS_SubMesh* /*faceSubMesh*/ );
+                              const SMESHDS_SubMesh* faceSubMesh );
     void restoreNoShrink( _LayerEdge& edge ) const;
     void fixBadFaces(const TopoDS_Face&          F,
                      SMESH_MesherHelper&         helper,
@@ -1091,10 +1091,10 @@ namespace VISCOUS_3D
                              Handle(ShapeAnalysis_Surface)& surface,
                              const TopoDS_Face&             F,
                              SMESH_MesherHelper&            helper);
-    bool smoothComplexEdge( _SolidData&                    /*data*/,
+    bool smoothComplexEdge( _SolidData&                     data,
                             Handle(ShapeAnalysis_Surface)& surface,
                             const TopoDS_Face&             F,
-                            SMESH_MesherHelper&            /*helper*/);
+                            SMESH_MesherHelper&            helper);
     gp_XYZ getNormalNormal( const gp_XYZ & normal,
                             const gp_XYZ&  edgeDir);
     _LayerEdge* getLEdgeOnV( bool is2nd )
index dfb2bdc308f03cafd81585d0c15a1265164c0799..be68715761401b8c061fb70aac276c08d480ca04 100644 (file)
@@ -106,7 +106,7 @@ public:
     * \param theShape - the geometry of interest
     * \retval bool - true if parameter values have been successfully defined
    */
-  virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/);
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
 
   /*!
    * \brief Initialize my parameter values by default parameters.
index 0e9ca988075efcc1941d6d31829a2c4fbbb81fe6..9d7262163b4744fc71b3db1295b50715bedca82e 100644 (file)
@@ -62,13 +62,13 @@ public:
    *
    * Just return false as this hypothesis does not have parameters values
    */
-  virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/);
+  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
 
   /*!
    * \brief Initialize my parameter values by default parameters.
    *  \retval bool - true if parameter values have been successfully defined
    */
-  virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* theMesh=0)
+  virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* /*theMesh*/=0)
   { return false; }
 
   static const char* GetHypType() { return "ViscousLayers2D"; }
index b9834b6a6fea095015d2e7ed2b21b2b788ce0cb3..59febb6c6690aa1145e7ac4ac35e249dc0cb9f86 100644 (file)
@@ -63,7 +63,7 @@ protected:
   virtual void     onReject();
   virtual void     valueChanged( QWidget* );
 
-  bool             initVariableName(SMESH::SMESH_Hypothesis_var /*theHyp*/, StdParam& theParams, const char* theMethod) const;
+  bool             initVariableName(SMESH::SMESH_Hypothesis_var theHyp, StdParam& theParams, const char* theMethod) const;
   QWidget*         makeReverseEdgesWdg( SMESH::long_array_var edgeIDs,
                                         CORBA::String_var     shapeEntry) const;
   void             removeOldGroup(const char*        oldName,
index 1a5e88d3545389591401fc998e5cb242841f36bd..0a295715049767ac545e58b98a7eadc7ada9391d 100644 (file)
@@ -82,7 +82,7 @@ public:
                                    std::vector< int >         & subIDArray );
 
  protected:
-  virtual std::string getMethodOfParameter(const int paramIndex, int /*nbVars*/) const;
+  virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
 };
 
 #endif
index c3d8c21e0f450d2f45fe6057b555f235eaaf53e6..8b264fe3dfe89b3519362ca60861360f292c6fb4 100644 (file)
@@ -56,15 +56,15 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
    * it's size is \athreshold times less than the size of the initial hexahedron. 
    * threshold must be > 1.0
    */
-  void SetSizeThreshold(CORBA::Double threshold) ;
+  void SetSizeThreshold(CORBA::Double threshold);
   CORBA::Double GetSizeThreshold();
 
   /*!
    * \brief Set node coordinates along an axis (counterd from zero)
    */
   void SetGrid(const SMESH::double_array& coords,
-               CORBA::Short               axis) ;
-  SMESH::double_array* GetGrid(CORBA::Short axis) ;
+               CORBA::Short               axis);
+  SMESH::double_array* GetGrid(CORBA::Short axis);
 
   /*!
    * \brief Set grid spacing along an axis
@@ -77,17 +77,17 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
    */
   void SetGridSpacing(const SMESH::string_array& spaceFunctions,
                       const SMESH::double_array& internalPoints,
-                      CORBA::Short               axis) ;
+                      CORBA::Short               axis);
 
   void GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
                       SMESH::double_array_out xInternalPoints,
-                      CORBA::Short            axis) ;
+                      CORBA::Short            axis);
   /*!
    * Set custom direction of axes
    */
   void SetAxesDirs(const SMESH::DirStruct& x,
                    const SMESH::DirStruct& y,
-                   const SMESH::DirStruct& z) ;
+                   const SMESH::DirStruct& z);
   void GetAxesDirs(SMESH::DirStruct& x,
                    SMESH::DirStruct& y,
                    SMESH::DirStruct& z);
@@ -139,7 +139,7 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
                               CORBA::Boolean        isOrthogonal,
                               SMESH::DirStruct&     x,
                               SMESH::DirStruct&     y,
-                              SMESH::DirStruct&     z) ;
+                              SMESH::DirStruct&     z);
   /*!
    * \brief Compute node coordinates by spacing functions
    *  \param x0 - lower coordinate
@@ -152,8 +152,7 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
                                           CORBA::Double              x1,
                                           const SMESH::string_array& spaceFuns,
                                           const SMESH::double_array& points,
-                                          const char*                axisName )
-    ;
+                                          const char*                axisName );
 
   // Get implementation
   ::StdMeshers_CartesianParameters3D* GetImpl();
index 2fc7e2b72b4c5d3570d0419b421f2a05f5a1f9dc..e7b1983a439ff2e7ed810c0c04c51eaf608bfe69 100644 (file)
@@ -54,8 +54,7 @@ public:
   virtual ~StdMeshers_Deflection1D_i();
 
   // Set deflection
-  void SetDeflection( CORBA::Double theLength )
-    ;
+  void SetDeflection( CORBA::Double theLength );
   // Get deflection
   CORBA::Double GetDeflection();
 
index 33704b9ae89ceba5a76f2c66606fa917ccec4ffd..92a8245684f9b74d9bb7436fd02e5ffca38ef270 100644 (file)
@@ -52,10 +52,8 @@ public:
   // (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 equals 1)
-  void SetPoints(const SMESH::double_array& listParams) 
-    ;
-  void SetNbSegments(const SMESH::long_array& listNbSeg) 
-    ;
+  void SetPoints(const SMESH::double_array& listParams);
+  void SetNbSegments(const SMESH::long_array& listNbSeg);
 
   // Returns list of point's parameters
   SMESH::double_array* GetPoints();
index 719c1df42ee910f47f5de08f38e538c4164186cb..225c353456b0bba51d0b96d0142c9005fa2feca7 100644 (file)
@@ -49,8 +49,8 @@ class STDMESHERS_I_EXPORT StdMeshers_Geometric1D_i:
   StdMeshers_Geometric1D_i( PortableServer::POA_ptr thePOA,
                             ::SMESH_Gen*            theGenImpl );
 
-  void SetStartLength(CORBA::Double length) ;
-  void SetCommonRatio(CORBA::Double factor) ;
+  void SetStartLength(CORBA::Double length);
+  void SetCommonRatio(CORBA::Double factor);
 
   CORBA::Double GetStartLength();
   CORBA::Double GetCommonRatio();
index 9c471cfd8b8e6ec237cd97e4ac8045effeaefe71..b98f696f39a9a139400f1eceeb41e7625d869383 100644 (file)
@@ -54,11 +54,9 @@ public:
   virtual ~StdMeshers_LocalLength_i();
 
   // Set length
-  void SetLength( CORBA::Double theLength )
-    ;
+  void SetLength( CORBA::Double theLength );
   // Set precision
-  void SetPrecision( CORBA::Double thePrecision )
-    ;
+  void SetPrecision( CORBA::Double thePrecision );
 
   // Get length
   CORBA::Double GetLength();
index 379cef763d9ea8f0adc97685b85f0de602f45a53..1a54e5d517aa9e70f8708b2f61aa0e4cc8369e80 100644 (file)
@@ -52,8 +52,7 @@ public:
   virtual ~StdMeshers_MaxElementArea_i();
 
   // Set maximum element area 
-  void SetMaxElementArea( CORBA::Double theArea )
-    ;
+  void SetMaxElementArea( CORBA::Double theArea );
   // Get maximum element area 
   CORBA::Double GetMaxElementArea();
 
index 39b66e423231f4ae2b5adf94a0bba54dd2c1a6d4..a271b8e73e983e0fe6af5b965f12b256c112ba75 100644 (file)
@@ -49,13 +49,11 @@ public:
   virtual ~StdMeshers_MaxLength_i();
 
   // Set length
-  void SetLength( CORBA::Double theLength )
-    ;
+  void SetLength( CORBA::Double theLength );
   // Set precision
 
   // Sets preestimation flag
-  void SetUsePreestimatedLength( CORBA::Boolean toUse)
-    ;
+  void SetUsePreestimatedLength( CORBA::Boolean toUse);
 
   // Get length
   CORBA::Double GetLength();
index d70ffe716f9d61ebb1db56de90cd8b616b52d944..09955fdea42ebc45e477964ba82e18d9000f64c3 100644 (file)
@@ -56,8 +56,7 @@ public:
   virtual ~StdMeshers_NumberOfLayers_i();
 
   // Sets <number of segments> parameter value
-  void SetNumberOfLayers(CORBA::Long numberOfLayers)
-    ;
+  void SetNumberOfLayers(CORBA::Long numberOfLayers);
 
   // Returns <number of layers> parameter value
   CORBA::Long GetNumberOfLayers();
index cdb3f859d46432923292db8bfc3f0ab15d82fc41..1d16872538092239afd80ae3f367531775755b99 100644 (file)
@@ -76,7 +76,6 @@ StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i()
 SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func, 
                                                                            CORBA::Long nbSeg, 
                                                                            CORBA::Long conv )
-  
 {
   ASSERT( myBaseImpl );
   try
@@ -98,7 +97,6 @@ SMESH::double_array*
 StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
                                                      CORBA::Long                nbSeg,
                                                      CORBA::Long                conv )
-  
 {
   ASSERT( myBaseImpl );
 
@@ -130,7 +128,6 @@ StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array&
 //=============================================================================
 
 void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber )
-     
 {
   ASSERT( myBaseImpl );
   try {
@@ -165,7 +162,6 @@ CORBA::Long StdMeshers_NumberOfSegments_i::GetNumberOfSegments()
 //=============================================================================
 
 void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ)
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -203,7 +199,6 @@ CORBA::Long StdMeshers_NumberOfSegments_i::GetDistrType()
 //=============================================================================
 
 void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor )
-     
 {
   ASSERT( myBaseImpl );
   try {
@@ -226,7 +221,6 @@ void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor
 //=============================================================================
 
 CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
-  
 {
   ASSERT( myBaseImpl );
   double scale;
@@ -246,7 +240,6 @@ CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
 //=============================================================================
 
 void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table)
-  
 {
   ASSERT( myBaseImpl );
   std::vector<double> tbl( table.length() );
@@ -269,7 +262,6 @@ void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array&
 //=============================================================================
 
 SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
-  
 {
   ASSERT( myBaseImpl );
   const std::vector<double>* tbl;
@@ -292,7 +284,6 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
 //=============================================================================
 
 void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -312,7 +303,6 @@ void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
 //=============================================================================
 
 char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
-  
 {
   ASSERT( myBaseImpl );
   const char* expr;
@@ -332,7 +322,6 @@ char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
 //=============================================================================
 
 void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -352,7 +341,6 @@ void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
 //=============================================================================
 
 CORBA::Long StdMeshers_NumberOfSegments_i::ConversionMode()
-  
 {
   ASSERT( myBaseImpl );
   int conv;
index 61d8b27cafca81147fb3a47a5c9275d2fef1d50d..5f00a8fb9cc328b71bf212845866b75df33e5d90 100644 (file)
@@ -54,50 +54,38 @@ public:
   virtual ~StdMeshers_NumberOfSegments_i();
 
   // Builds point distribution according to passed function
-  SMESH::double_array* BuildDistributionExpr( const char*, CORBA::Long, CORBA::Long )
-    ;
-  SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long )
-    ;
+  SMESH::double_array* BuildDistributionExpr( const char*, CORBA::Long, CORBA::Long );
+  SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long );
 
   // Set number of segments
-  void SetNumberOfSegments( CORBA::Long theSegmentsNumber )
-    ;
+  void SetNumberOfSegments( CORBA::Long theSegmentsNumber );
   // Get number of segments
   CORBA::Long GetNumberOfSegments();
 
   // Set distribution type
-  void SetDistrType(CORBA::Long typ)
-    ;
+  void SetDistrType(CORBA::Long typ);
   // Get distribution type
   CORBA::Long GetDistrType();
 
   // Set scalar factor
-  void SetScaleFactor( CORBA::Double theScaleFactor )
-    ;
+  void SetScaleFactor( CORBA::Double theScaleFactor );
   // Get scalar factor
-  CORBA::Double GetScaleFactor()
-    ;
+  CORBA::Double GetScaleFactor();
 
   // Set table function for distribution DT_TabFunc
-  void SetTableFunction(const SMESH::double_array& table)
-    ;
+  void SetTableFunction(const SMESH::double_array& table);
   // Get table function for distribution DT_TabFunc
-  SMESH::double_array* GetTableFunction()
-    ;
+  SMESH::double_array* GetTableFunction();
 
   // Set expression function for distribution DT_ExprFunc
-  void SetExpressionFunction(const char* expr)
-    ;
+  void SetExpressionFunction(const char* expr);
   // Get expression function for distribution DT_ExprFunc
-  char* GetExpressionFunction()
-    ;
+  char* GetExpressionFunction();
 
   // Set the exponent mode on/off
-  void SetConversionMode( CORBA::Long conv )
-    ;
+  void SetConversionMode( CORBA::Long conv );
   // Returns true if the exponent mode is set
-  CORBA::Long ConversionMode()
-    ;
+  CORBA::Long ConversionMode();
 
   // Get implementation
   ::StdMeshers_NumberOfSegments* GetImpl();
index 26446a49183d27b6a741242ce0caa81da9924d46..0ffd21f1abe3d6273b1de0970c60f7fd6e0e9872 100644 (file)
@@ -79,7 +79,7 @@ public:
   ::StdMeshers_RadialPrism_3D* GetImpl();
 
   // Return true if the algorithm is applicable to a shape
-  static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int /*dim*/);
+  static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int dim);
 };
 
 
index 2d6d7fa5e73e75b93136cf1b93695cb2e21a24cd..fba7197de9c5e4b34638b50dbe2651ed2f473117 100644 (file)
@@ -74,7 +74,6 @@ StdMeshers_ProjectionSource1D_i::~StdMeshers_ProjectionSource1D_i()
 //=============================================================================
 
 void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge)
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -98,7 +97,6 @@ void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge)
 
 void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
                                                            GEOM::GEOM_Object_ptr targetVertex)
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -124,7 +122,6 @@ void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr
 //=============================================================================
 
 void StdMeshers_ProjectionSource1D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
-  
 {
   ASSERT( myBaseImpl );
 
index 32ea4579901d6adc03c843f24e1df6e2ffea223f..19e426be299f51d201922246b5237a3f880dd37d 100644 (file)
@@ -59,8 +59,7 @@ public:
   /*!
    * Sets source <edge> or a group containing edges to take a mesh pattern from
    */
-  void SetSourceEdge(GEOM::GEOM_Object_ptr edge)
-    ;
+  void SetSourceEdge(GEOM::GEOM_Object_ptr edge);
 
   /*!
    * Returns the source edge or a group containing edges
@@ -70,8 +69,7 @@ public:
   /*!
    * Sets source <mesh> to take a mesh pattern from
    */
-  void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
-    ;
+  void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
 
   /*!
    * Return source mesh
@@ -83,8 +81,7 @@ public:
    * This parameter is optional
    */
   void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
-                            GEOM::GEOM_Object_ptr targetVertex)
-    ;
+                            GEOM::GEOM_Object_ptr targetVertex);
 
   /*!
    * Returns the vertex associated with the target vertex.
@@ -113,11 +110,11 @@ public:
 
   // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
   virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & /*subIDArray*/ ) const;
+                                   std::vector< int >         & subIDArray ) const;
 
   // Set new geometry instead of that returned by getObjectsDependOn()
   virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & /*subIDArray*/ );
+                                   std::vector< int >         & subIDArray );
 private:
   // keep entries because the same shape can be published several times with
   // different names and in this case a correct name can't be restored by a TopoDS_Shape
index fd0c85e231b36a83950352af9f1a6478e007bd0f..4cfe2739cd2d07d1cc2211bebed98ddbdb52606b 100644 (file)
@@ -74,7 +74,6 @@ StdMeshers_ProjectionSource2D_i::~StdMeshers_ProjectionSource2D_i()
 //=============================================================================
 
 void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face)
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -96,7 +95,6 @@ void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face)
 //=============================================================================
 
 void StdMeshers_ProjectionSource2D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
-  
 {
   ASSERT( myBaseImpl );
 
@@ -147,7 +145,6 @@ void StdMeshers_ProjectionSource2D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr
                                                            GEOM::GEOM_Object_ptr sourceVertex2,
                                                            GEOM::GEOM_Object_ptr targetVertex1,
                                                            GEOM::GEOM_Object_ptr targetVertex2)
-  
 {
   ASSERT( myBaseImpl );
   try {
index 33e4d56bf0f99c1bbe971152c5ce67618cdce8d7..7dcb90f74b4810d6bf906ce14a68e260ff17addc 100644 (file)
@@ -59,8 +59,7 @@ public:
   /*!
    * Sets a source <face> to take a mesh pattern from
    */
-  void SetSourceFace(GEOM::GEOM_Object_ptr face)
-    ;
+  void SetSourceFace(GEOM::GEOM_Object_ptr face);
 
   /*!
    * Returns the source face
@@ -70,8 +69,7 @@ public:
   /*!
    * Sets source <mesh> to take a mesh pattern from
    */
-  void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
-    ;
+  void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
 
   /*!
    * Return source mesh
@@ -86,8 +84,7 @@ public:
   void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1,
                             GEOM::GEOM_Object_ptr sourceVertex2,
                             GEOM::GEOM_Object_ptr targetVertex1,
-                            GEOM::GEOM_Object_ptr targetVertex2)
-    ;
+                            GEOM::GEOM_Object_ptr targetVertex2);
 
   /*!
    * Returns the <i>-th source vertex associated with the <i>-th target vertex.
@@ -118,11 +115,11 @@ public:
 
   // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
   virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & /*subIDArray*/ ) const;
+                                   std::vector< int >         & subIDArray ) const;
 
   // Set new geometry instead of that returned by getObjectsDependOn()
   virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & /*subIDArray*/ );
+                                   std::vector< int >         & subIDArray );
 private:
   // keep entries because the same shape can be published several times with
   // different names and in this case a correct name can't be restored by a TopoDS_Shape
index f81ef529479c55eef3ae8a42a9728a17bea6ab1b..112330e6b4340d956dcaf699bcc40b7821e833de 100644 (file)
@@ -74,7 +74,6 @@ StdMeshers_ProjectionSource3D_i::~StdMeshers_ProjectionSource3D_i()
 //=============================================================================
 
 void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr shape)
-  
 {
   ASSERT( myBaseImpl );
   try {
@@ -97,7 +96,6 @@ void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr sha
 //=============================================================================
 
 void StdMeshers_ProjectionSource3D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
-  
 {
   ASSERT( myBaseImpl );
 
@@ -148,7 +146,6 @@ void StdMeshers_ProjectionSource3D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr
                                                            GEOM::GEOM_Object_ptr sourceVertex2,
                                                            GEOM::GEOM_Object_ptr targetVertex1,
                                                            GEOM::GEOM_Object_ptr targetVertex2)
-  
 {
   ASSERT( myBaseImpl );
   try {
index 55269c4f4228ca67d1eed5083e504c25f288cdc9..4f3b3c9c5425dbeac6b221a435abb0a698723a33 100644 (file)
@@ -60,8 +60,7 @@ public:
   /*!
    * Sets a source <shape> to take a mesh pattern from
    */
-  void SetSource3DShape(GEOM::GEOM_Object_ptr shape)
-    ;
+  void SetSource3DShape(GEOM::GEOM_Object_ptr shape);
 
   /*!
    * Returns the source shape
@@ -71,8 +70,7 @@ public:
   /*!
    * Sets source <mesh> to take a mesh pattern from
    */
-  void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
-    ;
+  void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
 
   /*!
    * Return source mesh
@@ -87,8 +85,7 @@ public:
   void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1,
                             GEOM::GEOM_Object_ptr sourceVertex2,
                             GEOM::GEOM_Object_ptr targetVertex1,
-                            GEOM::GEOM_Object_ptr targetVertex2)
-    ;
+                            GEOM::GEOM_Object_ptr targetVertex2);
 
   /*!
    * Returns the <i>-th source vertex associated with the <i>-th target vertex.
@@ -119,11 +116,11 @@ public:
 
   // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
   virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & /*subIDArray*/ ) const;
+                                   std::vector< int >         & subIDArray ) const;
 
   // Set new geometry instead of that returned by getObjectsDependOn()
   virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & /*subIDArray*/ );
+                                   std::vector< int >         & subIDArray );
 
 private:
   // keep entries because the same shape can be published several times with
index abcafb0ac56b85c70037d0c51e18b1f1d782bc38..0fc97c809ff63afdbe486c3249cd3b3be216291d 100644 (file)
@@ -59,7 +59,7 @@ public:
   ::StdMeshers_Projection_3D* GetImpl();
 
   // Return true if the algorithm is applicable to a shape
-  static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int /*dim*/);
+  static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int dim);
 };
 
 // ======================================================
index a66a18b95aa348fa193ee7f188bd53f06469e7e2..3be789de4736ff340e191e52e660c596e6cefcc6 100644 (file)
@@ -51,8 +51,7 @@ public:
   virtual ~StdMeshers_SegmentLengthAroundVertex_i();
 
   // Set length
-  void SetLength( CORBA::Double theLength )
-    ;
+  void SetLength( CORBA::Double theLength );
 
   // Get length
   CORBA::Double GetLength();
index 86c4df17064d51fd54e46b56246f53bd07dc2ca6..784eebe1c9b4a57d932c2b7d81f8de95753ace7b 100644 (file)
@@ -56,14 +56,13 @@ public:
 
   // Set length
   // * OBSOLETE *. Avoid such a way of interface design
-  void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
-    ;
+  void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart );
 
   // Sets <start segment length> parameter value
-  void SetStartLength( CORBA::Double length) ;
+  void SetStartLength( CORBA::Double length);
 
   // Sets <end segment length> parameter value
-  void SetEndLength( CORBA::Double length) ;
+  void SetEndLength( CORBA::Double length);
 
   // Get length
   CORBA::Double GetLength(CORBA::Boolean theIsStart);
index fdf5289123b3542a127de83b3af284fac8de07be..eaeb970ab643cb5f4524f4a0e23eb4bca02c8ef2 100644 (file)
@@ -74,7 +74,7 @@ StdMeshers_ViscousLayers2D_i::~StdMeshers_ViscousLayers2D_i()
 //================================================================================
 
 void StdMeshers_ViscousLayers2D_i::SetEdges(const ::SMESH::long_array& edgeIDs,
-                                            CORBA::Boolean             toIgnore)  
+                                            CORBA::Boolean             toIgnore)
 {
   vector<int> ids( edgeIDs.length() );
   for ( unsigned i = 0; i < ids.size(); ++i )
@@ -93,7 +93,6 @@ void StdMeshers_ViscousLayers2D_i::SetEdges(const ::SMESH::long_array& edgeIDs,
 //================================================================================
 
 void StdMeshers_ViscousLayers2D_i::SetIgnoreEdges(const ::SMESH::long_array& edgeIDs)
-  
 {
   SMESH::TPythonDump pyDump;
   this->SetEdges( edgeIDs, true );
@@ -147,7 +146,6 @@ CORBA::Boolean StdMeshers_ViscousLayers2D_i::GetIsToIgnoreEdges()
 //================================================================================
 
 void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
-
 {
   if ( thickness < 1e-100 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
@@ -174,7 +172,6 @@ void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
 //================================================================================
 
 void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
-
 {
   if ( nb < 1 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
@@ -201,7 +198,6 @@ void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
 //================================================================================
 
 void StdMeshers_ViscousLayers2D_i::SetStretchFactor(::CORBA::Double factor)
-
 {
   if ( factor < 1 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
index 0b7c5f856b154d1dfd407d662ff9bd95cbe757c3..b7d5a2afe1a5e5ddc1680d4a83ad5fdac9fe237f 100644 (file)
@@ -47,7 +47,7 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
   // Destructor
   virtual ~StdMeshers_ViscousLayers2D_i();
 
-  void SetIgnoreEdges(const SMESH::long_array& edgeIDs) ;
+  void SetIgnoreEdges(const SMESH::long_array& edgeIDs);
   SMESH::long_array* GetIgnoreEdges();
 
   void SetEdges(const SMESH::long_array& edgeIDs, 
@@ -55,13 +55,13 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
   SMESH::long_array* GetEdges();
   CORBA::Boolean     GetIsToIgnoreEdges();
 
-  void SetTotalThickness(::CORBA::Double thickness) ;
+  void SetTotalThickness(::CORBA::Double thickness);
   ::CORBA::Double GetTotalThickness();
 
-  void SetNumberLayers(::CORBA::Short nb) ;
+  void SetNumberLayers(::CORBA::Short nb);
   ::CORBA::Short GetNumberLayers();
 
-  void SetStretchFactor(::CORBA::Double factor) ;
+  void SetStretchFactor(::CORBA::Double factor);
   ::CORBA::Double GetStretchFactor();
 
   void SetGroupName(const char* name);
@@ -82,11 +82,11 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
   // Methods for copying mesh definition to other geometry
 
   // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
-  virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+  virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
                                    std::vector< int >         & subIDArray ) const;
 
   // Set new geometry instead of that returned by getObjectsDependOn()
-  virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+  virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
                                    std::vector< int >         & subIDArray );
 };
 
index 675bd087e48938840eee8f026e0e32b1aa79d1ec..7f967dcb2d2d3c8a8fbaf627818cdbc77b68b276 100644 (file)
@@ -76,7 +76,6 @@ StdMeshers_ViscousLayers_i::~StdMeshers_ViscousLayers_i()
 
 void StdMeshers_ViscousLayers_i::SetFaces(const ::SMESH::long_array& faceIDs,
                                           CORBA::Boolean             toIgnore)
-  
 {
   vector<int> ids( faceIDs.length() );
   for ( unsigned i = 0; i < ids.size(); ++i )
@@ -135,7 +134,6 @@ CORBA::Boolean StdMeshers_ViscousLayers_i::GetIsToIgnoreFaces()
 //================================================================================
 
 void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceIDs)
-
 {
   vector<int> ids( faceIDs.length() );
   for ( unsigned i = 0; i < ids.size(); ++i )
@@ -152,7 +150,6 @@ void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceI
 //================================================================================
 
 void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness)
-
 {
   if ( thickness < 1e-100 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
@@ -179,7 +176,6 @@ void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness)
 //================================================================================
 
 void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb)
-
 {
   if ( nb < 1 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
@@ -206,7 +202,6 @@ void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb)
 //================================================================================
 
 void StdMeshers_ViscousLayers_i::SetStretchFactor(::CORBA::Double factor)
-
 {
   if ( factor < 1 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
index b5641ca21ae3808c761bf235ecebb8c220a85ae8..0b9affd4185c9a3594e464d574a41c807cbb0a99 100644 (file)
@@ -47,21 +47,21 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers_i:
   // Destructor
   virtual ~StdMeshers_ViscousLayers_i();
 
-  void SetIgnoreFaces(const ::SMESH::long_array& faceIDs) ;
+  void SetIgnoreFaces(const ::SMESH::long_array& faceIDs);
   SMESH::long_array* GetIgnoreFaces();
 
   void SetFaces(const SMESH::long_array& faceIDs,
-                CORBA::Boolean           toIgnore) ;
+                CORBA::Boolean           toIgnore);
   SMESH::long_array* GetFaces();
   CORBA::Boolean     GetIsToIgnoreFaces();
 
-  void SetTotalThickness(::CORBA::Double thickness) ;
+  void SetTotalThickness(::CORBA::Double thickness);
   ::CORBA::Double GetTotalThickness();
 
-  void SetNumberLayers(::CORBA::Short nb) ;
+  void SetNumberLayers(::CORBA::Short nb);
   ::CORBA::Short GetNumberLayers();
 
-  void SetStretchFactor(::CORBA::Double factor) ;
+  void SetStretchFactor(::CORBA::Double factor);
   ::CORBA::Double GetStretchFactor();
 
   void SetMethod( ::StdMeshers::VLExtrusionMethod how );
@@ -80,11 +80,11 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers_i:
   // Methods for copying mesh definition to other geometry
 
   // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
-  virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+  virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
                                    std::vector< int >         & subIDArray ) const;
 
   // Set new geometry instead of that returned by getObjectsDependOn()
-  virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+  virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
                                    std::vector< int >         & subIDArray );
  protected:
   virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
index f8543803dfc7cc391ec24d1b8bc20bedd5b0ae1e..c8e72fbb564ff2651cd1b314f70340ec956d8606 100644 (file)
@@ -253,7 +253,6 @@ STDMESHERS_I_EXPORT
       aCreator = new StdHypothesisCreator_i<StdMeshers_PolygonPerFace_2D_i>;
     else if (strcmp(aHypName, "PolyhedronPerSolid_3D") == 0)
       aCreator = new StdHypothesisCreator_i<StdMeshers_PolyhedronPerSolid_3D_i>;
-    //else ;
 
     return aCreator;
   }
index 2b3200d885ac0ce37e3355dde689942b698cf435..a383db29be3b6b02cefe9415ce8f48818bff2688 100644 (file)
@@ -95,7 +95,7 @@ namespace MESHCUT
 
       void creationGMtype(TYPE_MAILLE tm, std::string nomGMtype);
       void afficheMailles(TYPE_MAILLE tm);
-      void listeMaillesType(TYPE_MAILLE /*tm*/);
+      void listeMaillesType(TYPE_MAILLE tm);
       void listeMaillesTousTypes();
       void listeMaillesParGM();
       void listeMaillesGM(std::string nomGM);
@@ -120,13 +120,12 @@ namespace MESHCUT
       // std::string vrmlType(TYPE_MAILLE tm, char *renduAretes, char *renduFaces, float transparence);
       // void Maillage::creationGMtype(TYPE_MAILLE tm, std::vector<int> CON_TYPE);
       int NGLOBAL(TYPE_MAILLE typeMaille, int nlocal);
-      int NLOCAL(int nglobal, TYPE_MAILLE /*tm*/);
+      int NLOCAL(int nglobal, TYPE_MAILLE tm);
       TYPE_MAILLE TYPE(int nglobal);
       void eliminationMailles(TYPE_MAILLE typeMaille, std::vector<int> listeMaillesSuppr);
 
       // acquisitionTYPE_inputMED appelée par inputMED
-      void
-          acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int /*mdim*/);
+      void acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int mdim);
 
       // void infoChamps(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, char *maa,
       //                 char *nomChamp, med_field_type typeChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS);