after KERNEL 64bits update. Compile failed

diff --git a/src/SMDS/SMDS_ElementFactory.cxx b/src/SMDS/SMDS_ElementFactory.cxx
index a90965fe5d5d3b72900426d0a186e59340249185..6aec2c078448aa0f8b85bdc58679db1ccd049d55 100644 (file)
--- a/src/SMDS/SMDS_ElementFactory.cxx
+++ b/src/SMDS/SMDS_ElementFactory.cxx
@@ -281,11 +281,11 @@ void SMDS_ElementFactory::Clear()
  */
 //================================================================================
 
-void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
+void SMDS_ElementFactory::Compact( std::vector<smIdType>& theVtkIDsNewToOld )
 {
-  int  newNbCells = NbUsedElements();
-  int   maxCellID = GetMaxID();
-  int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
+  smIdType  newNbCells = NbUsedElements();
+  smIdType   maxCellID = GetMaxID();
+  smIdType newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
 
   theVtkIDsNewToOld.resize( newNbCells );
 
@@ -377,16 +377,16 @@ SMDS_NodeFactory::~SMDS_NodeFactory()
  */
 //================================================================================
 
-void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
+void SMDS_NodeFactory::Compact( std::vector<smIdType>& theVtkIDsOldToNew )
 {
   // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes"
   // in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
   // theVtkIDsOldToNew[ old VtkID ] = new VtkID
 
-  int  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
-  int  newNbNodes = NbUsedElements();
-  int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
-  int   maxNodeID = GetMaxID();
+  smIdType  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
+  smIdType  newNbNodes = NbUsedElements();
+  smIdType newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
+  smIdType   maxNodeID = GetMaxID();
 
   theVtkIDsOldToNew.resize( oldNbNodes, -1 );
 
@@ -836,7 +836,7 @@ void SMDS_ElementChunk::Compact()
     }
     else if ( it != mySubIDRanges.mySet.rbegin() )
     {
-      int nbNodes = (it-1)->my1st;
+      smIdType nbNodes = (it-1)->my1st;
       myPositions.resize( nbNodes * 2 );
       std::vector<TParam> newPos( myPositions.begin(), myPositions.end() );
       myPositions.swap( newPos );

diff --git a/src/SMDS/SMDS_ElementFactory.hxx b/src/SMDS/SMDS_ElementFactory.hxx
index 01bae378a6b5fed6430ca6af0e4a9f67de93cd91..10943108461255d8785e3ee3cd50027127be4564 100644 (file)
--- a/src/SMDS/SMDS_ElementFactory.hxx
+++ b/src/SMDS/SMDS_ElementFactory.hxx
@@ -128,7 +128,7 @@ public:
 
   //! Remove unused elements located not at the end of the last chunk.
   //  Minimize allocated memory
-  virtual void Compact(std::vector<int>& idCellsOldToNew);
+  virtual void Compact(std::vector<smIdType>& idCellsOldToNew);
 
   //! Return true if Compact() will change IDs of elements
   virtual bool CompactChangePointers();
@@ -170,7 +170,7 @@ public:
 
   //! Remove unused nodes located not at the end of the last chunk.
   //  Minimize allocated memory
-  virtual void Compact(std::vector<int>& idNodesOldToNew);
+  virtual void Compact(std::vector<smIdType>& idNodesOldToNew);
 
   //! Return true if Compact() will change IDs of node
   virtual bool CompactChangePointers();

diff --git a/src/SMDS/SMDS_ElementHolder.cxx b/src/SMDS/SMDS_ElementHolder.cxx
index 50486ee782b6495e6cdcc59ffea9584717c0c0c2..4fb3145cf1dded45af7b33a261e2b159911ab66e 100644 (file)
--- a/src/SMDS/SMDS_ElementHolder.cxx
+++ b/src/SMDS/SMDS_ElementHolder.cxx
@@ -84,8 +84,8 @@ void SMDS_ElementHolder::beforeCompacting()
 //purpose  : restore pointers to elements
 //=======================================================================
 
-void SMDS_ElementHolder::restoreElements( const std::vector<int>& idNodesOldToNew,
-                                          const std::vector<int>& idCellsOldToNew )
+void SMDS_ElementHolder::restoreElements( const std::vector<smIdType>& idNodesOldToNew,
+                                          const std::vector<smIdType>& idCellsOldToNew )
 {
   tmpClear();
 

diff --git a/src/SMDS/SMDS_ElementHolder.hxx b/src/SMDS/SMDS_ElementHolder.hxx
index d644b2f2da6143bf2f87ced06e5d247d1929cbb4..5481e3ca45ae3c8450c6f2874ea67e2a4760343d 100644 (file)
--- a/src/SMDS/SMDS_ElementHolder.hxx
+++ b/src/SMDS/SMDS_ElementHolder.hxx
@@ -29,6 +29,8 @@
 
 #include "SMDS_ElemIterator.hxx"
 
+#include <smIdType.hxx>
+
 #include <vector>
 #include <set>
 
@@ -80,8 +82,8 @@ class SMDS_EXPORT SMDS_ElementHolder
   void beforeCompacting();
 
   //! restore pointers to elements
-  void restoreElements( const std::vector<int>& idNodessOldToNew,
-                        const std::vector<int>& idCellsOldToNew );
+  void restoreElements( const std::vector<smIdType>& idNodessOldToNew,
+                        const std::vector<smIdType>& idCellsOldToNew );
 
 
   std::vector<const SMDS_MeshElement*>      myExternalElems; //!< elements not contained in the mesh

diff --git a/src/SMDS/SMDS_Mesh.hxx b/src/SMDS/SMDS_Mesh.hxx
index c14ffa264e294c959e0980330383a434fc55c1c9..88086debf109c4843458c028e9319e198b5f8b56 100644 (file)
--- a/src/SMDS/SMDS_Mesh.hxx
+++ b/src/SMDS/SMDS_Mesh.hxx
@@ -633,7 +633,7 @@ public:
   }
 
   const SMDS_MeshNode *FindNode(smIdType idnode) const;
-  const SMDS_MeshNode *FindNodeVtk(smIdType idnode) const;
+  const SMDS_MeshNode *FindNodeVtk(int idnode) const;
   const SMDS_MeshElement *FindElementVtk(int IDelem) const;
   virtual const SMDS_MeshElement * FindElement(int IDelem) const;
   static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);

diff --git a/src/SMDS/SMDS_MeshElement.cxx b/src/SMDS/SMDS_MeshElement.cxx
index ee03cf25aacb730d8e0c72d4fd424331e722071a..a6a398884d6c7bf942fa294b3c43f99726049048 100644 (file)
--- a/src/SMDS/SMDS_MeshElement.cxx
+++ b/src/SMDS/SMDS_MeshElement.cxx
@@ -105,7 +105,7 @@ int SMDS_MeshElement::GetNodeIndex( const SMDS_MeshNode* node ) const
  */
 //================================================================================
 
-int SMDS_MeshElement::GetID() const
+smIdType SMDS_MeshElement::GetID() const
 {
   return myHolder ? myHolder->GetID( this ) : -1;
 }
@@ -127,7 +127,7 @@ void SMDS_MeshElement::setShapeID( const int shapeID ) const
  */
 //================================================================================
 
-int SMDS_MeshElement::GetShapeID() const
+smIdType SMDS_MeshElement::GetShapeID() const
 {
   return myHolder->GetShapeID( this );
 }

diff --git a/src/SMDS/SMDS_MeshElement.hxx b/src/SMDS/SMDS_MeshElement.hxx
index d22d34181455e397164f84a72b055c230e74cf17..de545ea1c5b548a026a9d8121f515f8de0484f0c 100644 (file)
--- a/src/SMDS/SMDS_MeshElement.hxx
+++ b/src/SMDS/SMDS_MeshElement.hxx
@@ -38,6 +38,7 @@
 
 #include <vtkType.h>
 #include <vtkCellType.h>
+#include <smIdType.hxx>
 
 class SMDS_ElementChunk;
 class SMDS_Mesh;
@@ -127,10 +128,10 @@ public:
   virtual int GetNodeIndex( const SMDS_MeshNode* node ) const;
 
 
-  virtual int GetID() const;
+  virtual smIdType GetID() const;
   virtual int GetVtkID()   const;
   virtual int getshapeId() const { return GetShapeID(); }
-  virtual int GetShapeID() const;
+  virtual smIdType GetShapeID() const;
 
   // mark this element; to be used in algos
   virtual void setIsMarked( bool is ) const;

diff --git a/src/SMDS/SMDS_MeshInfo.hxx b/src/SMDS/SMDS_MeshInfo.hxx
index b37232ae11e7c20226f7591cf1e6a1a8d90e4794..556e33746b924b621c294fde36dd367a5d6c3629 100644 (file)
--- a/src/SMDS/SMDS_MeshInfo.hxx
+++ b/src/SMDS/SMDS_MeshInfo.hxx
@@ -102,7 +102,7 @@ private:
   smIdType myNbHexPrism;
   smIdType myNbPolyhedrons;
 
-  std::vector<int*> myNb; // pointers to myNb... fields
+  std::vector<smIdType*> myNb; // pointers to myNb... fields
   std::vector<int>  myShift; // shift to get an index in myNb by elem->NbNodes()
 };
 
