Update from OCC

Makefile.in

@@ -38,6 +38,8 @@ mesh_hypo_length.png \
 mesh_hypo_segment.png \
 mesh_hypo_volume.png \
 mesh_info.png \
+advanced_mesh_info.png \
+standard_mesh_info.png \
 mesh_init.png \
 mesh_length.png \
 mesh_free_edges.png \

resources/SMESH_en.xml

@@ -67,7 +67,8 @@
      <separator pos-id=""/>
      <popup-item item-id="813" pos-id="" label-id="Delete Groups" icon-id="mesh_deleteGroups.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>
      <separator pos-id=""/>
-     <popup-item item-id="900" pos-id="" label-id="Mesh Infos" icon-id="mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>
+     <popup-item item-id="900" pos-id="" label-id="Advanced Mesh Infos" icon-id="advanced_mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>
+     <popup-item item-id="902" pos-id="" label-id="Standard Mesh Infos" icon-id="standard_mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>
 </menu-item>
 
 <!-- ************************** Control  (menubar)  ************************************ -->
@@ -163,7 +164,8 @@
    <separator pos-id=""/>
    <popup-item item-id="701" pos-id="" label-id="Compute" icon-id="mesh_compute.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
    <popup-item item-id="214" pos-id="" label-id="Update" icon-id="mesh_update.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
-   <popup-item item-id="900" pos-id="" label-id="Show Info" icon-id="mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
+   <popup-item item-id="900" pos-id="" label-id="Show Advanced Info" icon-id="advanced_mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
+   <popup-item item-id="902" pos-id="" label-id="Show Standard Info" icon-id="standard_mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
    <separator pos-id=""/>
    <popup-item item-id="801" pos-id="" label-id="Create Group" icon-id="mesh_tree_group.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
    <separator pos-id=""/>
@@ -211,7 +213,8 @@
 
 <popupmenu label-id="Popup for Viewer" context-id="" parent-id="Viewer" object-id="Mesh">
    <popup-item item-id="214" pos-id="" label-id="Update" icon-id="mesh_update.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/> 
-   <popup-item item-id="900" pos-id="" label-id="Show Info" icon-id="mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
+   <popup-item item-id="900" pos-id="" label-id="Show Advanced Info" icon-id="advanced_mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
+   <popup-item item-id="902" pos-id="" label-id="Show Standard Info" icon-id="standard_mesh_info.png" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>   
    <separator pos-id=""/>   
    <submenu label-id="Numbering" item-id="114" pos-id="">
      <popup-item item-id="9010" pos-id="" label-id="Display Nodes #" icon-id="" tooltip-id="" accel-id="" toggle-id="" execute-action=""/>
@@ -356,7 +359,8 @@
    <toolbutton-item item-id="802" pos-id="" label-id="Construct Group" icon-id="mesh_make_group.png" tooltip-id="Construct Group" accel-id="" toggle-id="" execute-action=""/>
    <toolbutton-item item-id="803" pos-id="" label-id="Edit Group" icon-id="mesh_edit_group.png" tooltip-id="Edit Group" accel-id="" toggle-id="" execute-action=""/>
    <separatorTB/>
-   <toolbutton-item item-id="900" pos-id="" label-id="Mesh Infos" icon-id="mesh_info.png" tooltip-id="Mesh Infos" accel-id="" toggle-id="" execute-action=""/>
+   <toolbutton-item item-id="900" pos-id="" label-id="Advanced Mesh Infos" icon-id="advanced_mesh_info.png" tooltip-id="Advanced Mesh Infos" accel-id="" toggle-id="" execute-action=""/>
+   <toolbutton-item item-id="902" pos-id="" label-id="Standard Mesh Infos" icon-id="standard_mesh_info.png" tooltip-id="Standard Mesh Infos" accel-id="" toggle-id="" execute-action=""/>    
 </toolbar>
 
 <toolbar label-id="Hypotheses Toolbar">

src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx

@@ -39,7 +39,7 @@
 #include "MED_Utilities.hxx"
 
 #define _EDF_NODE_IDS_
-#define _ELEMENTS_BY_DIM_
+//#define _ELEMENTS_BY_DIM_
 
 using namespace std;
 
@@ -234,9 +234,9 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 	}
 
 	double EPS = 1.0E-7;
-	anIsXDimension = (aBounds[1] - aBounds[0]) > EPS;
+	anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
-	anIsYDimension = (aBounds[3] - aBounds[2]) > EPS;
+	anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
-	anIsZDimension = (aBounds[5] - aBounds[4]) > EPS;
+	anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
 
 	aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
 	if(!aMeshDimension)

src/SMESH/Makefile.in

@@ -45,6 +45,7 @@ EXPORT_HEADERS= \
 	SMESH_3D_Algo.hxx \
 	SMESH_Group.hxx \
 	SMESH_MeshEditor.hxx \
+	SMESH_Block.hxx \
 	SMESH_Pattern.hxx
 
 EXPORT_PYSCRIPTS =
@@ -61,6 +62,7 @@ LIB_SRC = SMESH_Gen.cxx SMESH_Mesh.cxx SMESH_subMesh.cxx \
 	  SMESH_3D_Algo.cxx \
 	  SMESH_Group.cxx \
 	  SMESH_MeshEditor.cxx \
+	  SMESH_Block.cxx \
 	  SMESH_Pattern.cxx
 
 LIB_SERVER_IDL = 
@@ -73,10 +75,10 @@ BIN_SRC =
 
 # additionnal information to compile and link file
 CPPFLAGS+= $(OCC_INCLUDES) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