@@ -407,7 +407,7 @@ SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
 }
 
 inline void // setNb
-SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
+SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const smIdType nb)
 {
   switch (geomType) {
   case SMDSEntity_Node:             myNbNodes             = nb; break;

diff --git a/src/SMDS/SMDS_UnstructuredGrid.cxx b/src/SMDS/SMDS_UnstructuredGrid.cxx
index 8da9a287b7bfddfa3f729a115878185815f71c70..2d134daca225d933875c65342fdadee2b1071f50 100644 (file)
--- a/src/SMDS/SMDS_UnstructuredGrid.cxx
+++ b/src/SMDS/SMDS_UnstructuredGrid.cxx
@@ -175,8 +175,8 @@ void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh)
   _mesh = mesh;
 }
 
-void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize,
-                                        std::vector<int>& idCellsNewToOld, int newCellSize)
+void SMDS_UnstructuredGrid::compactGrid(std::vector<smIdType>& idNodesOldToNew, smIdType newNodeSize,
+                                        std::vector<smIdType>& idCellsNewToOld, smIdType newCellSize)
 {
   this->DeleteLinks();
 
@@ -336,7 +336,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
 }
 
 void SMDS_UnstructuredGrid::copyNodes(vtkPoints *       newPoints,
-                                      std::vector<int>& /*idNodesOldToNew*/,
+                                      std::vector<smIdType>& /*idNodesOldToNew*/,
                                       int&              alreadyCopied,
                                       int               start,
                                       int               end)
@@ -352,8 +352,8 @@ void SMDS_UnstructuredGrid::copyNodes(vtkPoints *       newPoints,
 }
 
 void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *  newTypes,
-                                     const std::vector<int>& idCellsNewToOld,
-                                     const std::vector<int>& idNodesOldToNew,
+                                     const std::vector<smIdType>& idCellsNewToOld,
+                                     const std::vector<smIdType>& idNodesOldToNew,
                                      vtkCellArray*           newConnectivity,
                                      vtkIdTypeArray*         newLocations,
                                      std::vector<vtkIdType>& pointsCell)

diff --git a/src/SMDS/SMDS_UnstructuredGrid.hxx b/src/SMDS/SMDS_UnstructuredGrid.hxx
index e7ed86930eff89f429f374491584b97be0921e43..3c9b9b50719adcca7b53455ba9f0841913aabc8c 100644 (file)
--- a/src/SMDS/SMDS_UnstructuredGrid.hxx
+++ b/src/SMDS/SMDS_UnstructuredGrid.hxx
@@ -28,6 +28,7 @@
 
 #include <vtkUnstructuredGrid.h>
 #include <vtkCellLinks.h>
+#include <smIdType.hxx>
 
 #include <vector>
 #include <set>
@@ -73,10 +74,10 @@ class SMDS_EXPORT SMDS_UnstructuredGrid: public vtkUnstructuredGrid
 {
 public:
   void setSMDS_mesh(SMDS_Mesh *mesh);
-  void compactGrid(std::vector<int>& idNodesOldToNew,
-                   int               newNodeSize,
-                   std::vector<int>& idCellsOldToNew,
-                   int               newCellSize);
+  void compactGrid(std::vector<smIdType>& idNodesOldToNew,
+                   smIdType               newNodeSize,
+                   std::vector<smIdType>& idCellsOldToNew,
+                   smIdType               newCellSize);
   virtual vtkMTimeType GetMTime();
   virtual vtkPoints *GetPoints();
 
@@ -115,10 +116,10 @@ public:
 protected:
   SMDS_UnstructuredGrid();
   ~SMDS_UnstructuredGrid();
-  void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end);
+  void copyNodes(vtkPoints *newPoints, std::vector<smIdType>& idNodesOldToNew, int& alreadyCopied, int start, int end);
   void copyBloc(vtkUnsignedCharArray *newTypes,
-                const std::vector<int>& idCellsOldToNew,
-                const std::vector<int>& idNodesOldToNew,
+                const std::vector<smIdType>& idCellsOldToNew,
+                const std::vector<smIdType>& idNodesOldToNew,
                 vtkCellArray* newConnectivity,
                 vtkIdTypeArray* newLocations,
                 std::vector<vtkIdType>& pointsCell);