-           $(BOOST_CPPFLAGS)
+           -I${GEOM_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
-CXXFLAGS+= $(OCC_CXXFLAGS) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
+CXXFLAGS+= $(OCC_CXXFLAGS) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
-
+           -I${GEOM_ROOT_DIR}/include/salome
-LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -lSMESHDS -lMeshDriverDAT -lMeshDriverSTL -lMeshDriverMED -lMeshDriverUNV
+LDFLAGS+= -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome -lNMTTools -lSMESHDS -lMeshDriverDAT -lMeshDriverSTL -lMeshDriverMED -lMeshDriverUNV
 
 @CONCLUDE@
 

src/SMESH/SMESH_1D_Algo.cxx

@@ -29,6 +29,7 @@
 using namespace std;
 #include "SMESH_1D_Algo.hxx"
 #include "SMESH_Gen.hxx"
+#include "SMESH_subMesh.hxx"
 
 //=============================================================================
 /*!

src/SMESH/SMESH_2D_Algo.cxx

@@ -29,6 +29,7 @@
 using namespace std;
 #include "SMESH_2D_Algo.hxx"
 #include "SMESH_Gen.hxx"
+#include "SMESH_subMesh.hxx"
 
 #include "utilities.h"
 

src/SMESH/SMESH_3D_Algo.cxx

@@ -29,6 +29,7 @@
 using namespace std;
 #include "SMESH_3D_Algo.hxx"
 #include "SMESH_Gen.hxx"
+#include "SMESH_subMesh.hxx"
 
 #include "utilities.h"
 

src/SMESH/SMESH_Block.hxx

@@ -0,0 +1,209 @@
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+
+// File      : SMESH_Block.hxx
+// Created   : Tue Nov 30 12:42:18 2004
+// Author    : Edward AGAPOV (eap)
+
+
+#ifndef SMESH_Block_HeaderFile
+#define SMESH_Block_HeaderFile
+
+#include <Geom2d_Curve.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_Surface.hxx>
+#include <TopExp.hxx>
+#include <TopTools_IndexedMapOfOrientedShape.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Shell.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_XY.hxx>
+#include <gp_XYZ.hxx>
+#include <math_FunctionSetWithDerivatives.hxx>
+#include <math_Matrix.hxx>
+#include <math_Vector.hxx>
+
+#include <ostream>
+#include <vector>
+
+// =========================================================
+// class calculating coordinates of 3D points by normalized
+// parameters inside the block and vice versa
+// =========================================================
+
+class SMESH_Block: public math_FunctionSetWithDerivatives
+{
+ public:
+  enum TShapeID { // ids of the block sub-shapes
+    ID_NONE = 0,
+
+    ID_V000 = 1, ID_V100, ID_V010, ID_V110, ID_V001, ID_V101, ID_V011, ID_V111,
+
+    ID_Ex00, ID_Ex10, ID_Ex01, ID_Ex11,
+    ID_E0y0, ID_E1y0, ID_E0y1, ID_E1y1,
+    ID_E00z, ID_E10z, ID_E01z, ID_E11z,
+
+    ID_Fxy0, ID_Fxy1, ID_Fx0z, ID_Fx1z, ID_F0yz, ID_F1yz,
+
+    ID_Shell
+    };
+  static inline bool IsVertexID( int theShapeID )
+  { return ( theShapeID >= ID_V000 && theShapeID <= ID_V111 ); }
+
+  static inline bool IsEdgeID( int theShapeID )
+  { return ( theShapeID >= ID_Ex00 && theShapeID <= ID_E11z ); }
+
+  static inline bool IsFaceID( int theShapeID )
+  { return ( theShapeID >= ID_Fxy0 && theShapeID <= ID_F1yz ); }
+
+
+  SMESH_Block (): myNbIterations(0), mySumDist(0.) {}
+
+  bool LoadBlockShapes(const TopoDS_Shell&         theShell,
+                       const TopoDS_Vertex&        theVertex000,
+                       const TopoDS_Vertex&        theVertex001,
+//                       TopTools_IndexedMapOfShape& theShapeIDMap
+                       TopTools_IndexedMapOfOrientedShape& theShapeIDMap );
+  // add sub-shapes of theBlock to theShapeIDMap so that they get
+  // IDs acoording to enum TShapeID
+
+  static int GetShapeIDByParams ( const gp_XYZ& theParams );
+  // define an id of the block sub-shape by point parameters
+
+  bool VertexPoint( const int theVertexID, gp_XYZ& thePoint ) const {
+    if ( !IsVertexID( theVertexID ))           return false;
+    thePoint = myPnt[ theVertexID - ID_V000 ]; return true;
+  }
+  // return vertex coordinates
+
+  bool EdgePoint( const int theEdgeID, const gp_XYZ& theParams, gp_XYZ& thePoint ) const {
+    if ( !IsEdgeID( theEdgeID ))                                 return false;
+    thePoint = myEdge[ theEdgeID - ID_Ex00 ].Point( theParams ); return true;
+  }
+  // return coordinates of a point on edge
+
+  bool FacePoint( const int theFaceID, const gp_XYZ& theParams, gp_XYZ& thePoint ) const {
+    if ( !IsFaceID ( theFaceID ))                                return false;
+    thePoint = myFace[ theFaceID - ID_Fxy0 ].Point( theParams ); return true;
+  }
+  // return coordinates of a point on face
+
+  bool ShellPoint( const gp_XYZ& theParams, gp_XYZ& thePoint ) const;
+  // return coordinates of a point in shell
+
+  bool ComputeParameters (const gp_Pnt& thePoint,
+                          gp_XYZ&       theParams,
+                          const int     theShapeID = ID_Shell);
+  // compute point parameters in the block
+
+  static void GetFaceEdgesIDs (const int faceID, vector< int >& edgeVec );
+  // return edges IDs of a face in the order u0, u1, 0v, 1v
+
+  static int GetCoordIndOnEdge (const int theEdgeID)
+  { return (theEdgeID < ID_E0y0) ? 1 : (theEdgeID < ID_E00z) ? 2 : 3; }
+  // return an index of a coordinate which varies along the edge
+
+  static double* GetShapeCoef (const int theShapeID);
+  // for theShapeID( TShapeID ), returns 3 coefficients used
+  // to compute an addition of an on-theShape point to coordinates
+  // of an in-shell point. If an in-shell point has parameters (Px,Py,Pz),
+  // then the addition of a point P is computed as P*kx*ky*kz and ki is
+  // defined by the returned coef like this:
+  // ki = (coef[i] == 0) ? 1 : (coef[i] < 0) ? 1 - Pi : Pi
+
+  static bool IsForwardEdge (const TopoDS_Edge &         theEdge, 
+                             //TopTools_IndexedMapOfShape& theShapeIDMap
+                             TopTools_IndexedMapOfOrientedShape& theShapeIDMap) {
+    int v1ID = theShapeIDMap.FindIndex( TopExp::FirstVertex( theEdge ).Oriented( TopAbs_FORWARD ));
+    int v2ID = theShapeIDMap.FindIndex( TopExp::LastVertex( theEdge ).Oriented( TopAbs_FORWARD ));
+    return ( v1ID < v2ID );
+  }
+  // Return true if an in-block parameter increases along theEdge curve
+
+  static void Swap(double& a, double& b) { double tmp = a; a = b; b = tmp; }
+
+  // methods of math_FunctionSetWithDerivatives
+  Standard_Integer NbVariables() const;
+  Standard_Integer NbEquations() const;
+  Standard_Boolean Value(const math_Vector& X,math_Vector& F) ;
+  Standard_Boolean Derivatives(const math_Vector& X,math_Matrix& D) ;
+  Standard_Boolean Values(const math_Vector& X,math_Vector& F,math_Matrix& D) ;
+  Standard_Integer GetStateNumber ();
+
+  static ostream& DumpShapeID (const int theBlockShapeID, ostream& stream);
+  // DEBUG: dump an id of a block sub-shape
+
+ private:
+
+  struct TEdge {
+    int                myCoordInd;
+    double             myFirst;
+    double             myLast;
+    Handle(Geom_Curve) myC3d;
+    gp_Trsf            myTrsf;
+    double GetU( const gp_XYZ& theParams ) const;
+    gp_XYZ Point( const gp_XYZ& theParams ) const;
+  };
+
+  struct TFace {
+    // 4 edges in the order u0, u1, 0v, 1v
+    int                  myCoordInd[ 4 ];
+    double               myFirst   [ 4 ];
+    double               myLast    [ 4 ];
+    Handle(Geom2d_Curve) myC2d     [ 4 ];
+    // 4 corner points in the order 00, 10, 11, 01
+    gp_XY                myCorner  [ 4 ];
+    // surface
+    Handle(Geom_Surface) myS;
+    gp_Trsf              myTrsf;
+    gp_XY  GetUV( const gp_XYZ& theParams ) const;
+    gp_XYZ Point( const gp_XYZ& theParams ) const;
+    int GetUInd() const { return myCoordInd[ 0 ]; }
+    int GetVInd() const { return myCoordInd[ 2 ]; }
+  };
+
+  TopoDS_Shell myShell;
+  // geometry:
+  // 8 vertices
+  gp_XYZ myPnt[ 8 ];
+  // 12 edges
+  TEdge  myEdge[ 12 ];
+  // 6 faces
+  TFace  myFace[ 6 ];
+
+  // for param computation
+
+  int      myFaceIndex;
+  double   myFaceParam;
+  int      myNbIterations;
+  double   mySumDist;
+
+  gp_XYZ   myPoint; // the given point
+  gp_XYZ   myParam; // the best parameters guess
+  double   myValues[ 4 ]; // values computed at myParam
+
+  typedef pair<gp_XYZ,gp_XYZ> TxyzPair;
+  TxyzPair my3x3x3GridNodes[ 27 ];
+  bool     myGridComputed;
+};
+
+
+#endif

src/SMESH/SMESH_Gen.cxx

@@ -208,12 +208,21 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
   // mesh the rest subshapes starting from vertices
   // -----------------------------------------------
 
-  smToCompute = sm->GetFirstToCompute();
+  int i, nbSub = smMap.size();
-  while (smToCompute)
+  map<int, SMESH_subMesh*>::const_iterator itSub = smMap.begin();
+  for ( i = 0; i <= nbSub; ++i ) // loop on the whole map plus <sm>
   {
+    if ( itSub == smMap.end() )
+      smToCompute = sm;
+    else
+      smToCompute = (itSub++)->second;
+    if (smToCompute->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE) {
+      if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE)
+        ret = false;
+      continue;
+    }
     TopoDS_Shape subShape = smToCompute->GetSubShape();
-    int dim = GetShapeDim(subShape);
+    if ( subShape.ShapeType() != TopAbs_VERTEX )
-    if (dim > 0)
     {
       if ( !smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE) )
         ret = false;
@@ -229,22 +238,10 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
         smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE);
       }
     }
-    smToCompute = sm->GetFirstToCompute();
   }
 
-  if (!ret) return false;
+  MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret);
-
+  return ret;
-  // JFA for PAL6524: if there are failed sub-meshes, return Standard_False
-  const map < int, SMESH_subMesh * >&subMeshes = sm->DependsOn();
-  map < int, SMESH_subMesh * >::const_iterator itsub;
-  for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) {
-    SMESH_subMesh *smi = (*itsub).second;
-    if (smi->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE) return false;
-  }
-  if (sm->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE) return false;
-
-  MESSAGE( "VSR - SMESH_Gen::Compute() finished" );
-  return true;
 }
 
 

src/SMESH/SMESH_Hypothesis.cxx

@@ -30,6 +30,7 @@ using namespace std;
 using namespace std;
 #include "SMESH_Hypothesis.hxx"
 #include "SMESH_Gen.hxx"
+#include "SMESH_subMesh.hxx"
 #include "utilities.h"
 
 //=============================================================================

src/SMESH/SMESH_Mesh.cxx

@@ -46,11 +46,18 @@
 #include "DriverUNV_R_SMDS_Mesh.h"
 #include "DriverSTL_R_SMDS_Mesh.h"
 
+#include <BRepTools_WireExplorer.hxx>
+#include <BRep_Builder.hxx>
+#include <gp_Pnt.hxx>
+
 #include <TCollection_AsciiString.hxx>
-#include <memory>
-#include <TopTools_ListOfShape.hxx>
 #include <TopExp.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_Array1OfShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
+
+#include <memory>
+
 #include "Utils_ExceptHandlers.hxx"
 
 #ifdef _DEBUG_
@@ -254,8 +261,7 @@ SMESH_Hypothesis::Hypothesis_Status
   }
 
   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
-  if(MYDEBUG) SCRUTE( anHyp->GetName() );
+  MESSAGE( "SMESH_Mesh::AddHypothesis " << anHyp->GetName() );
-  int event;
 
   bool isGlobalHyp = IsMainShape( aSubShape );
 
@@ -272,6 +278,7 @@ SMESH_Hypothesis::Hypothesis_Status
 
   // shape 
 
+  int event;
   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
     event = SMESH_subMesh::ADD_HYP;
   else
@@ -290,10 +297,26 @@ SMESH_Hypothesis::Hypothesis_Status
       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
     if (ret2 > ret)
       ret = ret2;
+
+    // check concurent hypotheses on ansestors
+    if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
+    {
+      const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
+      map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
+      for ( ; smIt != smMap.end(); smIt++ ) {
+        if ( smIt->second->IsApplicableHypotesis( anHyp )) {
+          ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
+          if (ret2 > ret) {
+            ret = ret2;
+            break;
+          }
+        }
+      }
+    }
   }
 
-  subMesh->DumpAlgoState(true);
+  if(MYDEBUG) subMesh->DumpAlgoState(true);
-  if(MYDEBUG) SCRUTE(ret);
+  SCRUTE(ret);
   return ret;
 }
 
@@ -348,21 +371,43 @@ SMESH_Hypothesis::Hypothesis_Status
     event = SMESH_subMesh::REMOVE_ALGO;
   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
 
+  // there may appear concurrent hyps that were covered by the removed hyp
+  if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
+      subMesh->IsApplicableHypotesis( anHyp ) &&
+      subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
+    ret = SMESH_Hypothesis::HYP_CONCURENT;
+
   // subShapes
   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
       !subMesh->IsApplicableHypotesis( anHyp )) // is removed from father
-    {
+  {
-      if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
+    if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
-	event = SMESH_subMesh::REMOVE_FATHER_HYP;
+      event = SMESH_subMesh::REMOVE_FATHER_HYP;
-      else
+    else
-	event = SMESH_subMesh::REMOVE_FATHER_ALGO;
+      event = SMESH_subMesh::REMOVE_FATHER_ALGO;
-      SMESH_Hypothesis::Hypothesis_Status ret2 =
+    SMESH_Hypothesis::Hypothesis_Status ret2 =
-	subMesh->SubMeshesAlgoStateEngine(event, anHyp);
+      subMesh->SubMeshesAlgoStateEngine(event, anHyp);
-      if (ret2 > ret) // more severe
+    if (ret2 > ret) // more severe
-	ret = ret2;
+      ret = ret2;
-    }
 
-  subMesh->DumpAlgoState(true);
+    // check concurent hypotheses on ansestors
+    if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
+    {
+      const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
+      map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
+      for ( ; smIt != smMap.end(); smIt++ ) {
+        if ( smIt->second->IsApplicableHypotesis( anHyp )) {
+          ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
+          if (ret2 > ret) {
+            ret = ret2;
+            break;
+          }
+        }
+      }
+    }
+  }
+  
+  if(MYDEBUG) subMesh->DumpAlgoState(true);
   if(MYDEBUG) SCRUTE(ret);
   return ret;
 }
@@ -864,6 +909,256 @@ void SMESH_Mesh::RemoveGroup (const int theGroupID)
   delete _mapGroup[theGroupID];
 }
 
+//=============================================================================
+/*!
+ *  IsLocal1DHypothesis
+ *  Check, if there is 1D hypothesis assigned directly on <theEdge>
+ */
+//=============================================================================
+bool SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
+{
+  const SMESHDS_Mesh* meshDS = GetMeshDS();
+  const list<const SMESHDS_Hypothesis*>& listHyp = meshDS->GetHypothesis(theEdge);
+  list<const SMESHDS_Hypothesis*>::const_iterator it = listHyp.begin();
+
+  for (; it != listHyp.end(); it++) {
+    const SMESH_Hypothesis * aHyp = static_cast<const SMESH_Hypothesis*>(*it);
+    if (aHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO &&
+        aHyp->GetDim() == 1) { // 1D Hypothesis found
+      return true;
+    }
+  }
+  return false;
+}
+
+//=============================================================================
+/*!
+ *  IsPropagationHypothesis
+ */
+//=============================================================================
+bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
+{
+  return _mapPropagationChains.Contains(theEdge);
+}
+
+//=============================================================================
+/*!
+ *  IsPropagatedHypothesis
+ */
+//=============================================================================
+bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
+                                         TopoDS_Shape&       theMainEdge)
+{
+  int nbChains = _mapPropagationChains.Extent();
+  for (int i = 1; i <= nbChains; i++) {
+    const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
+    if (aChain.Contains(theEdge)) {
+      theMainEdge = _mapPropagationChains.FindKey(i);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+//=============================================================================
+/*!
+ *  CleanMeshOnPropagationChain
+ */
+//=============================================================================
+void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
+{
+  const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
+  int i, nbEdges = aChain.Extent();
+  for (i = 1; i <= nbEdges; i++) {
+    TopoDS_Shape anEdge = aChain.FindKey(i);
+    SMESH_subMesh *subMesh = GetSubMesh(anEdge);
+    SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
+    if (subMeshDS && subMeshDS->NbElements() > 0) {
+      subMesh->ComputeStateEngine(SMESH_subMesh::CLEANDEP);
+    }
+  }
+}
+
+//=============================================================================
+/*!
+ *  RebuildPropagationChains
+ *  Rebuild all existing propagation chains.
+ *  Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
+ */
+//=============================================================================
+bool SMESH_Mesh::RebuildPropagationChains()
+{
+  bool ret = true;
+
+  // Clean all chains, because they can be not up-to-date
+  int i, nbChains = _mapPropagationChains.Extent();
+  for (i = 1; i <= nbChains; i++) {
+    TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
+    CleanMeshOnPropagationChain(aMainEdge);
+    _mapPropagationChains.ChangeFromIndex(i).Clear();
+  }
+
+  // Build all chains
+  for (i = 1; i <= nbChains; i++) {
+    TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
+    if (!BuildPropagationChain(aMainEdge))
+      ret = false;
+    CleanMeshOnPropagationChain(aMainEdge);
+  }
+
+  return ret;
+}
+
+//=============================================================================
+/*!
+ *  RemovePropagationChain
+ *  Have to be used, if Propagation hypothesis is removed from <theMainEdge>
+ */
+//=============================================================================
+bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
+{
+  if (!_mapPropagationChains.Contains(theMainEdge))
+    return false;
+
+  // Clean mesh elements and nodes, built on the chain
+  CleanMeshOnPropagationChain(theMainEdge);
+
+  // Clean the chain
+  _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
+
+  // Remove the chain from the map
+  int i = _mapPropagationChains.FindIndex(theMainEdge);
+  TopoDS_Vertex anEmptyShape;
+  BRep_Builder BB;
+  BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
+  TopTools_IndexedMapOfShape anEmptyMap;
+  _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
+
+  return true;
+}
+
+//=============================================================================
+/*!
+ *  BuildPropagationChain
+ */
+//=============================================================================
+bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
+{
+  if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
+
+  // Add new chain, if there is no
+  if (!_mapPropagationChains.Contains(theMainEdge)) {
+    TopTools_IndexedMapOfShape aNewChain;
+    _mapPropagationChains.Add(theMainEdge, aNewChain);
+  }
+
+  // Check presence of 1D hypothesis to be propagated
+  if (!IsLocal1DHypothesis(theMainEdge)) {
+    MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
+    return true;
+  }
+
+  // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
+  TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
+  if (aChain.Extent() > 0) {
+    CleanMeshOnPropagationChain(theMainEdge);
+    aChain.Clear();
+  }
+
+  // At first put <theMainEdge> in the chain
+  aChain.Add(theMainEdge);
+
+  // List of edges, added to chain on the previous cycle pass
+  TopTools_ListOfShape listPrevEdges;
+  listPrevEdges.Append(theMainEdge);
+
+//   5____4____3____4____5____6
+//   |    |    |    |    |    |
+//   |    |    |    |    |    |
+//   4____3____2____3____4____5
+//   |    |    |    |    |    |      Number in the each knot of
+//   |    |    |    |    |    |      grid indicates cycle pass,
+//   3____2____1____2____3____4      on which corresponding edge
+//   |    |    |    |    |    |      (perpendicular to the plane
+//   |    |    |    |    |    |      of view) will be found.
+//   2____1____0____1____2____3
+//   |    |    |    |    |    |
+//   |    |    |    |    |    |
+//   3____2____1____2____3____4
+
+  // Collect all edges pass by pass
+  while (listPrevEdges.Extent() > 0) {
+    // List of edges, added to chain on this cycle pass
+    TopTools_ListOfShape listCurEdges;
+
+    // Find the next portion of edges
+    TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
+    for (; itE.More(); itE.Next()) {
+      TopoDS_Shape anE = itE.Value();
+
+      // Iterate on faces, having edge <anE>
+      TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
+      for (; itA.More(); itA.Next()) {
+        TopoDS_Shape aW = itA.Value();
+
+        // There are objects of different type among the ancestors of edge
+        if (aW.ShapeType() == TopAbs_WIRE) {
+          TopoDS_Shape anOppE;
+
+          BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
+          Standard_Integer nb = 1, found = 0;
+          TopTools_Array1OfShape anEdges (1,4);
+          for (; aWE.More(); aWE.Next(), nb++) {
+            if (nb > 4) {
+              found = 0;
+              break;
+            }
+            anEdges(nb) = aWE.Current();
+            if (!_mapAncestors.Contains(anEdges(nb))) {
+              MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
+              break;
+            } else {
+              int ind = _mapAncestors.FindIndex(anEdges(nb));
+              anEdges(nb) = _mapAncestors.FindKey(ind);
+            }
+            if (anEdges(nb).IsSame(anE)) found = nb;
+          }
+
+          if (nb == 5 && found > 0) {
+            // Quadrangle face found, get an opposite edge
+            Standard_Integer opp = found + 2;
+            if (opp > 4) opp -= 4;
+            anOppE = anEdges(opp);
+
+            if (!aChain.Contains(anOppE)) {
+              if (!IsLocal1DHypothesis(anOppE)) {
+                TopoDS_Shape aMainEdgeForOppEdge;
+                if (IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge)) {
+                  // Collision!
+                  MESSAGE("Error: Collision between propagated hypotheses");
+                  CleanMeshOnPropagationChain(theMainEdge);
+                  aChain.Clear();
+                  return false;
+                } else {
+                  // Add found edge to the chain
+                  aChain.Add(anOppE);
+                  listCurEdges.Append(anOppE);
+                }
+              }
+            }
+          } // if (nb == 5 && found > 0)
+        } // if (aF.ShapeType() == TopAbs_WIRE)
+      } // for (; itF.More(); itF.Next())
+    } // for (; itE.More(); itE.Next())
+
+    listPrevEdges = listCurEdges;
+  } // while (listPrevEdges.Extent() > 0)
+
+  CleanMeshOnPropagationChain(theMainEdge);
+  return true;
+}
+
 //=======================================================================
 //function : GetAncestors
 //purpose  : return list of ancestors of theSubShape in the order

src/SMESH/SMESH_Mesh.hxx

@@ -29,13 +29,18 @@
 #ifndef _SMESH_MESH_HXX_
 #define _SMESH_MESH_HXX_
 
+#include "SMESH_Hypothesis.hxx"
+//#include "SMESH_subMesh.hxx"
+
 #include "SMESHDS_Document.hxx"
 #include "SMESHDS_Mesh.hxx"
 #include "SMESHDS_Command.hxx"
-#include "SMESH_Hypothesis.hxx"
-#include "SMESH_subMesh.hxx"
 #include "SMDSAbs_ElementType.hxx"
 
+#include "NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx"
+
+#include "Utils_SALOME_Exception.hxx"
+
 #include <TopExp.hxx>
 #include <TopExp_Explorer.hxx>
 #include <TopoDS.hxx>
@@ -62,6 +67,9 @@
 class SMESH_Gen;
 class SMESH_Group;
 class TopTools_ListOfShape;
+class SMESH_subMesh;
+
+typedef NMTTools_IndexedDataMapOfShapeIndexedMapOfShape IndexedMapOfChain;
 
 class SMESH_Mesh
 {
@@ -168,8 +176,34 @@ public:
   
   void RemoveGroup (const int theGroupID);
 
+  // Propagation hypothesis management
+
+  bool IsLocal1DHypothesis (const TopoDS_Shape& theEdge);
+  // Returns true, if a local 1D hypothesis is set directly on <theEdge>
+
+  bool IsPropagationHypothesis (const TopoDS_Shape& theEdge);
+  // Returns true, if a local Propagation hypothesis is set directly on <theEdge>
+
+  bool IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
+                               TopoDS_Shape&       theMainEdge);
+  // Returns true, if a local 1D hypothesis is
+  // propagated on <theEdge> from some other edge.
+  // Returns through <theMainEdge> the edge, from
+  // which the 1D hypothesis is propagated on <theEdge>
+
+  bool RebuildPropagationChains();
+  bool RemovePropagationChain (const TopoDS_Shape& theMainEdge);
+  bool BuildPropagationChain (const TopoDS_Shape& theMainEdge);
+
+  //
+  
   ostream& Dump(ostream & save);
   
+private:
+  // Propagation hypothesis management
+  void CleanMeshOnPropagationChain(const TopoDS_Shape& theMainEdge);
+  //
+  
 private:
   int _id;					// id given by creator (unique within the creator instance)
   int _studyId;
@@ -186,6 +220,8 @@ private:
   SMESH_Gen *_gen;
   
   TopTools_IndexedDataMapOfShapeListOfShape _mapAncestors;
+
+  IndexedMapOfChain _mapPropagationChains; // Propagation hypothesis management
 };
 
 #endif

src/SMESH/SMESH_Pattern.hxx

@@ -30,7 +30,6 @@
 #include <iostream>
 
 #include <TopoDS_Shape.hxx>
-//#include <TopTools_IndexedMapOfShape.hxx>
 #include <TopTools_IndexedMapOfOrientedShape.hxx>
 #include <gp_XYZ.hxx>
 #include <gp_XY.hxx>

src/SMESH/SMESH_subMesh.cxx

@@ -32,16 +32,20 @@ using namespace std;
 #include "SMESH_Mesh.hxx"
 #include "SMESH_Hypothesis.hxx"
 #include "SMESH_Algo.hxx"
+
 #include "utilities.h"
 #include "OpUtil.hxx"
 
+#include <BRep_Builder.hxx>
+
 #include <TopExp.hxx>
-#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopTools_MapOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+
 #include <TColStd_ListIteratorOfListOfInteger.hxx>
-#include <TopoDS_Compound.hxx>
-#include <BRep_Builder.hxx>
 
 #ifdef _DEBUG_
 #include <gp_Pnt.hxx>
@@ -550,6 +554,43 @@ SMESH_Hypothesis::Hypothesis_Status
 
     if ( !_meshDS->AddHypothesis(_subShape, anHyp))
       return SMESH_Hypothesis::HYP_ALREADY_EXIST;
+
+    // Serve Propagation of 1D hypothesis
+    if (event == ADD_HYP) {
+      bool isPropagationOk = true;
+      string hypName = anHyp->GetName();
+
+      if (hypName == "Propagation") {
+        if (_subShape.ShapeType() == TopAbs_EDGE) {
+          isPropagationOk = _father->BuildPropagationChain(_subShape);
+        } else {
+          TopExp_Explorer exp (_subShape, TopAbs_EDGE);
+          TopTools_MapOfShape aMap;
+          for (; exp.More(); exp.Next()) {
+            if (aMap.Add(exp.Current())) {
+              if (!_father->BuildPropagationChain(exp.Current())) {
+                isPropagationOk = false;
+              }
+            }
+          }
+        }
+      } else if (anHyp->GetDim() == 1) { // Only 1D hypothesis can be propagated
+        if (_subShape.ShapeType() == TopAbs_EDGE) {
+          TopoDS_Shape aMainEdge;
+          if (_father->IsPropagatedHypothesis(_subShape, aMainEdge)) {
+            isPropagationOk = _father->RebuildPropagationChains();
+          } else if (_father->IsPropagationHypothesis(_subShape)) {
+            isPropagationOk = _father->BuildPropagationChain(_subShape);
+          } else {
+          }
+        }
+      } else {
+      }
+
+      if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) {
+        ret = SMESH_Hypothesis::HYP_CONCURENT;
+      }
+    } // Serve Propagation of 1D hypothesis
   }
 
   // --------------------------