diff --git a/src/SMESHDS/SMESHDS_Mesh.cxx b/src/SMESHDS/SMESHDS_Mesh.cxx
index e7429e5a25cb28fa086b6477eca1931fc94b2f18..922d5234fc97e6739aeaed85838e9eddd1b89e42 100644 (file)
--- a/src/SMESHDS/SMESHDS_Mesh.cxx
+++ b/src/SMESHDS/SMESHDS_Mesh.cxx
@@ -194,7 +194,7 @@ SMDS_MeshNode* SMESHDS_Mesh::AddNode(double x, double y, double z){
   return node;
 }
 
-SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, int ID){
+SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, smIdType ID){
   SMDS_MeshNode* node = SMDS_Mesh::AddNodeWithID(x,y,z,ID);
   if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
   return node;
@@ -218,7 +218,7 @@ void SMESHDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z
 
 bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
                                       const SMDS_MeshNode    * nodes[],
-                                      const int                nbnodes)
+                                      const smIdType                nbnodes)
 {
   if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
     return false;
@@ -286,7 +286,7 @@ void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, cons
 //function : Add0DElement
 //purpose  :
 //=======================================================================
-SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
+SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(smIdType nodeID, smIdType ID)
 {
   SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID);
   if (anElem) myScript->Add0DElement(ID, nodeID);
@@ -294,7 +294,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
 }
 
 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID
-(const SMDS_MeshNode * node, int ID)
+(const SMDS_MeshNode * node, smIdType ID)
 {
   return Add0DElementWithID(node->GetID(), ID);
 }
@@ -311,7 +311,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
 //purpose  : 
 //=======================================================================
 
-SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
+SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(smIdType node, double diameter, smIdType ID)
 {
   SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
   if (anElem) myScript->AddBall(anElem->GetID(), node, diameter);
@@ -320,7 +320,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
 
 SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node,
                                               double                diameter,
-                                              int                   ID)
+                                              smIdType                   ID)
 {
   SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
   if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
@@ -340,7 +340,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBall (const SMDS_MeshNode * node,
 //purpose  : 
 //=======================================================================
 
-SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
+SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID)
 {
   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID);
   if(anElem) myScript->AddEdge(ID,n1,n2);
@@ -349,7 +349,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
 
 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddEdgeWithID(n1->GetID(),
                        n2->GetID(),
@@ -370,7 +370,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode * n1,
 //function :AddFace
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3);
@@ -380,7 +380,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(),
                        n2->GetID(),
@@ -404,7 +404,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
 //function :AddFace
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID);
   if(anElem) myScript->AddFace(ID, n1, n2, n3, n4);
@@ -415,7 +415,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
                                            const SMDS_MeshNode * n4, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(),
                        n2->GetID(),
@@ -442,7 +442,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 //function :AddVolume
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4);
@@ -453,7 +453,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4, 
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), 
                          n2->GetID(), 
@@ -480,7 +480,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function :AddVolume
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5);
@@ -492,7 +492,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
                                                const SMDS_MeshNode * n5, 
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), 
                          n2->GetID(), 
@@ -522,7 +522,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function :AddVolume
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID)
 {
   SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6);
@@ -535,7 +535,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n4,
                                                const SMDS_MeshNode * n5,
                                                const SMDS_MeshNode * n6, 
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), 
                          n2->GetID(), 
@@ -568,7 +568,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function :AddVolume
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID)
 {
   SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8);
@@ -583,7 +583,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n6,
                                                const SMDS_MeshNode * n7,
                                                const SMDS_MeshNode * n8, 
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), 
                          n2->GetID(), 
@@ -623,10 +623,10 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function :AddVolume
 //purpose  : add hexagonal prism
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n5, int n6, int n7, int n8,
-                                               int n9, int n10, int n11, int n12,
-                                               int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                               smIdType n9, smIdType n10, smIdType n11, smIdType n12,
+                                               smIdType ID)
 {
   SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
@@ -645,7 +645,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n10, 
                                                const SMDS_MeshNode * n11, 
                                                const SMDS_MeshNode * n12, 
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), 
                          n2->GetID(),
@@ -697,8 +697,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function : AddPolygonalFace
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
-                                                     const int               ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
+                                                     const smIdType               ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
   if (anElem) {
@@ -709,12 +709,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nod
 
 SMDS_MeshFace*
 SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
-                                      const int                                ID)
+                                      const smIdType                                ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -728,8 +728,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -743,8 +743,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
 //function : AddQuadPolygonalFace
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>& nodes_ids,
-                                                         const int               ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
+                                                         const smIdType               ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes_ids, ID);
   if (anElem) {
@@ -755,12 +755,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>&
 
 SMDS_MeshFace*
 SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
-                                          const int                                ID)
+                                          const smIdType                                ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -774,8 +774,8 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFace(nodes);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -789,9 +789,9 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
 //function : AddPolyhedralVolume
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids,
-                                                          const std::vector<int>& quantities,
-                                                          const int               ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType>& nodes_ids,
+                                                          const std::vector<smIdType>& quantities,
+                                                          const smIdType               ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
   if (anElem) {
@@ -803,12 +803,12 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>
 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
 (const std::vector<const SMDS_MeshNode*>& nodes,
  const std::vector<int>&                  quantities,
- const int                                ID)
+ const smIdType                                ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -823,8 +823,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -1489,7 +1489,7 @@ SMESHDS_Mesh::~SMESHDS_Mesh()
 //function : AddEdgeWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID) 
+SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID) 
 {
   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
   if(anElem) myScript->AddEdge(ID,n1,n2,n12);
@@ -1519,7 +1519,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2, 
                                            const SMDS_MeshNode * n12, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddEdgeWithID(n1->GetID(),
                        n2->GetID(),
@@ -1550,8 +1550,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 //function : AddFaceWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
-                                           int n12,int n23,int n31, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
+                                           smIdType n12,smIdType n23,smIdType n31, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
@@ -1568,7 +1568,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n12,
                                            const SMDS_MeshNode * n23,
                                            const SMDS_MeshNode * n31, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                        n12->GetID(), n23->GetID(), n31->GetID(),
@@ -1599,8 +1599,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 //function : AddFaceWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
-                                           int n12,int n23,int n31, int nCenter, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
+                                           smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
@@ -1618,7 +1618,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n23,
                                            const SMDS_MeshNode * n31, 
                                            const SMDS_MeshNode * nCenter, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                        n12->GetID(), n23->GetID(), n31->GetID(),
@@ -1650,8 +1650,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 //function : AddFaceWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
-                                           int n12,int n23,int n34,int n41, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
@@ -1670,7 +1670,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n23,
                                            const SMDS_MeshNode * n34, 
                                            const SMDS_MeshNode * n41, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@@ -1704,9 +1704,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 //function : AddFaceWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
-                                           int n12,int n23,int n34,int n41,
-                                           int nCenter, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                           smIdType nCenter, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
@@ -1726,7 +1726,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n34, 
                                            const SMDS_MeshNode * n41, 
                                            const SMDS_MeshNode * nCenter, 
-                                           int ID)
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@@ -1761,9 +1761,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function : AddVolumeWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n12,int n23,int n31,
-                                               int n14,int n24,int n34, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n12,smIdType n23,smIdType n31,
+                                               smIdType n14,smIdType n24,smIdType n34, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
                                                        n31,n14,n24,n34,ID);
@@ -1785,7 +1785,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n14, 
                                                const SMDS_MeshNode * n24,
                                                const SMDS_MeshNode * n34,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                          n12->GetID(), n23->GetID(), n31->GetID(),
@@ -1825,9 +1825,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function : AddVolumeWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
-                                               int n12,int n23,int n34,int n41,
-                                               int n15,int n25,int n35,int n45, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
+                                               smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                               smIdType n15,smIdType n25,smIdType n35,smIdType n45, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
                                                        n12,n23,n34,n41,
@@ -1854,7 +1854,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n25,
                                                const SMDS_MeshNode * n35,
                                                const SMDS_MeshNode * n45,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                          n4->GetID(), n5->GetID(),