@@ -559,6 +600,51 @@ SMESH_Hypothesis::Hypothesis_Status
   {
     if (!_meshDS->RemoveHypothesis(_subShape, anHyp))
       return SMESH_Hypothesis::HYP_OK; // nothing changes
+
+    // Serve Propagation of 1D hypothesis
+    if (event == REMOVE_HYP) {
+      bool isPropagationOk = true;
+      string hypName = anHyp->GetName();
+
+      if (hypName == "Propagation") {
+        if (_subShape.ShapeType() == TopAbs_EDGE) {
+          if (!_father->RemovePropagationChain(_subShape)) {
+            return SMESH_Hypothesis::HYP_UNKNOWN_FATAL;
+          }
+          // rebuild propagation chains, because removing one
+          // chain can resolve concurention, existing before
+          isPropagationOk = _father->RebuildPropagationChains();
+        } else {
+          TopExp_Explorer exp (_subShape, TopAbs_EDGE);
+          TopTools_MapOfShape aMap;
+          for (; exp.More(); exp.Next()) {
+            if (aMap.Add(exp.Current())) {
+              if (!_father->RemovePropagationChain(exp.Current())) {
+                return SMESH_Hypothesis::HYP_UNKNOWN_FATAL;
+              }
+            }
+          }
+          // rebuild propagation chains, because removing one
+          // chain can resolve concurention, existing before
+          if (!_father->RebuildPropagationChains()) {
+            isPropagationOk = false;
+          }
+        }
+      } else { // if (hypName == "Propagation")
+        if (anHyp->GetDim() == 1) // Only 1D hypothesis can be propagated
+        {
+          if (_subShape.ShapeType() == TopAbs_EDGE) {
+            isPropagationOk = _father->RebuildPropagationChains();
+            if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT)
+              ret = SMESH_Hypothesis::HYP_CONCURENT;
+          }
+        }
+      }
+
+      if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) {
+        ret = SMESH_Hypothesis::HYP_CONCURENT;
+      }
+    } // Serve Propagation of 1D hypothesis
   }
 
   // ------------------
@@ -843,22 +929,9 @@ SMESH_Hypothesis::Hypothesis_Status
     ASSERT(0);
     break;
   }
-  // ----------------------------------------
-  // check concurent hypotheses on ansestors
-  // ----------------------------------------
-  if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
-      (event == ADD_FATHER_HYP ||
-       event == ADD_FATHER_ALGO ||
-       event == REMOVE_FATHER_HYP ||
-       event == REMOVE_FATHER_ALGO ||
-       event == REMOVE_ALGO ||
-       event == REMOVE_HYP))
-  {
-    ret = CheckConcurentHypothesis( anHyp->GetType() );
-  }
 
   if ((_algoState != oldAlgoState) || modifiedHyp)
-    int retc = ComputeStateEngine(MODIF_ALGO_STATE);
+    ComputeStateEngine(MODIF_ALGO_STATE);
 
   return ret;
 }

src/SMESH/SMESH_subMesh.hxx

@@ -123,6 +123,8 @@ class SMESH_subMesh
   // return true if theHypothesis can be used to mesh me:
   // its shape type is checked
   
+  SMESH_Hypothesis::Hypothesis_Status CheckConcurentHypothesis (const int theHypType);
+  // check if there are several applicable hypothesis on fathers
 
  protected:
   void InsertDependence(const TopoDS_Shape aSubShape);
@@ -150,9 +152,6 @@ class SMESH_subMesh
                           const TopoDS_Shape& theCollection);
   // Apply theAlgo to all subshapes in theCollection
 
-  SMESH_Hypothesis::Hypothesis_Status CheckConcurentHypothesis (const int theHypType);
-  // check if there are several applicable hypothesis on fathers
-
   const SMESH_Hypothesis* GetSimilarAttached(const TopoDS_Shape&      theShape,
                                              const SMESH_Hypothesis * theHyp,
                                              const int                theHypType = 0);

src/SMESHGUI/Makefile.in

@@ -66,6 +66,7 @@ LIB_SRC =	SMESHGUI.cxx \
 		SMESHGUI_RemoveNodesDlg.cxx \
 		SMESHGUI_RemoveElementsDlg.cxx \
 		SMESHGUI_MeshInfosDlg.cxx \
+		SMESHGUI_StandardMeshInfosDlg.cxx \
 		SMESHGUI_Preferences_ColorDlg.cxx \
 		SMESHGUI_Preferences_ScalarBarDlg.cxx \
 		SMESHGUI_Preferences_SelectionDlg.cxx \
@@ -119,6 +120,7 @@ LIB_MOC = \
 		SMESHGUI_RemoveNodesDlg.h \
 		SMESHGUI_RemoveElementsDlg.h \
 		SMESHGUI_MeshInfosDlg.h \
+		SMESHGUI_StandardMeshInfosDlg.h \
 		SMESHGUI_Preferences_ColorDlg.h \
 		SMESHGUI_Preferences_ScalarBarDlg.h \
 		SMESHGUI_Preferences_SelectionDlg.h \

src/SMESHGUI/SMESHGUI.cxx

@@ -34,6 +34,7 @@
 #include "SMESHGUI_RemoveNodesDlg.h"
 #include "SMESHGUI_RemoveElementsDlg.h"
 #include "SMESHGUI_MeshInfosDlg.h"
+#include "SMESHGUI_StandardMeshInfosDlg.h"
 #include "SMESHGUI_Preferences_ColorDlg.h"
 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
 #include "SMESHGUI_Preferences_SelectionDlg.h"