@@ -1899,11 +1899,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function : AddVolumeWithID
 //purpose  : 2nd order pentahedron (prism) with 15 nodes
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
-                                               int n4, int n5, int n6,
-                                               int n12,int n23,int n31,
-                                               int n45,int n56,int n64,
-                                               int n14,int n25,int n36, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
+                                               smIdType n4, smIdType n5, smIdType n6,
+                                               smIdType n12,smIdType n23,smIdType n31,
+                                               smIdType n45,smIdType n56,smIdType n64,
+                                               smIdType n14,smIdType n25,smIdType n36, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
                                                        n12,n23,n31,
@@ -1933,7 +1933,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n14,
                                                const SMDS_MeshNode * n25,
                                                const SMDS_MeshNode * n36,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                          n4->GetID(), n5->GetID(), n6->GetID(),
@@ -1982,13 +1982,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function : AddVolumeWithID
 //purpose  : 2nd order pentahedron (prism) with 18 nodes
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
-                                               int n4, int n5, int n6,
-                                               int n12,int n23,int n31,
-                                               int n45,int n56,int n64,
-                                               int n14,int n25,int n36,
-                                               int n1245, int n2356, int n1346,
-                                               int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
+                                               smIdType n4, smIdType n5, smIdType n6,
+                                               smIdType n12,smIdType n23,smIdType n31,
+                                               smIdType n45,smIdType n56,smIdType n64,
+                                               smIdType n14,smIdType n25,smIdType n36,
+                                               smIdType n1245, smIdType n2356, smIdType n1346,
+                                               smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
                                                        n12,n23,n31,
@@ -2022,7 +2022,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n1245,
                                                const SMDS_MeshNode * n2356,
                                                const SMDS_MeshNode * n1346,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                          n4->GetID(), n5->GetID(), n6->GetID(),
@@ -2076,11 +2076,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function : AddVolumeWithID
 //purpose  : 
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n5, int n6, int n7, int n8,
-                                               int n12,int n23,int n34,int n41,
-                                               int n56,int n67,int n78,int n85,
-                                               int n15,int n26,int n37,int n48, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                               smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                               smIdType n56,smIdType n67,smIdType n78,smIdType n85,
+                                               smIdType n15,smIdType n26,smIdType n37,smIdType n48, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
                                                        n12,n23,n34,n41,
@@ -2115,7 +2115,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n26,
                                                const SMDS_MeshNode * n37,
                                                const SMDS_MeshNode * n48,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
@@ -2175,14 +2175,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
   return anElem;
 }
 
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n5, int n6, int n7, int n8,
-                                               int n12,int n23,int n34,int n41,
-                                               int n56,int n67,int n78,int n85,
-                                               int n15,int n26,int n37,int n48,
-                                               int n1234,int n1256,int n2367,int n3478,
-                                               int n1458,int n5678,int nCenter,
-                                               int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                               smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                               smIdType n56,smIdType n67,smIdType n78,smIdType n85,
+                                               smIdType n15,smIdType n26,smIdType n37,smIdType n48,
+                                               smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
+                                               smIdType n1458,smIdType n5678,smIdType nCenter,
+                                               smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
                                                        n12,n23,n34,n41,
@@ -2225,7 +2225,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n1458,
                                                const SMDS_MeshNode * n5678,
                                                const SMDS_MeshNode * nCenter,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),

diff --git a/src/SMESHDS/SMESHDS_Mesh.hxx b/src/SMESHDS/SMESHDS_Mesh.hxx
index cc31bda83c0752d4fc7a9d91d916cf285f570c8b..c8b35400ee922914772b95c3d825edf41544ec6d 100644 (file)
--- a/src/SMESHDS/SMESHDS_Mesh.hxx
+++ b/src/SMESHDS/SMESHDS_Mesh.hxx
@@ -77,64 +77,64 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
   bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
   bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
   
-  virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
+  virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);
   virtual SMDS_MeshNode* AddNode(double x, double y, double z);
   
-  virtual SMDS_Mesh0DElement* Add0DElementWithID(int nodeID, int ID);
-  virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, int ID);
+  virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType nodeID, smIdType ID);
+  virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, smIdType ID);
   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * node);
   
-  virtual SMDS_BallElement* AddBallWithID(int n,                   double diameter, int ID);
-  virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID);
+  virtual SMDS_BallElement* AddBallWithID(smIdType n,                   double diameter, smIdType ID);
+  virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);
   virtual SMDS_BallElement* AddBall      (const SMDS_MeshNode * n, double diameter);
 
-  virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
+  virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);
   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2);
   
   // 2d order edge with 3 nodes: n12 - node between n1 and n2
-  virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
+  virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);
   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2, 
                                        const SMDS_MeshNode * n12, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n12);
   // tria 3
-  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2,
                                        const SMDS_MeshNode * n3, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n3);
   // quad 4
-  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2,
                                        const SMDS_MeshNode * n3,
                                        const SMDS_MeshNode * n4, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n3,
                                  const SMDS_MeshNode * n4);
 
   // 2d order triangle of 6 nodes
-  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
-                                       int n12,int n23,int n31, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
+                                       smIdType n12,smIdType n23,smIdType n31, smIdType ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2,
                                        const SMDS_MeshNode * n3, 
                                        const SMDS_MeshNode * n12,
                                        const SMDS_MeshNode * n23,
                                        const SMDS_MeshNode * n31, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n3,
@@ -143,8 +143,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                  const SMDS_MeshNode * n31);
 
   // biquadratic triangle of 7 nodes
-  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
-                                       int n12,int n23,int n31, int nCenter, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
+                                       smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2,
                                        const SMDS_MeshNode * n3, 
@@ -152,7 +152,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                        const SMDS_MeshNode * n23,
                                        const SMDS_MeshNode * n31,
                                        const SMDS_MeshNode * nCenter, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n3,
@@ -162,8 +162,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                  const SMDS_MeshNode * nCenter);
 
   // 2d order quadrangle
-  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
-                                       int n12,int n23,int n34,int n41, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                       smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2,
                                        const SMDS_MeshNode * n3,
@@ -172,7 +172,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                        const SMDS_MeshNode * n23,
                                        const SMDS_MeshNode * n34,
                                        const SMDS_MeshNode * n41, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n3,
@@ -183,8 +183,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                  const SMDS_MeshNode * n41);
 
   // biquadratic quadrangle of 9 nodes
-  virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
-                                       int n12,int n23,int n34,int n41, int nCenter, int ID);
+  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                       smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
                                        const SMDS_MeshNode * n2,
                                        const SMDS_MeshNode * n3,
@@ -194,7 +194,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                        const SMDS_MeshNode * n34,
                                        const SMDS_MeshNode * n41, 
                                        const SMDS_MeshNode * nCenter, 
-                                       int ID);
+                                       smIdType ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n3,
@@ -205,38 +205,38 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                  const SMDS_MeshNode * n41,
                                  const SMDS_MeshNode * nCenter);
   // tetra 4
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
                                            const SMDS_MeshNode * n4, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
                                      const SMDS_MeshNode * n4);
   // pyra 5
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
                                            const SMDS_MeshNode * n4,
                                            const SMDS_MeshNode * n5, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
                                      const SMDS_MeshNode * n4,
                                      const SMDS_MeshNode * n5);
   // penta 6
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
                                            const SMDS_MeshNode * n4,
                                            const SMDS_MeshNode * n5,
                                            const SMDS_MeshNode * n6, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -244,7 +244,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n5,
                                      const SMDS_MeshNode * n6);
   // hexa 8
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -253,7 +253,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n6,
                                            const SMDS_MeshNode * n7,
                                            const SMDS_MeshNode * n8, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -263,8 +263,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n7,
                                      const SMDS_MeshNode * n8);
   // hexagonal prism of 12 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
-                                           int n7, int n8, int n9, int n10, int n11, int n12, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,
+                                           smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12, smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -277,7 +277,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n10, 
                                            const SMDS_MeshNode * n11, 
                                            const SMDS_MeshNode * n12, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -292,9 +292,9 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n12);
 
   // 2d order tetrahedron of 10 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                           int n12,int n23,int n31,
-                                           int n14,int n24,int n34, int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n12,smIdType n23,smIdType n31,
+                                           smIdType n14,smIdType n24,smIdType n34, smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -305,7 +305,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n14, 
                                            const SMDS_MeshNode * n24,
                                            const SMDS_MeshNode * n34, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -318,10 +318,10 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n34);
 
   // 2d order pyramid of 13 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
-                                           int n12,int n23,int n34,int n41,
-                                           int n15,int n25,int n35,int n45,
-                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                           smIdType n15,smIdType n25,smIdType n35,smIdType n45,
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -335,7 +335,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n25,
                                            const SMDS_MeshNode * n35,
                                            const SMDS_MeshNode * n45, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -351,12 +351,12 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n45);
 
   // 2d order Pentahedron with 15 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