@@ -626,6 +627,16 @@ namespace{
 
   void OnEditDelete()
   {
+    // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
+    QString aParentComponent = ((SALOMEGUI_Desktop*)QAD_Application::getDesktop())->getComponentFromSelection();
+    if ( aParentComponent != QAD_Application::getDesktop()->getActiveComponent() )  {
+      QAD_MessageBox::warn1 ( QAD_Application::getDesktop(),
+			      QObject::tr("ERR_ERROR"), 
+			      QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg(QAD_Application::getDesktop()->getComponentUserName( "SMESH" )),
+			      QObject::tr("BUT_OK") );
+      return;
+    }
+    // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
     if (QAD_MessageBox::warn2
 	(QAD_Application::getDesktop(),
 	 QObject::tr("SMESH_WRN_WARNING"),
@@ -712,32 +723,35 @@ namespace{
  *
  */
 //=============================================================================
-class CustomItem:public QCustomMenuItem
+class CustomItem : public QCustomMenuItem
 {
- public:
+public:
-  CustomItem(const QString & s, const QFont & f):string(s), font(f)
+  CustomItem(const QString& s, const QFont& f) : myString(s), myFont(f) {}
-  {
+  ~CustomItem() {}
-  };
-  ~CustomItem()
-  {
-  }
 
-  void paint(QPainter * p, const QColorGroup & /*cg */ , bool /*act */ ,
+  void paint(QPainter* p, const QColorGroup& cg, bool act, bool /*enabled*/, int x, int y, int w, int h)
-             bool /*enabled */ , int x, int y, int w, int h)
   {
-    p->setFont(font);
+    p->save();
-    p->drawText(x, y, w, h,
+    p->fillRect( x, y, w, h, act ? cg.highlight() : cg.mid() );
-                AlignHCenter | AlignVCenter | ShowPrefix | DontClip, string);
+    p->setPen( act ? cg.highlightedText() : cg.buttonText() );
+    p->setFont( myFont );
+    p->drawText( x, y, w, h, AlignHCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, myString );
+    p->restore();
   }
 
   QSize sizeHint()
   {
-    return QFontMetrics(font).
+    return QFontMetrics( myFont ).size( AlignHCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, myString );
-      size(AlignHCenter | AlignVCenter | ShowPrefix | DontClip, string);
   }
- private:
+
-  QString string;
+  bool fullSpan() const
-  QFont font;
+  {
+    return true;
+  }
+
+private:
+  QString myString;
+  QFont   myFont;
 };
 
 //=============================================================================
@@ -1542,6 +1556,29 @@ bool SMESHGUI::OnGUIEvent(int theCommandID, QAD_Desktop * parent)
       break;
     }
 
+  case 902:					// STANDARD MESH INFOS
+    {
+      EmitSignalDeactivateDialog();
+      SALOME_Selection *Sel =
+	SALOME_Selection::Selection(myActiveStudy->getSelection());
+      if ( Sel->IObjectCount() > 1 ) { // a dlg for each IO
+        SALOME_ListIO IOs; IOs = Sel->StoredIObjects(); // list copy
+        SALOME_ListIteratorOfListIO It (IOs);
+        for ( ; It.More(); It.Next() ) {
+          Sel->ClearIObjects();
+          Sel->AddIObject( It.Value() );
+          SMESHGUI_StandardMeshInfosDlg *aDlg = new SMESHGUI_StandardMeshInfosDlg(parent, "", false);
+        }
+        // restore selection
+        Sel->ClearIObjects();
+        for (It.Initialize( IOs ) ; It.More(); It.Next() )
+          Sel->AddIObject( It.Value() );
+      }
+      else
+        SMESHGUI_StandardMeshInfosDlg *aDlg = new SMESHGUI_StandardMeshInfosDlg(parent, "", false);
+      break;
+    } 
+    
   case 1001:					// AUTOMATIC UPDATE PREFERENCES
     {
       parent->menuBar()->setItemChecked(1001, !parent->menuBar()->isItemChecked(1001));
@@ -2246,7 +2283,7 @@ bool SMESHGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* popup, const QString
       if ( topItem >= 0 ) {
 	if ( theParent == "Viewer" ) {
 	  // set bold font for popup menu's TopLabel item (Viewer popup)
-	  QFont fnt = QApplication::font(); fnt.setBold( TRUE );
+	  QFont fnt = popup->font(); fnt.setBold( TRUE );
 	  popup->removeItem( QAD_TopLabel_Popup_ID );
 	  popup->insertItem( new CustomItem( QString( IObject->getName() ), fnt ), QAD_TopLabel_Popup_ID, topItem );
 	}
@@ -2438,7 +2475,7 @@ bool SMESHGUI::CustomPopup(QAD_Desktop* parent, QPopupMenu* popup, const QString
 	int topItem = popup->indexOf( QAD_TopLabel_Popup_ID );
 	if ( topItem >= 0 ) {
 	  // set bold font for popup menu's TopLabel item
-	  QFont fnt = QApplication::font(); fnt.setBold( TRUE );
+	  QFont fnt = popup->font(); fnt.setBold( TRUE );
 	  popup->removeItem( QAD_TopLabel_Popup_ID );
 	  popup->insertItem( new CustomItem( QString("%1 ").arg( nbSel ) + type + "(s) ", fnt ), QAD_TopLabel_Popup_ID, topItem );
 	}

src/SMESHGUI/SMESHGUI_EditHypothesesDlg.cxx

@@ -745,7 +745,8 @@ void SMESHGUI_EditHypothesesDlg::InitGeom()
   SALOMEDS::GenericAttribute_var    anAttr;
   SALOMEDS::AttributeName_var       aName;
   if ( !myGeomShape->_is_nil() && (!myMesh->_is_nil() || !mySubMesh->_is_nil()) ) {
-    SALOMEDS::SObject_var aSO = SMESH::GetActiveStudyDocument()->FindObjectIOR( myGeomShape->GetName() );
+    SALOMEDS::Study_var aStudy = SMESH::GetActiveStudyDocument();
+    SALOMEDS::SObject_var aSO = aStudy->FindObjectIOR( aStudy->ConvertObjectToIOR(myGeomShape) );
     if ( !aSO->_is_nil() ) {
       if (aSO->FindAttribute(anAttr, "AttributeName") ) {
 	aName = SALOMEDS::AttributeName::_narrow(anAttr);

src/SMESHGUI/SMESHGUI_MeshInfosDlg.cxx

@@ -347,6 +347,8 @@ SMESHGUI_MeshInfosDlg::SMESHGUI_MeshInfosDlg( QWidget* parent,  const char* name
   this->move( x, y );
   this->show();
 
+  cout<<"----"<<this->height()<<endl;
+  cout<<"----"<<this->width()<<endl;
   // init dialog with current selection
   onSelectionChanged();
 }

src/SMESHGUI/SMESHGUI_RotationDlg.cxx

@@ -529,7 +529,10 @@ void SMESHGUI_RotationDlg::SelectionIntoArgument()
   myMesh = SMESH::GetMeshByIO( mySelection->firstIObject() );
   if(myMesh->_is_nil())
     return;
+
   myActor = SMESH::FindActorByObject(myMesh);
+  if (!myActor)
+    myActor = SMESH::FindActorByEntry(IO->getEntry());
   if (!myActor)
     return;
   

src/SMESHGUI/SMESHGUI_StandardMeshInfosDlg.cxx

@@ -0,0 +1,448 @@
+//  SMESH SMESHGUI : GUI for SMESH component
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : SMESHGUI_StandardMeshInfosDlg.cxx
+//  Author : Michael ZORIN
+//  Module : SMESH
+//  $Header$
+
+// QT Includes
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qlineedit.h>
+#include <qtextbrowser.h>
+#include <qmap.h>
+#include <qpushbutton.h>
+
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "QAD_WaitCursor.h"
+
+#include "SMESHGUI_StandardMeshInfosDlg.h"
+#include "SMESHGUI_Utils.h"
+#include "SMESHGUI_MeshUtils.h"
+#include "SMESHGUI.h"
+
+#include "SMESH.hxx"
+
+// IDL Headers
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
+#include CORBA_SERVER_HEADER(SMESH_Group)
+#include CORBA_SERVER_HEADER(GEOM_Gen)
+
+#include "utilities.h"
+
+using namespace std;
+
+
+//=================================================================================
+/*!
+ *  SMESHGUI_StandardMeshInfosDlg::SMESHGUI_StandardMeshInfosDlg
+ * 
+ *  Constructor
+ */
+//=================================================================================
+SMESHGUI_StandardMeshInfosDlg::SMESHGUI_StandardMeshInfosDlg( QWidget* parent,  const char* name, bool modal, WFlags fl )
+     : QDialog( parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose )
+{
+  if ( !name )
+      setName( "SMESHGUI_StandardMeshInfosDlg" );
+  setCaption( tr( "SMESH_STANDARD_MESHINFO_TITLE"  ) );
+  setSizeGripEnabled( TRUE );
+
+  myStartSelection = true;
+  myIsActiveWindow = true;
+
+  // dialog layout
+  QGridLayout* aDlgLayout = new QGridLayout( this ); 
+  aDlgLayout->setSpacing( 6 );
+  aDlgLayout->setMargin( 11 );
+  
+  // mesh group box
+  myMeshGroup = new QGroupBox( this, "myMeshGroup" );
+  myMeshGroup->setTitle( tr( "SMESH_MESH" ) );
+  myMeshGroup->setColumnLayout(0, Qt::Vertical );
+  myMeshGroup->layout()->setSpacing( 0 );
+  myMeshGroup->layout()->setMargin( 0 );
+  QGridLayout* myMeshGroupLayout = new QGridLayout( myMeshGroup->layout() );
+  myMeshGroupLayout->setAlignment( Qt::AlignTop );
+  myMeshGroupLayout->setSpacing( 6 );
+  myMeshGroupLayout->setMargin( 11 );
+  
+  // select button, label and line edit with mesh name
+  myNameLab = new QLabel( myMeshGroup, "myNameLab" );
+  myNameLab->setText( tr( "SMESH_NAME"  ) );
+  myMeshGroupLayout->addWidget( myNameLab, 0, 0 );
+
+  QPixmap image0( QAD_Desktop::getResourceManager()->loadPixmap( "SMESH",tr( "ICON_SELECT" ) ) );
+  mySelectBtn = new QPushButton( myMeshGroup, "mySelectBtn" );
+  mySelectBtn->setPixmap( image0 );
+  mySelectBtn->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+  myMeshGroupLayout->addWidget( mySelectBtn, 0, 1 );
+  
+  myMeshLine = new QLineEdit( myMeshGroup, "myMeshLine" );
+  myMeshGroupLayout->addWidget( myMeshLine, 0, 2 );
+  
+  aDlgLayout->addWidget( myMeshGroup, 0, 0 );
+
+  // information group box
+  myInfoGroup  = new QGroupBox( this, "myInfoGroup" );
+  myInfoGroup->setTitle( tr( "SMESH_INFORMATION" ) );
+  myInfoGroup->setColumnLayout(0, Qt::Vertical );
+  myInfoGroup->layout()->setSpacing( 0 );
+  myInfoGroup->layout()->setMargin( 0 );
+  QGridLayout* myInfoGroupLayout = new QGridLayout( myInfoGroup->layout() );
+  myInfoGroupLayout->setAlignment( Qt::AlignTop );
+  myInfoGroupLayout->setSpacing( 6 );
+  myInfoGroupLayout->setMargin( 11 );
+  
+  // information text browser
+  myInfo = new QTextBrowser(myInfoGroup, "myInfo");
+  myInfoGroupLayout->addWidget( myInfo, 0, 0 );
+
+  aDlgLayout->addWidget( myInfoGroup, 1, 0 );
+
+  // buttons group
+  myButtonsGroup = new QGroupBox( this, "myButtonsGroup" );
+  myButtonsGroup->setColumnLayout(0, Qt::Vertical );
+  myButtonsGroup->layout()->setSpacing( 0 );  myButtonsGroup->layout()->setMargin( 0 );
+  QHBoxLayout* myButtonsGroupLayout = new QHBoxLayout( myButtonsGroup->layout() );
+  myButtonsGroupLayout->setAlignment( Qt::AlignTop );
+  myButtonsGroupLayout->setSpacing( 6 ); myButtonsGroupLayout->setMargin( 11 );
+  
+  // buttons --> OK button
+  myOkBtn = new QPushButton( tr( "SMESH_BUT_OK"  ), myButtonsGroup, "myOkBtn" );
+  myOkBtn->setAutoDefault( TRUE ); myOkBtn->setDefault( TRUE );
+  myButtonsGroupLayout->addStretch();
+  myButtonsGroupLayout->addWidget( myOkBtn );
+  myButtonsGroupLayout->addStretch();
+  
+  aDlgLayout->addWidget( myButtonsGroup, 2, 0 );
+  
+  mySelection = SALOME_Selection::Selection( SMESHGUI::GetSMESHGUI()->GetActiveStudy()->getSelection() );
+  SMESHGUI::GetSMESHGUI()->SetActiveDialogBox( this ) ;
+
+  // connect signals
+  connect( myOkBtn,                  SIGNAL( clicked() ),                      this, SLOT( close() ) );
+  connect( mySelectBtn,              SIGNAL( clicked() ),                      this, SLOT( onStartSelection() ) );
+  connect( SMESHGUI::GetSMESHGUI(),  SIGNAL( SignalCloseAllDialogs() ),        this, SLOT( close() ) ) ;
+  connect( SMESHGUI::GetSMESHGUI(),  SIGNAL( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
+  connect( mySelection,              SIGNAL( currentSelectionChanged() ),      this, SLOT( onSelectionChanged() ) );
+
+  // resize and move dialog, then show
+  this->setMinimumSize(270, 428);
+  int x, y;
+  SMESHGUI::GetSMESHGUI()->DefineDlgPosition( this, x, y );
+  this->move( x, y );
+  this->show();
+  
+  // init dialog with current selection
+  myMeshFilter = new SMESH_TypeFilter( MESH );
+  mySelection->AddFilter( myMeshFilter );
+  onSelectionChanged();
+}
+
+//=================================================================================
+/*!
+ *  SMESHGUI_StandardMeshInfosDlg::~SMESHGUI_StandardMeshInfosDlg
+ * 
+ *  Destructor
+ */
+//=================================================================================
+SMESHGUI_StandardMeshInfosDlg::~SMESHGUI_StandardMeshInfosDlg()
+{
+}
+
+//=================================================================================
+/*!
+ *  SMESHGUI_StandardMeshInfosDlg::DumpMeshInfos
+ */
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::DumpMeshInfos()
+{
+  QAD_WaitCursor wc;
+  int nbSel = mySelection->IObjectCount();
+  myInfo->clear();
+  if ( nbSel == 1 ) {
+    myStartSelection = false;
+    myMeshLine->setText( "" );
+    SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( mySelection->firstIObject() );
+    
+    if ( !aMesh->_is_nil() ) {
+      QString aName, anInfo;
+      SMESH::GetNameOfSelectedIObjects(mySelection, aName);
+      myMeshLine->setText( aName );
+      int aNbNodes =   (int)aMesh->NbNodes();
+      int aNbEdges =   (int)aMesh->NbEdges();
+      int aNbFaces =   (int)aMesh->NbFaces();
+      int aNbVolumes = (int)aMesh->NbVolumes();
+      
+      int aDimension = 0;
+      double aNbDimElements = 0;
+      if (aNbVolumes > 0) {
+	aNbDimElements = aNbVolumes;
+	aDimension = 3;
+      }
+      else if(aNbFaces > 0 ) {
+	aNbDimElements = aNbFaces;
+	aDimension = 2;
+      }
+      else if(aNbEdges > 0 ) {
+	aNbDimElements = aNbEdges;
+	aDimension = 1;
+      }
+      else if(aNbNodes > 0 ) {
+	aNbDimElements = aNbNodes;
+	aDimension = 0;
+      }
+      
+      // information about the mesh
+      anInfo.append(QString("Nb of element of dimension %1:<b> %2</b><br>").arg(aDimension).arg(aNbDimElements));
+      anInfo.append(QString("Nb of nodes: <b>%1</b><br><br>").arg(aNbNodes));
+
+      // information about the groups of the mesh
+      SALOMEDS::Study_var aStudy = SMESH::GetActiveStudyDocument();
+      SALOMEDS::SObject_var aMeshSO = aStudy->FindObjectIOR( aStudy->ConvertObjectToIOR(aMesh) ); 
+      SALOMEDS::SObject_var anObj;
+      
+      bool hasGroup = false;
+
+      // info about groups on nodes
+      aMeshSO->FindSubObject(Tag_NodeGroups , anObj);
+      if ( !anObj->_is_nil() )
+	{
+	  SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(anObj);
+	  if (it->More())
+	    {
+	      anInfo.append(QString("Groups:<br><br>"));
+	      hasGroup = true;
+	    }
+	  for(; it->More(); it->Next()){
+	    SALOMEDS::SObject_var subObj = it->Value();
+	    SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( subObj->GetObject() );
+	    if ( !aGroup->_is_nil() )
+	      {
+		anInfo.append(QString("-   <b>%1</b><br>").arg(aGroup->GetName()));
+		anInfo.append(QString("%1<br>").arg("on nodes"));
+		anInfo.append(QString("%1<br>").arg(aGroup->Size()));
+		// check if the group based on geometry
+		SMESH::SMESH_GroupOnGeom_var aGroupOnGeom = SMESH::SMESH_GroupOnGeom::_narrow(aGroup);
+		if ( !aGroupOnGeom->_is_nil() )
+		  {
+		    GEOM::GEOM_Object_var aGroupMainShape = aGroupOnGeom->GetShape();
+		    QString aShapeName = "<unknown>";
+		    SALOMEDS::SObject_var aGeomObj, aRef;
+		    if ( subObj->FindSubObject( 1, aGeomObj ) &&  aGeomObj->ReferencedObject( aRef ))
+		      aShapeName = aRef->GetName();
+		    anInfo.append(QString("based on <i>%1</i> geometry object<br><br>").arg(aShapeName));
+		  }
+		else
+		  anInfo.append(QString("<br>"));
+	      }
+	  }
+	}  
+      
+      // info about groups on edges
+      anObj = SALOMEDS::SObject::_nil();
+      aMeshSO->FindSubObject(Tag_EdgeGroups , anObj);
+      if ( !anObj->_is_nil() )
+	{
+	  SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(anObj);
+	  if (!hasGroup && it->More())
+	    {
+	      anInfo.append(QString("Groups:<br><br>"));
+	      hasGroup = true;
+	    }
+	  for(; it->More(); it->Next()){
+	    SALOMEDS::SObject_var subObj = it->Value();
+	    SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( subObj->GetObject() );
+	    if ( !aGroup->_is_nil() )
+	      {
+		anInfo.append(QString("-   <b>%1</b><br>").arg(aGroup->GetName()));
+		anInfo.append(QString("%1<br>").arg("on edges"));
+		anInfo.append(QString("%1<br>").arg(aGroup->Size()));
+		// check if the group based on geometry
+		SMESH::SMESH_GroupOnGeom_var aGroupOnGeom = SMESH::SMESH_GroupOnGeom::_narrow(aGroup);
+		if ( !aGroupOnGeom->_is_nil() )
+		  {
+		    GEOM::GEOM_Object_var aGroupMainShape = aGroupOnGeom->GetShape();
+		    QString aShapeName = "<unknown>";
+		    SALOMEDS::SObject_var aGeomObj, aRef;
+		    if ( subObj->FindSubObject( 1, aGeomObj ) &&  aGeomObj->ReferencedObject( aRef ))
+		      aShapeName = aRef->GetName();
+		    anInfo.append(QString("based on <i>%1</i> geometry object<br><br>").arg(aShapeName));
+		  }
+		else
+		  anInfo.append(QString("<br>"));
+	      }
+	  }
+	}
+      
+      // info about groups on faces
+      anObj = SALOMEDS::SObject::_nil();
+      aMeshSO->FindSubObject(Tag_FaceGroups , anObj);
+      if ( !anObj->_is_nil() )
+	{
+	  SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(anObj);
+	  if (!hasGroup && it->More())
+	    {
+	      anInfo.append(QString("Groups:<br><br>"));
+	      hasGroup = true;
+	    }
+	  for(; it->More(); it->Next()){
+	    SALOMEDS::SObject_var subObj = it->Value();
+	    SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( subObj->GetObject() );
+	    if ( !aGroup->_is_nil() )
+	      {
+		anInfo.append(QString("-   <b>%1</b><br>").arg(aGroup->GetName()));
+		anInfo.append(QString("%1<br>").arg("on faces"));
+		anInfo.append(QString("%1<br>").arg(aGroup->Size()));
+		// check if the group based on geometry
+		SMESH::SMESH_GroupOnGeom_var aGroupOnGeom = SMESH::SMESH_GroupOnGeom::_narrow(aGroup);
+		if ( !aGroupOnGeom->_is_nil() )
+		  {
+		    GEOM::GEOM_Object_var aGroupMainShape = aGroupOnGeom->GetShape();
+		    QString aShapeName = "<unknown>";
+		    SALOMEDS::SObject_var aGeomObj, aRef;
+		    if ( subObj->FindSubObject( 1, aGeomObj ) &&  aGeomObj->ReferencedObject( aRef ))
+		      aShapeName = aRef->GetName();
+		    anInfo.append(QString("based on <i>%1</i> geometry object<br><br>").arg(aShapeName));
+		  }
+		else
+		  anInfo.append(QString("<br>"));
+	      }
+	  }
+	}
+      
+      // info about groups on volumes
+      anObj = SALOMEDS::SObject::_nil();
+      aMeshSO->FindSubObject(Tag_VolumeGroups , anObj);
+      if ( !anObj->_is_nil() )
+	{
+	  SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(anObj);
+	  if (!hasGroup && it->More())
+	    anInfo.append(QString("Groups:<br>"));
+	  for(; it->More(); it->Next()){
+	    SALOMEDS::SObject_var subObj = it->Value();
+	    SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( subObj->GetObject() );
+	    if ( !aGroup->_is_nil() )
+	      {
+		anInfo.append(QString("-   <b>%1</b><br>").arg(aGroup->GetName()));
+		anInfo.append(QString("%1<br>").arg("on volumes"));
+		anInfo.append(QString("%1<br>").arg(aGroup->Size()));
+		// check if the group based on geometry
+		SMESH::SMESH_GroupOnGeom_var aGroupOnGeom = SMESH::SMESH_GroupOnGeom::_narrow(aGroup);
+		if ( !aGroupOnGeom->_is_nil() )
+		  {
+		    GEOM::GEOM_Object_var aGroupMainShape = aGroupOnGeom->GetShape();
+		    QString aShapeName = "<unknown>";
+		    SALOMEDS::SObject_var aGeomObj, aRef;
+		    if ( subObj->FindSubObject( 1, aGeomObj ) &&  aGeomObj->ReferencedObject( aRef ))
+		      aShapeName = aRef->GetName();
+		    anInfo.append(QString("based on <i>%1</i> geometry object<br><br>").arg(aShapeName));
+		  }
+		else
+		  anInfo.append(QString("<br>"));
+	      }
+	  }
+	}
+      
+      myInfo->setText(anInfo);
+      return;
+    }
+  }
+  
+  return;
+}
+
+//=================================================================================
+// function : SelectionIntoArgument()
+// purpose  : Called when selection has changed
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::onSelectionChanged()
+{
+  if ( myStartSelection )
+    DumpMeshInfos();
+}
+
+
+//=================================================================================
+// function : closeEvent()
+// purpose  :
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::closeEvent( QCloseEvent* e )
+{
+  mySelection->ClearFilters();
+  SMESHGUI::GetSMESHGUI()->ResetState();
+  QDialog::closeEvent( e );
+}
+
+
+//=================================================================================
+// function : windowActivationChange()
+// purpose  : called when window is activated/deactivated
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::windowActivationChange( bool oldActive )
+{
+  QDialog::windowActivationChange( oldActive );
+  if ( isActiveWindow() && myIsActiveWindow != isActiveWindow() )
+    ActivateThisDialog() ;
+  myIsActiveWindow = isActiveWindow();
+}
+
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose  :
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::DeactivateActiveDialog()
+{
+  disconnect( mySelection, 0, this, 0 );
+}
+
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose  :
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::ActivateThisDialog()
+{
+  /* Emit a signal to deactivate any active dialog */
+  SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog() ;
+  connect( mySelection, SIGNAL( currentSelectionChanged() ), this, SLOT( onSelectionChanged() ) );
+}
+
+//=================================================================================
+// function : onStartSelection()
+// purpose  : starts selection
+//=================================================================================
+void SMESHGUI_StandardMeshInfosDlg::onStartSelection()
+{
+  myStartSelection = true;
+  mySelection->AddFilter( myMeshFilter ) ;
+  myMeshLine->setText( tr( "Select a mesh" ) );
+  onSelectionChanged();
+  myStartSelection = true;
+}

src/SMESHGUI/SMESHGUI_StandardMeshInfosDlg.h

@@ -0,0 +1,83 @@
+//  SMESH SMESHGUI : GUI for SMESH component
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : SMESHGUI_StandardMeshInfosDlg.h
+//  Author : Michael ZORIN
+//  Module : SMESH
+//  $Header: 
+
+#ifndef SMESHGUI_STANDARDMESHINFOSDLG_H
+#define SMESHGUI_STANDARDMESHINFOSDLG_H
+
+#include "SMESH_TypeFilter.hxx"
+
+// QT Includes
+#include <qdialog.h>
+
+class QGroupBox;
+class QLabel;
+class QPushButton;
+class QLineEdit;
+class QTextBrowser;
+class SALOME_Selection;
+
+class SMESHGUI_StandardMeshInfosDlg : public QDialog
+{ 
+    Q_OBJECT
+
+public:
+    SMESHGUI_StandardMeshInfosDlg( QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 );
+    ~SMESHGUI_StandardMeshInfosDlg();
+
+protected:
+    void closeEvent( QCloseEvent* e );
+    void windowActivationChange( bool oldActive );
+    void DumpMeshInfos();
+
+private slots:
+    void onSelectionChanged();
+    void DeactivateActiveDialog() ;
+    void ActivateThisDialog();
+    void onStartSelection();
+
+private:
+    SALOME_Selection*     mySelection; 
+    bool                  myStartSelection;
+    bool                  myIsActiveWindow;
+    
+    Handle(SMESH_TypeFilter)      myMeshFilter;
+
+    QLabel*       myNameLab;
+    QPushButton*  mySelectBtn;
+    QLineEdit*    myMeshLine;
+    
+    QTextBrowser* myInfo;
+    
+    QGroupBox*    myMeshGroup;
+    QGroupBox*    myInfoGroup;
+    
+    QGroupBox*    myButtonsGroup;
+    QPushButton*  myOkBtn;
+};
+
+#endif // SMESHGUI_STANDARDMESHINFOSDLG_H

src/SMESHGUI/SMESHGUI_SymmetryDlg.cxx

@@ -592,7 +592,10 @@ void SMESHGUI_SymmetryDlg::SelectionIntoArgument()
   myMesh = SMESH::GetMeshByIO( mySelection->firstIObject() );
   if(myMesh->_is_nil())
     return;
+
   myActor = SMESH::FindActorByObject(myMesh);
+  if (!myActor)
+    myActor = SMESH::FindActorByEntry(IO->getEntry());
   if (!myActor)
     return;
   

src/SMESHGUI/SMESHGUI_TranslationDlg.cxx

@@ -560,7 +560,10 @@ void SMESHGUI_TranslationDlg::SelectionIntoArgument()
   myMesh = SMESH::GetMeshByIO(IO);
   if(myMesh->_is_nil())
     return;
+  
   myActor = SMESH::FindActorByObject(myMesh);
+  if (!myActor)
+    myActor = SMESH::FindActorByEntry(IO->getEntry());
   if (!myActor)
     return;
     

src/SMESHGUI/SMESH_msg_en.po

@@ -722,6 +722,10 @@ msgstr "Rotation"
 msgid "SMESH_MESHINFO_TITLE"
 msgstr "Mesh Infos"
 
+#Standard Mesh Infos
+msgid "SMESH_STANDARD_MESHINFO_TITLE"
+msgstr "Standard Mesh Infos"
+
 #Mesh Infos
 msgid "SMESH_MESHINFO_NAME"
 msgstr "Name"
@@ -790,6 +794,10 @@ msgstr "Heterogenous"
 msgid "SMESH_BAD_SELECTION"
 msgstr "No valid selection"
 
+#Information :
+msgid "SMESH_INFORMATION"
+msgstr "Information"
+
 # --------- Create hypotheses/algorithms ---------
 
 msgid "SMESH_CREATE_HYPOTHESES"
@@ -1665,8 +1673,8 @@ msgstr "Number of digits after point"
 msgid "SMESHGUI_PrecisionDlg::NOT_USE"
 msgstr "Do not use"
 
-
+msgid "NON_SMESH_OBJECTS_SELECTED"
-
+msgstr "There are objects selected which do not belong to %1 component."
 
 
 

src/SMESH_I/Makefile.in

@@ -44,7 +44,8 @@ EXPORT_HEADERS= \
 	SMESH_3D_Algo_i.hxx \
 	SMESH_subMesh_i.hxx \
 	SMESH_Mesh_i.hxx \
-	SMESH_Hypothesis_i.hxx
+	SMESH_Hypothesis_i.hxx \
+	SMESH.hxx
 
 EXPORT_PYSCRIPTS = smeshpy.py SMESH_test.py
 

src/SMESH_I/SMESH.hxx

@@ -0,0 +1,56 @@
+//  SMESH SMESH_I :
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : SMESH.hxx
+//  Author : Michael ZORIN
+//  Module : SMESH
+//  $Header: 
+
+#ifndef _SMESH_SMESH_HXX_
+#define _SMESH_SMESH_HXX_
+
+// Tags definition
+enum {
+  // Top level
+  Tag_HypothesisRoot         = 1, // hypotheses root
+  Tag_AlgorithmsRoot         = 2, // algorithms root
+  // Mesh/Submesh
+  Tag_RefOnShape             = 1, // references to shape
+  Tag_RefOnAppliedHypothesis = 2, // applied hypotheses root
+  Tag_RefOnAppliedAlgorithms = 3, // applied algorithms root
+  // Mesh only
+  Tag_SubMeshOnVertex        = 4, // sub-meshes roots by type
+  Tag_SubMeshOnEdge          = 5, // ...
+  Tag_SubMeshOnWire          = 6, // ...
+  Tag_SubMeshOnFace          = 7, // ...
+  Tag_SubMeshOnShell         = 8, // ...
+  Tag_SubMeshOnSolid         = 9, // ...
+  Tag_SubMeshOnCompound      = 10, // ...
+  Tag_NodeGroups             = 11, // Group roots by type
+  Tag_EdgeGroups             = 12, // ...
+  Tag_FaceGroups             = 13, // ...
+  Tag_VolumeGroups           = 14 // ... 
+};
+
+#endif
+

src/SMESH_I/SMESH_Gen_i_1.cxx

@@ -33,6 +33,8 @@
 #include "SMESH_Algo_i.hxx"
 #include "SMESH_Group_i.hxx"
 
+#include "SMESH.hxx"
+
 #include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog)
 
 #include "utilities.h"
@@ -46,28 +48,6 @@ static int MYDEBUG = 0;
 static int MYDEBUG = 0;
 #endif
 
-// Tags definition ===========================================================
-// Top level
-long Tag_HypothesisRoot         = 1; // hypotheses root
-long Tag_AlgorithmsRoot         = 2; // algorithms root
-// Mesh/Submesh
-long Tag_RefOnShape             = 1; // references to shape
-long Tag_RefOnAppliedHypothesis = 2; // applied hypotheses root
-long Tag_RefOnAppliedAlgorithms = 3; // applied algorithms root
-// Mesh only
-long Tag_SubMeshOnVertex        = 4; // sub-meshes roots by type
-long Tag_SubMeshOnEdge          = 5; // ...
-long Tag_SubMeshOnWire          = 6; // ...
-long Tag_SubMeshOnFace          = 7; // ...
-long Tag_SubMeshOnShell         = 8; // ...
-long Tag_SubMeshOnSolid         = 9; // ...
-long Tag_SubMeshOnCompound      = 10; // ...
-long Tag_NodeGroups             = 11; // Group roots by type
-long Tag_EdgeGroups             = 12; // ...
-long Tag_FaceGroups             = 13; // ...
-long Tag_VolumeGroups           = 14; // ...
-// ===========================================================================
-
 //=============================================================================
 /*!
  *  Get...Tag [ static ]

src/SMESH_I/SMESH_MEDFamily_i.hxx

@@ -58,11 +58,11 @@ public :
 		    string name, string description, SALOME_MED::medEntityMesh entity );
   SMESH_MEDFamily_i(const SMESH_MEDFamily_i & f);
   
-        // IDL Methods
+  // IDL Methods
-        void setProtocol(SALOME::TypeOfCommunication typ) {}
+  void setProtocol(SALOME::TypeOfCommunication typ) {}
-        void release() {}
+  void release() {}
-        SALOME::Sender_ptr getSenderForNumber(long int) {return SALOME::Sender::_nil();}
+  SALOME::Sender_ptr getSenderForNumber(long int) {return SALOME::Sender::_nil();}
-        SALOME::Sender_ptr getSenderForNumberIndex() {return SALOME::Sender::_nil();}
+  SALOME::Sender_ptr getSenderForNumberIndex() {return SALOME::Sender::_nil();}
   
   CORBA::Long            getIdentifier()      
     throw (SALOME::SALOME_Exception);

src/SMESH_I/SMESH_MeshEditor_i.cxx

@@ -252,7 +252,7 @@ CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfEleme
 CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
 {
   SMESH::long_array_var anElementsId = theObject->GetIDs();
-  Reorient(anElementsId);
+  return Reorient(anElementsId);
 }
 
 //=============================================================================
@@ -298,7 +298,7 @@ CORBA::Boolean
 				       CORBA::Double               MaxAngle)
 {
   SMESH::long_array_var anElementsId = theObject->GetIDs();
-  TriToQuad(anElementsId, Criterion, MaxAngle);
+  return TriToQuad(anElementsId, Criterion, MaxAngle);
 }
 
 //=============================================================================
@@ -365,7 +365,7 @@ CORBA::Boolean
 				      CORBA::Boolean            Diag13)
 {
   SMESH::long_array_var anElementsId = theObject->GetIDs();
-  SplitQuad(anElementsId, Diag13);
+  return SplitQuad(anElementsId, Diag13);
 }
 
 //=============================================================================

src/SMESH_SWIG/Makefile.in

@@ -74,6 +74,12 @@ EXPORT_PYSCRIPTS = libSMESH_Swig.py \
 		   SMESH_controls.py \
 		   SMESH_freebord.py \
 		   SMESH_blocks.py \
+		   SMESH_BelongToGeom.py \
+		   SMESH_GroupFromGeom2.py \
+		   SMESH_box.py \
+		   SMESH_demo_hexa2_upd.py \
+		   SMESH_hexaedre.py \
+		   SMESH_Sphere.py \
 		   SMESH_GroupFromGeom.py
 
 LIB_CLIENT_IDL = SALOMEDS.idl \

src/SMESH_SWIG/SMESH_GroupFromGeom2.py

@@ -0,0 +1,53 @@
+#==============================================================================
+#  Info.
+#  Bug (from script, bug)   : SMESH_GroupFromGeom.py, PAL6945
+#  Modified                 : 25/11/2004
+#  Author                   : Kovaltchuk Alexey
+#  Project                  : PAL/SALOME
+#============================================================================== 
+from SMESH_test1 import *
+import SMESH
+
+# Compute the mesh created in SMESH_test1
+
+smesh.Compute(mesh, box)
+
+# Create geometry groups on plane:
+aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])
+geompy.AddObject(aGeomGroup1, 1)
+
+aGeomGroup2 = geompy.CreateGroup(face , geompy.ShapeType["EDGE"])
+
+geompy.AddObject(aGeomGroup2, 3)
+geompy.AddObject(aGeomGroup2, 6)
+geompy.AddObject(aGeomGroup2, 8)
+geompy.AddObject(aGeomGroup2, 10)
+
+geompy.addToStudy(aGeomGroup1, "Group on Faces")
+geompy.addToStudy(aGeomGroup2, "Group on Edges")
+
+aSmeshGroup1 = mesh.CreateGroupFromGEOM(SMESH.FACE, "SMESHGroup1", aGeomGroup1)
+aSmeshGroup2 = mesh.CreateGroupFromGEOM(SMESH.EDGE, "SMESHGroup2", aGeomGroup2)
+
+print "Create aGroupOnShell - a group linked to a shell"
+aGroupOnShell = mesh.CreateGroupFromGEOM(SMESH.EDGE, "GroupOnShell", shell)
+print "aGroupOnShell type =", aGroupOnShell.GetType()
+print "aGroupOnShell size =", aGroupOnShell.Size()
+print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()
+
+print " "
+
+print "Modify <LocalLength> hypothesis: 100 -> 50"
+hypLen1.SetLength(50)
+print "Contents of aGroupOnShell changes:"
+print "aGroupOnShell size =", aGroupOnShell.Size()
+print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()
+
+print " "
+
+print "Re-compute mesh, contents of aGroupOnShell changes again:"
+smesh.Compute(mesh, box)
+print "aGroupOnShell size =", aGroupOnShell.Size()
+print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()
+
+salome.sg.updateObjBrowser(1);

src/SMESH_SWIG/SMESH_Sphere.py

@@ -0,0 +1,107 @@
+#  GEOM GEOM_SWIG : binding of C++ omplementaion with Python
+#
+#  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+# 
+#  This library is free software; you can redistribute it and/or 
+#  modify it under the terms of the GNU Lesser General Public 
+#  License as published by the Free Software Foundation; either 
+#  version 2.1 of the License. 
+# 
+#  This library is distributed in the hope that it will be useful, 
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+#  Lesser General Public License for more details. 
+# 
+#  You should have received a copy of the GNU Lesser General Public 
+#  License along with this library; if not, write to the Free Software 
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+# 
+#  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+#
+#
+#
+#  File   : GEOM_Sphere.py
+#  Author : Damien COQUERET, Open CASCADE
+#  Module : GEOM
+#  $Header: 
+
+from geompy import *
+from math import *
+
+from meshpy import *
+
+# It is an example of creating a hexahedrical mesh on a sphere.
+#
+# Used approach allows to avoid problems with degenerated and
+# seam edges without special processing of geometrical shapes
+
+#-----------------------------------------------------------------------
+#Variables
+Radius  = 100.
+Dist    = Radius / 2.
+Factor  = 2.5
+Angle90 = pi / 2.
+NbSeg   = 10
+
+PointsList = []
+ShapesList = []
+
+#Basic Elements
+P0 = MakeVertex(0., 0., 0.)
+P1 = MakeVertex(-Dist, -Dist, -Dist)
+P2 = MakeVertex(-Dist, -Dist, Dist)
+P3 = MakeVertex(-Dist, Dist, Dist)
+P4 = MakeVertex(-Dist, Dist, -Dist)
+
+VZ = MakeVectorDXDYDZ(0., 0., 1.)
+
+#Construction Elements
+PointsList.append(P1)
+PointsList.append(P2)
+PointsList.append(P3)
+PointsList.append(P4)
+PointsList.append(P1)
+
+PolyLine = MakePolyline(PointsList)
+
+Face1 = MakeFace(PolyLine, 1)
+Face2 = MakeScaleTransform(Face1, P0, Factor)
+Face3 = MakeScaleTransform(Face1, P0, -1.)
+
+#Models
+Sphere = MakeSphereR(Radius)
+
+Block = MakeHexa2Faces(Face1, Face2)
+Cube  = MakeHexa2Faces(Face1, Face3)
+
+Common1 = MakeBoolean(Sphere, Block, 1)
+Common2 = MakeRotation(Common1, VZ, Angle90)
+
+MultiBlock1 = MakeMultiTransformation1D(Common1, 21, -1, 3)
+MultiBlock2 = MakeMultiTransformation1D(Common2, 31, -1, 3)
+
+#Reconstruct sphere from several blocks
+ShapesList.append(Cube)
+ShapesList.append(MultiBlock1)
+ShapesList.append(MultiBlock2)
+Compound = MakeCompound(ShapesList)
+
+Result = MakeGlueFaces(Compound, 0.1)
+
+#addToStudy
+Id_Sphere      = addToStudy(Sphere, "Sphere")
+Id_Cube        = addToStudy(Cube, "Cube")
+
+Id_Common1     = addToStudy(Common1, "Common1")
+Id_Common2     = addToStudy(Common2, "Common2")
+
+Id_MultiBlock1 = addToStudy(MultiBlock1, "MultiBlock1")
+Id_MultiBlock2 = addToStudy(MultiBlock2, "MultiBlock2")
+
+Id_Result      = addToStudy(Result, "Result")
+
+#-----------------------------------------------------------------------
+#Meshing
+my_hexa = MeshHexa(Result, NbSeg, "Sphere_Mesh")
+my_hexa.Compute()

src/SMESH_SWIG/SMESH_box.py

@@ -0,0 +1,73 @@
+#==============================================================================
+#  Info.
+#  Bug (from script, bug)   : box.py, PAL5223
+#  Modified                 : 25/11/2004
+#  Author                   : Kovaltchuk Alexey
+#  Project                  : PAL/SALOME
+#==============================================================================
+#
+# Salome geometry and meshing for a box
+#
+import salome
+from salome import sg
+import geompy
+
+import StdMeshers
+
+# ---- launch GEOM
+
+geom          = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
+meshgenerator = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
+
+###geom.GetCurrentStudy(salome.myStudy._get_StudyId())
+meshgenerator.SetCurrentStudy(salome.myStudy)
+
+# Plate
+
+box    = geompy.MakeBox(0.,0.,0.,1.,1.,1.)
+boxId  = geompy.addToStudy(box,"box")
+
+# ---- launch SMESH
+
+smeshgui = salome.ImportComponentGUI("SMESH")
+smeshgui.Init(salome.myStudyId)
+# meshgenerator=smeshpy.smeshpy()
+
+
+# Hypothesis
+
+hypL1=meshgenerator.CreateHypothesis("LocalLength","libStdMeshersEngine.so")
+hypL1.SetLength(0.25)
+hypL1Id = salome.ObjectToID(hypL1) 
+smeshgui.SetName(hypL1Id, "LocalLength")
+
+# Algorithm
+
+alg1D=meshgenerator.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
+alg1DId = salome.ObjectToID(alg1D) 
+smeshgui.SetName(alg1DId, "algo1D")
+
+alg2D=meshgenerator.CreateHypothesis("Quadrangle_2D", "libStdMeshersEngine.so")
+alg2DId = salome.ObjectToID(alg2D) 
+smeshgui.SetName(alg2DId, "algo2D")
+
+alg3D=meshgenerator.CreateHypothesis("Hexa_3D", "libStdMeshersEngine.so")
+alg3DId = salome.ObjectToID(alg3D) 
+smeshgui.SetName(alg3DId, "algo3D")
+ 
+# ---- init a Mesh
+
+box_mesh=meshgenerator.CreateMesh(box)
+box_meshId = salome.ObjectToID(box_mesh)
+smeshgui.SetName(box_meshId, "box_mesh")
+
+# ---- set Hypothesis & Algorithm
+
+box_mesh.AddHypothesis(box,alg1D)
+box_mesh.AddHypothesis(box,alg2D)
+box_mesh.AddHypothesis(box,alg3D)
+box_mesh.AddHypothesis(box,hypL1)
+
+meshgenerator.Compute(box_mesh,box)
+
+sg.updateObjBrowser(1)

src/SMESH_SWIG/SMESH_demo_hexa2_upd.py

@@ -0,0 +1,210 @@
+#==============================================================================
+#  Info.
+#  Bug (from script, bug)   : SMESH_demo_hexa2_upd.py, PAL6781
+#  Modified                 : 25/11/2004
+#  Author                   : Kovaltchuk Alexey
+#  Project                  : PAL/SALOME
+#==============================================================================
+# Tetrahedrization of a geometry (box minus a inner cylinder).
+# Hypothesis and algorithms for the mesh generation are not global:
+# the mesh of some edges is thinner
+#
+
+import salome
+import geompy
+
+import StdMeshers
+import NETGENPlugin
+
+geom  = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
+smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
+
+smeshgui = salome.ImportComponentGUI("SMESH")
+smeshgui.Init(salome.myStudyId);
+
+import math
+
+# -----------------------------------------------------------------------------
+
+ShapeTypeShell     = 3
+ShapeTypeFace      = 4
+ShapeTypeEdge      = 6
+
+a = math.sqrt(2.)/4.
+ma = - a
+zero = 0.
+un = 1.
+mun= - un
+demi = 1./2.
+
+Orig = geompy.MakeVertex(zero,zero,zero)
+P0 = geompy.MakeVertex(a,a,zero)
+P1 = geompy.MakeVertex(zero,demi,zero)
+P2 = geompy.MakeVertex(ma,a,zero)
+P3 = geompy.MakeVertex(mun,un,zero)
+P4 = geompy.MakeVertex(un,un,zero)
+P5 = geompy.MakeVertex(zero,zero,un)
+
+arc = geompy.MakeArc(P0,P1,P2)
+e1 = geompy.MakeEdge(P2,P3)
+e2 = geompy.MakeEdge(P3,P4)
+e3 = geompy.MakeEdge(P4,P0)
+
+list = []
+list.append(arc)
+list.append(e1)
+list.append(e2)
+list.append(e3)
+
+wire = geompy.MakeWire(list)
+face = geompy.MakeFace(wire,1)
+
+dir = geompy.MakeVector(Orig,P5)
+vol1 = geompy.MakePipe(face,dir)
+
+angle = math.pi/2.
+#dir = geom.MakeVector(Orig,P5)
+vol2 = geompy.MakeRotation(vol1,dir,angle)
+
+vol3 = geompy.MakeRotation(vol2,dir,angle)
+
+vol4 = geompy.MakeRotation(vol3,dir,angle)
+
+list = []
+list.append(vol1)
+list.append(vol2)
+list.append(vol3)
+list.append(vol4)
+
+volComp = geompy.MakeCompound(list)
+
+tol3d = 1.e-3
+vol = geompy.MakeGlueFaces(volComp,tol3d)
+idVol = geompy.addToStudy(vol,"volume")
+
+print "Analysis of the final volume:"
+subShellList = geompy.SubShapeAllSorted(vol,ShapeTypeShell)
+subFaceList = geompy.SubShapeAllSorted(vol,ShapeTypeFace)
+subEdgeList = geompy.SubShapeAllSorted(vol,ShapeTypeEdge)
+
+print "number of Shells in the volume : ",len(subShellList)
+print "number of Faces in the volume : ",len(subFaceList)
+print "number of Edges in the volume : ",len(subEdgeList)
+
+idSubEdge = []
+for k in range(len(subEdgeList)):
+    idSubEdge.append(geompy.addToStudyInFather(vol,subEdgeList[k],"SubEdge"+str(k)))
+
+edgeZ = []
+edgeZ.append(subEdgeList[0])
+edgeZ.append(subEdgeList[3])
+edgeZ.append(subEdgeList[10])
+edgeZ.append(subEdgeList[11])
+edgeZ.append(subEdgeList[20])
+edgeZ.append(subEdgeList[21])
+edgeZ.append(subEdgeList[28])
+edgeZ.append(subEdgeList[31])
+
+idEdgeZ = []
+for i in range(8):
+    idEdgeZ.append(geompy.addToStudyInFather(vol,edgeZ[i],"EdgeZ"+str(i+1)))
+
+### ---------------------------- SMESH --------------------------------------
+
+# ---- create Hypothesis
+
+print "-------------------------- create Hypothesis"
+
+print "-------------------------- NumberOfSegments the global one"
+
+numberOfSegments = 10
+
+hypNbSeg=smesh.CreateHypothesis("NumberOfSegments","libStdMeshersEngine.so")
+hypNbSeg.SetNumberOfSegments(numberOfSegments)
+hypNbSegID = hypNbSeg.GetId()
+print hypNbSeg.GetName()
+print hypNbSegID
+print hypNbSeg.GetNumberOfSegments()
+
+smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments")
+
+print "-------------------------- NumberOfSegments in the Z direction"
+
+numberOfSegmentsZ = 40
+
+hypNbSegZ=smesh.CreateHypothesis("NumberOfSegments","libStdMeshersEngine.so")
+hypNbSegZ.SetNumberOfSegments(numberOfSegmentsZ)
+hypNbSegZID = hypNbSegZ.GetId()
+print hypNbSegZ.GetName()
+print hypNbSegZID
+print hypNbSegZ.GetNumberOfSegments()
+
+smeshgui.SetName(salome.ObjectToID(hypNbSegZ), "NumberOfSegmentsZ")
+
+# ---- create Algorithms
+
+print "-------------------------- create Algorithms"
+
+print "-------------------------- Regular_1D"
+
+regular1D=smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
+smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")
+
+print "-------------------------- Quadrangle_2D"
+
+quad2D=smesh.CreateHypothesis("Quadrangle_2D", "libStdMeshersEngine.so")
+smeshgui.SetName(salome.ObjectToID(quad2D), "Quadrangle_2D")
+
+print "-------------------------- Hexa_3D"
+
+hexa3D=smesh.CreateHypothesis("Hexa_3D", "libStdMeshersEngine.so")
+smeshgui.SetName(salome.ObjectToID(hexa3D), "Hexa_3D")
+
+# ---- init a Mesh with the volume
+
+mesh = smesh.CreateMesh(vol)
+smeshgui.SetName(salome.ObjectToID(mesh), "meshVolume")
+
+# ---- add hypothesis to the volume
+
+print "-------------------------- add hypothesis to the volume"
+
+ret=mesh.AddHypothesis(vol,regular1D)
+print ret
+ret=mesh.AddHypothesis(vol,hypNbSeg)
+print ret
+ret=mesh.AddHypothesis(vol,quad2D)
+print ret
+ret=mesh.AddHypothesis(vol,hexa3D)
+print ret
+
+for i in range(8):
+    print "-------------------------- add hypothesis to edge in the Z directions", (i+1)
+
+    subMeshEdgeZ = mesh.GetSubMesh(edgeZ[i],"SubMeshEdgeZ_"+str(i+1))
+
+    retZ = mesh.AddHypothesis(edgeZ[i],hypNbSegZ)
+    print " add hyp Z ", retZ
+
+salome.sg.updateObjBrowser(1)
+
+print "-------------------------- compute the mesh of the volume"
+
+ret=smesh.Compute(mesh,vol)
+
+print ret
+if ret != 0:
+##    log=mesh.GetLog(0) # no erase trace
+##    for linelog in log:
+##        print linelog
+    print "Information about the MeshBox :"
+    print "Number of nodes       : ", mesh.NbNodes()
+    print "Number of edges       : ", mesh.NbEdges()
+    print "Number of faces       : ", mesh.NbFaces()
+    print "Number of triangles   : ", mesh.NbTriangles()
+    print "Number of volumes     : ", mesh.NbVolumes()
+    print "Number of tetrahedrons: ", mesh.NbTetras()
+else:
+    print "problem when Computing the mesh"
+
+salome.sg.updateObjBrowser(1)

src/SMESH_SWIG/SMESH_hexaedre.py

@@ -0,0 +1,148 @@
+#==============================================================================
+#  Info.
+#  Bug (from script, bug)   : hexaedre_modified.py, PAL6194, PAL7153
+#  Modified                 : 25/11/2004
+#  Author                   : Kovaltchuk Alexey
+#  Project                  : PAL/SALOME
+#==============================================================================
+
+import salome
+from salome import sg
+
+import geompy
+
+import math
+
+# -----------------------------------------------------------------------------
+
+geom = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
+myBuilder = salome.myStudy.NewBuilder()
+gg = salome.ImportComponentGUI("GEOM")
+from salome import sg
+
+ShapeTypeCompSolid = 1
+ShapeTypeSolid     = 2
+ShapeTypeShell     = 3
+ShapeTypeFace      = 4
+ShapeTypeWire      = 5
+ShapeTypeEdge      = 6
+ShapeTypeVertex    = 7
+
+Boolop_common = 1
+Boolop_cut = 2
+Boolop_fuse = 3
+Boolop_section = 4
+
+p0 = geompy.MakeVertex(0., 0., 0.)
+px = geompy.MakeVertex(100., 0., 0.)
+py = geompy.MakeVertex(0., 100., 0.)
+pz = geompy.MakeVertex(0., 0., 100.)
+vx = geompy.MakeVector(p0, px)
+vy = geompy.MakeVector(p0, py)
+vz = geompy.MakeVector(p0, pz)
+
+sphereExt = geompy.MakeSphere(    0.,  0.,  0., 400.)
+sphereInt = geompy.MakeSphere(    0.,-50.,  0., 350.)
+sphereA   = geompy.MakeSphere( -400., 50., 50., 400.)
+sphereB   = geompy.MakeSphere(  350.,-50.,-50., 350.)
+ptcyle    = geompy.MakeVertex(0., -300., -450.)
+cylindre  = geompy.MakeCylinder(ptcyle,vz,500.,900.)
+
+vol1=geompy.MakeCut(sphereExt,sphereA)
+vol2=geompy.MakeCut(vol1,sphereB)
+vol3=geompy.MakeCut(vol2,cylindre)
+blob=geompy.MakeCut(vol3,sphereInt)
+
+idblob = geompy.addToStudy(blob,"blob")
+
+aretes = []
+aretes = geompy.SubShapeAllSorted(blob, ShapeTypeEdge)
+eid=0
+
+# -------------------------------
+# --- numerotation des aretes
+##for edge in aretes:
+##    edname="arete%d"%eid
+##    idedge=geompy.addToStudy(edge,edname)
+##    eid=eid+1
+
+salome.sg.updateObjBrowser(1)
+
+# --- epaisseur 0 2 8 10
+# --- hauteur   1 3 9 11
+# --- largeur   4 5 6 7
+
+# -----------------------------------------------------------------------------
+
+print "-------------------------- mesh"
+
+import SMESH
+import StdMeshers
+smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
+smesh.SetCurrentStudy(salome.myStudy)
+
+# ---- create Hypothesis
+print "-------------------------- create Hypothesis"
+numberOfSegments = 4
+hypNbSegA=smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
+hypNbSegA.SetNumberOfSegments(numberOfSegments)
+numberOfSegments = 10
+hypNbSegB=smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
+hypNbSegB.SetNumberOfSegments(numberOfSegments)
+numberOfSegments = 15
+hypNbSegC=smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
+hypNbSegC.SetNumberOfSegments(numberOfSegments)
+
+# ---- create Algorithms
+print "-------------------------- create Algorithms"
+regular1D=smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
+quad2D=smesh.CreateHypothesis("Quadrangle_2D", "libStdMeshersEngine.so")
+hexa3D=smesh.CreateHypothesis("Hexa_3D", "libStdMeshersEngine.so")
+
+# ---- init a Mesh with the geom shape
+shape_mesh = blob
+myMesh=smesh.CreateMesh(shape_mesh)
+
+# ---- add hypothesis and algorithms to mesh
+print "-------------------------- add hypothesis to mesh"
+myMesh.AddHypothesis(shape_mesh,regular1D)
+myMesh.AddHypothesis(shape_mesh,quad2D)
+myMesh.AddHypothesis(shape_mesh,hexa3D)
+
+#myMesh.AddHypothesis(shape_mesh,hypNbSeg)
+
+myMesh.AddHypothesis(aretes[0],hypNbSegA)
+myMesh.AddHypothesis(aretes[2],hypNbSegA)
+myMesh.AddHypothesis(aretes[8],hypNbSegA)
+myMesh.AddHypothesis(aretes[10],hypNbSegA)
+
+myMesh.AddHypothesis(aretes[1],hypNbSegC)
+myMesh.AddHypothesis(aretes[3],hypNbSegC)
+myMesh.AddHypothesis(aretes[9],hypNbSegC)
+myMesh.AddHypothesis(aretes[11],hypNbSegC)
+
+myMesh.AddHypothesis(aretes[4],hypNbSegB)
+myMesh.AddHypothesis(aretes[5],hypNbSegB)
+myMesh.AddHypothesis(aretes[6],hypNbSegB)
+myMesh.AddHypothesis(aretes[7],hypNbSegB)
+
+# ---- compute mesh
+
+print "-------------------------- compute mesh"
+ret=smesh.Compute(myMesh, shape_mesh)
+print ret
+if ret != 0:
+    #log=myMesh.GetLog(0) # no erase trace
+    #for linelog in log:
+    #    print linelog
+    print "Information about the Mesh:"
+    print "Number of nodes       : ", myMesh.NbNodes()
+    print "Number of edges       : ", myMesh.NbEdges()
+    print "Number of faces       : ", myMesh.NbFaces()
+    print "Number of quadrangles : ", myMesh.NbQuadrangles()
+    print "Number of volumes     : ", myMesh.NbVolumes()
+    print "Number of hexahedrons : ", myMesh.NbHexas()
+else:
+    print "problem when Computing the mesh"
+
+salome.sg.updateObjBrowser(1)

src/SMESH_SWIG/meshpy.py

@@ -10,6 +10,8 @@ import salome
 
 import StdMeshers
 
+import SMESH
+
 # Variables
 # ---------
 
@@ -98,4 +100,27 @@ class MeshHexaImpl:
         smesh.Compute(self.mesh, self.piece)
         salome.sg.updateObjBrowser(1)
 
+    # Creates mesh group based on a geometric group
+    # --------------------
+
+    def Group(self, grp, name=""):
+        if name == "":
+            name = grp.GetName()
+        tgeo = geompy.GroupOp.GetType(grp)
+        if tgeo == geompy.ShapeType["VERTEX"]:
+            type = SMESH.NODE
+        elif tgeo == geompy.ShapeType["EDGE"]:
+            type = SMESH.EDGE
+        elif tgeo == geompy.ShapeType["FACE"]:
+            type = SMESH.FACE
+        elif tgeo == geompy.ShapeType["SOLID"]:
+            type = SMESH.VOLUME
+        return self.mesh.CreateGroupFromGEOM(type, name, grp)
+
+    # Export mesh in a MED file
+    # --------------------
+
+    def ExportMED(self, filename, groups=1):
+        self.mesh.ExportMED(filename, groups)
+
 MeshHexa = MeshHexaImpl

src/StdMeshers/Makefile.in

@@ -70,6 +70,7 @@ LIB_SRC = \
 	StdMeshers_Regular_1D.cxx \
 	StdMeshers_Quadrangle_2D.cxx \
 	StdMeshers_MEFISTO_2D.cxx \
+	StdMeshers_Penta_3D.cxx \
 	StdMeshers_Hexa_3D.cxx
 
 LIB_SERVER_IDL = 
@@ -82,8 +83,8 @@ BIN_SRC =
 
 # additionnal information to compil and link file
 CPPFLAGS+= $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
-CXXFLAGS+= $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome
+CXXFLAGS+= $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
 
-LDFLAGS+= -lSMESHimpl -lMEFISTO2D -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= -lSMESHimpl -lMEFISTO2D -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
 
 @CONCLUDE@

src/StdMeshers/StdMeshers_Hexa_3D.cxx

@@ -55,6 +55,11 @@ using namespace std;
 #include "utilities.h"
 #include "Utils_ExceptHandlers.hxx"
 
+//modified by NIZNHY-PKV Wed Nov 17 15:31:58 2004 f
+#include <StdMeshers_Penta_3D.hxx>
+
+static bool ComputePentahedralMesh(SMESH_Mesh & aMesh,	const TopoDS_Shape & aShape);
+//modified by NIZNHY-PKV Wed Nov 17 15:32:00 2004 t
 
 //=============================================================================
 /*!
@@ -155,15 +160,14 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
 {
   Unexpect aCatch(SalomeException);
 	MESSAGE("StdMeshers_Hexa_3D::Compute");
-
+	//bool isOk = false;
-	bool isOk = false;
 	SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
-	SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
+	//SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
 	//const SMESHDS_SubMesh *& subMeshDS = theSubMesh->GetSubMeshDS();
 
 	// 0.  - shape and face mesh verification
 	// 0.1 - shape must be a solid (or a shell) with 6 faces
-	//MESSAGE("---");
+	MESSAGE("---");
 
 	vector < SMESH_subMesh * >meshFaces;
 	for (TopExp_Explorer exp(aShape, TopAbs_FACE); exp.More(); exp.Next())
@@ -184,40 +188,56 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
 
 	for (int i = 0; i < 6; i++)
 	{
-		TopoDS_Shape aShape = meshFaces[i]->GetSubShape();
+	  TopoDS_Shape aFace = meshFaces[i]->GetSubShape();
-		SMESH_Algo *algo = _gen->GetAlgo(aMesh, aShape);
+	  SMESH_Algo *algo = _gen->GetAlgo(aMesh, aFace);
-		string algoName = algo->GetName();
+	  string algoName = algo->GetName();
-		if (algoName != "Quadrangle_2D")
+          bool isAllQuad = false;
-		{
+	  if (algoName == "Quadrangle_2D") {
-			// *** delete _quads
+            SMESHDS_SubMesh * sm = meshDS->MeshElements( aFace );
-			SCRUTE(algoName);
+            if ( sm ) {
-//			ASSERT(0);
+              isAllQuad = true;
-			return false;
+              SMDS_ElemIteratorPtr eIt = sm->GetElements();
-		}
+              while ( isAllQuad && eIt->more() )
-		StdMeshers_Quadrangle_2D *quadAlgo =
+                isAllQuad = ( eIt->next()->NbNodes() == 4 );
-			dynamic_cast < StdMeshers_Quadrangle_2D * >(algo);
+            }
-		ASSERT(quadAlgo);
+          }
-		try
+          if ( ! isAllQuad ) {
-		{
+	    //modified by NIZNHY-PKV Wed Nov 17 15:31:37 2004 f
-			_quads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aShape);
+            bool bIsOk;
-			// *** to delete after usage
+            //
-		}
+            bIsOk=ComputePentahedralMesh(aMesh, aShape);
-		catch(SALOME_Exception & S_ex)
+            if (bIsOk) {
-		{
+              return true;
-			// *** delete _quads
+            }
-			// *** throw exception
+	    //modified by NIZNHY-PKV Wed Nov 17 15:31:42 2004 t
-//			ASSERT(0);
+	    SCRUTE(algoName);
-                        return false;
+	    //			ASSERT(0);
-		}
+	    return false;
+	  }
+	  StdMeshers_Quadrangle_2D *quadAlgo =
+	    dynamic_cast < StdMeshers_Quadrangle_2D * >(algo);
+	  ASSERT(quadAlgo);
+	  try
+	    {
+	      _quads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aFace);
+	      // *** to delete after usage
+	    }
+	  catch(SALOME_Exception & S_ex)
+	    {
+	      // *** delete _quads
+	      // *** throw exception
+	      //			ASSERT(0);
+	      return false;
+	    }
 
-                // 0.2.1 - number of points on the opposite edges must be the same
+	  // 0.2.1 - number of points on the opposite edges must be the same
-                if (_quads[i]->nbPts[0] != _quads[i]->nbPts[2] ||
+	  if (_quads[i]->nbPts[0] != _quads[i]->nbPts[2] ||
-                    _quads[i]->nbPts[1] != _quads[i]->nbPts[3])
+	      _quads[i]->nbPts[1] != _quads[i]->nbPts[3])
-                {
+	    {
-                  MESSAGE("different number of points on the opposite edges of face " << i);
+	      MESSAGE("different number of points on the opposite edges of face " << i);
-//                  ASSERT(0);
+	      //                  ASSERT(0);
-                  return false;
+	      return false;
-                }
+	    }
 	}
 
 	// 1.  - identify faces and vertices of the "cube"
@@ -1023,3 +1043,35 @@ istream & operator >>(istream & load, StdMeshers_Hexa_3D & hyp)
 {
   return hyp.LoadFrom( load );
 }
+
+//modified by NIZNHY-PKV Wed Nov 17 15:34:13 2004 f
+///////////////////////////////////////////////////////////////////////////////
+//ZZ
+//#include <stdio.h>
+
+//=======================================================================
+//function : ComputePentahedralMesh
+//purpose  : 
+//=======================================================================
+bool ComputePentahedralMesh(SMESH_Mesh & aMesh,	const TopoDS_Shape & aShape)
+{
+  //printf(" ComputePentahedralMesh HERE\n");
+  //
+  bool bOK;
+  int iErr;
+  StdMeshers_Penta_3D anAlgo;
+  //
+  bOK=anAlgo.Compute(aMesh, aShape);
+  /*
+  iErr=anAlgo.ErrorStatus();
+  
+  if (iErr) {
+    printf("  *** Error# %d\n", iErr);
+  }
+  else {
+    printf("  *** No errors# %d\n", iErr);
+  }
+  */
+  return bOK;
+}
+

src/StdMeshers/StdMeshers_Penta_3D.hxx

@@ -0,0 +1,225 @@
+//  SMESH StdMeshers : implementaion of SMESH idl descriptions
+//
+//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
+// 
+//  This library is free software; you can redistribute it and/or 
+//  modify it under the terms of the GNU Lesser General Public 
+//  License as published by the Free Software Foundation; either 
+//  version 2.1 of the License. 
+// 
+//  This library is distributed in the hope that it will be useful, 
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of 
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+//  Lesser General Public License for more details. 
+// 
+//  You should have received a copy of the GNU Lesser General Public 
+//  License along with this library; if not, write to the Free Software 
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+// 
+//  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
+//
+//
+//
+//  File   : StdMeshers_Penta_3D.hxx
+//  Module : SMESH
+
+#ifndef StdMeshers_Penta_3D_HeaderFile
+#define StdMeshers_Penta_3D_HeaderFile
+
+#include <map>
+
+typedef std::map < int, int > StdMeshers_DataMapOfIntegerInteger;
+
+////////////////////////////////////////////////////////////////////////
+//
+//  class StdMeshers_SMESHBlock
+//
+#include <gp_Pnt.hxx>
+#include <gp_XYZ.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Shell.hxx>
+#include <TopTools_IndexedMapOfOrientedShape.hxx>
+
+#include "SMESH_Block.hxx"
+
+class StdMeshers_SMESHBlock {
+ 
+public:
+  //
+  StdMeshers_SMESHBlock();
+  
+  void Load (const TopoDS_Shell& theShell);
+  
+  void Load (const TopoDS_Shell& theShell,
+	     const TopoDS_Vertex& theV000,
+	     const TopoDS_Vertex& theV001);
+  
+  void ComputeParameters(const gp_Pnt& thePnt, 
+			 gp_XYZ& theXYZ);
+  
+  void ComputeParameters(const gp_Pnt& thePnt,
+			 const TopoDS_Shape& theShape,
+			 gp_XYZ& theXYZ);
+  
+  void Point(const gp_XYZ& theParams, 
+	     gp_Pnt& thePnt);
+  
+  void Point(const gp_XYZ& theParams,
+	     const TopoDS_Shape& theShape, 
+	     gp_Pnt& thePnt);
+  
+  int ShapeID(const TopoDS_Shape& theShape); 
+  
+  const TopoDS_Shape& Shape(const int theID);
+  
+  
+  int  ErrorStatus() const;
+
+
+protected:
+  TopoDS_Shell                       myShell;
+  TopTools_IndexedMapOfOrientedShape myShapeIDMap;
+  SMESH_Block                        myTBlock;
+  TopoDS_Shape                       myEmptyShape;
+  //
+  int myErrorStatus;
+};
+////////////////////////////////////////////////////////////////////////
+//
+//  class StdMeshers_TNode
+//
+#include "SMDS_MeshNode.hxx"
+
+class StdMeshers_TNode {
+
+public:
+  
+  StdMeshers_TNode(){
+    myNode=NULL;
+    myXYZ.SetCoord(99., 99., 99.);
+    myShapeSupportID=-1;
+    myBaseNodeID=-1;
+  }
+  
+  void SetNode(const SMDS_MeshNode* theNode) {
+    myNode=(SMDS_MeshNode*) theNode;
+  }
+  
+  const SMDS_MeshNode* Node()const {
+    return myNode;
+  }
+
+  void SetShapeSupportID (const int theID) {
+    myShapeSupportID=theID;
+  }
+  
+  int ShapeSupportID()const {
+    return myShapeSupportID;
+  }
+  
+  void SetNormCoord (const gp_XYZ& theXYZ) {
+    myXYZ=theXYZ;
+  }
+
+  const gp_XYZ& NormCoord ()const{
+    return myXYZ;
+  }
+  
+  void SetBaseNodeID (const int theID) {
+    myBaseNodeID=theID;
+  }
+  
+  int BaseNodeID ()const{
+    return myBaseNodeID;
+  }
+
+private:
+  SMDS_MeshNode* myNode;
+  int  myShapeSupportID;
+  gp_XYZ         myXYZ;
+  int            myBaseNodeID;
+};
+
+////////////////////////////////////////////////////////////////////////
+//
+//  class StdMeshers_Penta_3D
+//
+#include "SMESH_Mesh.hxx"
+#include <TopoDS_Shape.hxx>
+//
+class StdMeshers_Penta_3D {
+//
+  public: // methods
+    StdMeshers_Penta_3D();
+    
+    //~StdMeshers_Penta_3D();
+    
+    bool Compute(SMESH_Mesh& , const TopoDS_Shape& );
+    
+    int ErrorStatus() const {
+      return myErrorStatus;
+    }
+   
+    void SetTolerance(const double theTol3D) {
+      myTol3D=theTol3D;
+    }
+    
+    double Tolerance() const {
+      return myTol3D;
+    }
+    
+
+  protected: // methods
+    
+    void CheckData();
+    
+    void MakeBlock();
+
+    void MakeNodes();
+
+    void ShapeSupportID(const bool theIsUpperLayer,
+			const SMESH_Block::TShapeID theBNSSID,
+			SMESH_Block::TShapeID& theSSID);
+
+    void FindNodeOnShape(const TopoDS_Shape& aS,
+			 const gp_XYZ& aParams,
+			 StdMeshers_TNode& aTN);
+
+    void CreateNode(const bool theIsUpperLayer,
+		    const gp_XYZ& aParams,
+		    StdMeshers_TNode& aTN);
+
+    void ClearMeshOnFxy1();
+
+    void MakeMeshOnFxy1();
+
+    void MakeConnectingMap();
+
+    int GetIndexOnLayer(const int aID);
+
+    void MakeVolumeMesh();
+  
+    void SetMesh(SMESH_Mesh& theMesh) {
+      myMesh=(void *)&theMesh;
+    }
+    
+    SMESH_Mesh* GetMesh()const {
+      return (SMESH_Mesh*)myMesh;
+    }
+    
+  protected: // fields
+    TopoDS_Shape myShape;
+    StdMeshers_SMESHBlock myBlock;
+    void *       myMesh;
+    int          myErrorStatus;
+    //
+    vector <StdMeshers_TNode> myTNodes;
+    int myISize;
+    int myJSize;
+    double   myTol3D;        // Tolerance value     
+    StdMeshers_DataMapOfIntegerInteger myConnectingMap;
+
+};
+
+#endif

src/StdMeshers/StdMeshers_Regular_1D.cxx

@@ -38,7 +38,6 @@ using namespace std;
 #include "StdMeshers_Arithmetic1D.hxx"
 #include "StdMeshers_StartEndLength.hxx"
 #include "StdMeshers_Deflection1D.hxx"
-#include "StdMeshers_Propagation.hxx"
 
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
@@ -48,18 +47,13 @@ using namespace std;
 #include "utilities.h"
 
 #include <BRep_Tool.hxx>
-#include <BRepTools_WireExplorer.hxx>
-
 #include <TopoDS_Edge.hxx>
 #include <TopoDS_Shape.hxx>
-#include <TopTools_Array1OfShape.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
-
 #include <GeomAdaptor_Curve.hxx>
 #include <GCPnts_AbscissaPoint.hxx>
 #include <GCPnts_UniformAbscissa.hxx>
 #include <GCPnts_UniformDeflection.hxx>
-
 #include <Standard_ErrorHandler.hxx>
 #include <Precision.hxx>
 
@@ -476,127 +470,45 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh
 
 //=============================================================================
 /*!
- *  GetUsedHypothesis
+ *  See comments in SMESH_Algo.cxx
  */
 //=============================================================================
 
-const list <const SMESHDS_Hypothesis *> & StdMeshers_Regular_1D::GetUsedHypothesis
+const list <const SMESHDS_Hypothesis *> & StdMeshers_Regular_1D::GetUsedHypothesis(
-  (SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+	SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
 {
   _usedHypList.clear();
-  _usedHypList = GetAppliedHypothesis(aMesh, aShape); // copy
+  _usedHypList = GetAppliedHypothesis(aMesh, aShape);	// copy
   int nbHyp = _usedHypList.size();
-
+  if (nbHyp == 0)
-  // try to find being propagated hypothesis
+  {
-  string propName = StdMeshers_Propagation::GetName();
+    // Check, if propagated from some other edge
-  if (nbHyp == 0) {
+    TopoDS_Shape aMainEdge;
-    // Get all opposite edges
+    if (aShape.ShapeType() == TopAbs_EDGE &&
-    TopTools_ListOfShape anOppositeEdges;
+        aMesh.IsPropagatedHypothesis(aShape, aMainEdge))
-    TopoDS_Shape mainShape = aMesh.GetMeshDS()->ShapeToMesh();
+    {
-    GetOppositeEdges(mainShape, aShape, anOppositeEdges);
+      // Propagation of 1D hypothesis from <aMainEdge> on this edge
-    TopTools_ListIteratorOfListOfShape oppIt (anOppositeEdges);
+      _usedHypList = GetAppliedHypothesis(aMesh, aMainEdge);	// copy
-    for (; oppIt.More(); oppIt.Next()) {
+      nbHyp = _usedHypList.size();
-      const TopoDS_Shape& oppE = oppIt.Value();
-
-      // Find Propagation hypothesis on the opposite edge
-      if (IsPropagated(aMesh, oppE)) {
-
-        // Get hypothesis, used by the opposite edge
-        _usedHypList = SMESH_Algo::GetUsedHypothesis(aMesh, oppE);
-        nbHyp = _usedHypList.size();
-        if (nbHyp == 1)
-          break;
-      }
     }
   }
-
+  if (nbHyp == 0)
-  // try to find relevant 1D hypothesis on ancestors
+  {
-  if (nbHyp == 0) {
+    TopTools_ListIteratorOfListOfShape ancIt( aMesh.GetAncestors( aShape ));
-    TopTools_ListIteratorOfListOfShape ancIt (aMesh.GetAncestors(aShape));
+    for (; ancIt.More(); ancIt.Next())
-    for (; ancIt.More(); ancIt.Next()) {
+    {
       const TopoDS_Shape& ancestor = ancIt.Value();
-      _usedHypList = GetAppliedHypothesis(aMesh, ancestor); // copy
+      _usedHypList = GetAppliedHypothesis(aMesh, ancestor);	// copy
       nbHyp = _usedHypList.size();
       if (nbHyp == 1)
         break;
     }
   }
-
   if (nbHyp > 1)
-    _usedHypList.clear(); //only one compatible hypothesis allowed
+    _usedHypList.clear();	//only one compatible hypothesis allowed
   return _usedHypList;
 }
 
-//=============================================================================
-/*!
- *  Is Propagation hypothesis assigned to theShape or its ancestors
- */
-//=============================================================================
-Standard_Boolean StdMeshers_Regular_1D::IsPropagated (SMESH_Mesh         & theMesh,
-                                                      const TopoDS_Shape & theShape)
-{
-  const SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
-
-  // try to find Propagation hypothesis on theShape
-  const list<const SMESHDS_Hypothesis*> & listHyp = meshDS->GetHypothesis(theShape);
-
-  list<const SMESHDS_Hypothesis*>::const_iterator it = listHyp.begin();
-  for (; it != listHyp.end(); it++) {
-    const SMESHDS_Hypothesis *anHyp = *it;
-    if (anHyp->GetName() == StdMeshers_Propagation::GetName())
-      return Standard_True;
-  }
-
-  // try to find Propagation hypothesis on ancestors
-  TopTools_ListIteratorOfListOfShape ancIt (theMesh.GetAncestors(theShape));
-  for (; ancIt.More(); ancIt.Next()) {
-    const TopoDS_Shape& ancestor = ancIt.Value();
-    const list<const SMESHDS_Hypothesis*> & listAncHyp = meshDS->GetHypothesis(ancestor);
-
-    list<const SMESHDS_Hypothesis*>::const_iterator itAnc = listAncHyp.begin();
-    for (; itAnc != listAncHyp.end(); itAnc++) {
-      const SMESHDS_Hypothesis *anHyp = *itAnc;
-      if (anHyp->GetName() == StdMeshers_Propagation::GetName())
-        return Standard_True;
-    }
-  }
-
-  return Standard_False;
-}
-
-//=============================================================================
-/*!
- * GetOppositeEdges() - get all edges of theShape,
- * laying on any quadrangle face in front of theEdge
- */
-//=============================================================================
-void StdMeshers_Regular_1D::GetOppositeEdges (const TopoDS_Shape&   theShape,
-                                              const TopoDS_Shape&   theEdge,
-                                              TopTools_ListOfShape& theOppositeEdges) const
-{
-  TopExp_Explorer aWires (theShape, TopAbs_WIRE);
-  for (; aWires.More(); aWires.Next()) {
-    const TopoDS_Shape& aWire = aWires.Current();
-    BRepTools_WireExplorer aWE (TopoDS::Wire(aWire));
-    Standard_Integer nb = 1, found = 0;
-    TopTools_Array1OfShape anEdges (1,4);
-    for (; aWE.More(); aWE.Next(), nb++) {
-      if (nb > 4) {
-        found = 0;
-        break;
-      }
-      anEdges(nb) = aWE.Current();
-      if (anEdges(nb).IsSame(theEdge))
-        found = nb;
-    }
-    if (nb == 5 && found > 0) {
-      Standard_Integer opp = found + 2;
-      if (opp > 4) opp -= 4;
-      theOppositeEdges.Append(anEdges(opp));
-    }
-  }
-}
-
 //=============================================================================
 /*!
  *  

src/StdMeshers/StdMeshers_Regular_1D.hxx

@@ -32,9 +32,6 @@
 
 #include "SMESH_1D_Algo.hxx"
 
-#include <TopoDS_Shape.hxx>
-#include <TopTools_ListOfShape.hxx>
-
 class TopoDS_Edge;
 
 class StdMeshers_Regular_1D:
@@ -52,7 +49,7 @@ public:
 		       const TopoDS_Shape& aShape);
 
   virtual const std::list <const SMESHDS_Hypothesis *> &
-          GetUsedHypothesis (SMESH_Mesh & aMesh, const TopoDS_Shape & aShape);
+    GetUsedHypothesis(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape);
 
   ostream & SaveTo(ostream & save);
   istream & LoadFrom(istream & load);
@@ -61,13 +58,6 @@ public:
 
 protected:
 
-  Standard_Boolean IsPropagated (SMESH_Mesh         & theMesh,
-                                 const TopoDS_Shape & theShape);
-
-  void GetOppositeEdges (const TopoDS_Shape&   theShape,
-                         const TopoDS_Shape&   theEdge,
-                         TopTools_ListOfShape& theOppositeEdges) const;
-
   bool computeInternalParameters (const TopoDS_Edge&    theEdge,
                                   std::list< double > & theParameters ) const;