-                                           int n4, int n5, int n6,
-                                           int n12,int n23,int n31,
-                                           int n45,int n56,int n64,
-                                           int n14,int n25,int n36,
-                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
+                                           smIdType n4, smIdType n5, smIdType n6,
+                                           smIdType n12,smIdType n23,smIdType n31,
+                                           smIdType n45,smIdType n56,smIdType n64,
+                                           smIdType n14,smIdType n25,smIdType n36,
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -372,7 +372,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n14,
                                            const SMDS_MeshNode * n25,
                                            const SMDS_MeshNode * n36, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -390,13 +390,13 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n36);
 
   // 2d order Pentahedron with 18 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3,
-                                           int n4, int n5, int n6,
-                                           int n12,int n23,int n31,
-                                           int n45,int n56,int n64,
-                                           int n14,int n25,int n36,
-                                           int n1245, int n2356, int n1346,
-                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
+                                           smIdType n4, smIdType n5, smIdType n6,
+                                           smIdType n12,smIdType n23,smIdType n31,
+                                           smIdType n45,smIdType n56,smIdType n64,
+                                           smIdType n14,smIdType n25,smIdType n36,
+                                           smIdType n1245, smIdType n2356, smIdType n1346,
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -415,7 +415,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n1245,
                                            const SMDS_MeshNode * n2356,
                                            const SMDS_MeshNode * n1346,
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -436,12 +436,12 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n1346);
 
   // 2d order Hexahedrons with 20 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                           int n5, int n6, int n7, int n8,
-                                           int n12,int n23,int n34,int n41,
-                                           int n56,int n67,int n78,int n85,
-                                           int n15,int n26,int n37,int n48,
-                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                           smIdType n56,smIdType n67,smIdType n78,smIdType n85,
+                                           smIdType n15,smIdType n26,smIdType n37,smIdType n48,
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -462,7 +462,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n26,
                                            const SMDS_MeshNode * n37,
                                            const SMDS_MeshNode * n48, 
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -485,14 +485,14 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n48);
 
   // 2d order Hexahedrons with 27 nodes
-  virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                           int n5, int n6, int n7, int n8,
-                                           int n12,int n23,int n34,int n41,
-                                           int n56,int n67,int n78,int n85,
-                                           int n15,int n26,int n37,int n48,
-                                           int n1234,int n1256,int n2367,int n3478,
-                                           int n1458,int n5678,int nCenter,
-                                           int ID);
+  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                           smIdType n56,smIdType n67,smIdType n78,smIdType n85,
+                                           smIdType n15,smIdType n26,smIdType n37,smIdType n48,
+                                           smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
+                                           smIdType n1458,smIdType n5678,smIdType nCenter,
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
@@ -520,7 +520,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                            const SMDS_MeshNode * n1458,
                                            const SMDS_MeshNode * n5678,
                                            const SMDS_MeshNode * nCenter,
-                                           int ID);
+                                           smIdType ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
                                      const SMDS_MeshNode * n3,
@@ -549,31 +549,31 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
                                      const SMDS_MeshNode * n5678,
                                      const SMDS_MeshNode * nCenter);
 
-  virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
-                                                 const int               ID);
+  virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
+                                                 const smIdType               ID);
 
   virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
-                                                 const int                                ID);
+                                                 const smIdType                                ID);
 
   virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);
 
-  virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<int> & nodes_ids,
-                                                    const int                ID);
+  virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,
+                                                    const smIdType                ID);
 
   virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
-                                                    const int                                 ID);
+                                                    const smIdType                                 ID);
 
   virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
-    (const std::vector<int>& nodes_ids,
+    (const std::vector<smIdType>& nodes_ids,
      const std::vector<int>& quantities,
-     const int               ID);
+     const smIdType               ID);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
     (const std::vector<const SMDS_MeshNode*>& nodes,
      const std::vector<int>&                  quantities,
-     const int                                ID);
+     const smIdType                                ID);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolume
     (const std::vector<const SMDS_MeshNode*>& nodes,
@@ -594,7 +594,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
 
   bool ChangeElementNodes(const SMDS_MeshElement * elem,
                           const SMDS_MeshNode    * nodes[],
-                          const int                nbnodes);
+                          const smIdType                nbnodes);
   bool ChangePolygonNodes(const SMDS_MeshElement * elem,
                           std::vector<const SMDS_MeshNode*> nodes);
   bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,