Merge br_enable_import_mesh. Enable import mesh and save/load SMESH study.

idl/SMESH_Gen.idl

@@ -104,7 +104,13 @@ module SMESH
     //				 in shape_array listOfSubShape)
     //  raises (SALOME::SALOME_Exception);
     
-
+	/**
+	 * Import a mesh from a file.
+	 * @param fileName file name to be imported.
+	 * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+	 * @param studyId The id of the current study.
+	 */
+	SMESH_Mesh Import(in long studyId, in string fileName, in string fileType);
   };
 
 };

idl/SMESH_Mesh.idl

@@ -49,7 +49,8 @@ module SMESH
       ADD_PRISM,
       ADD_HEXAHEDRON,
       REMOVE_NODE,
-      REMOVE_ELEMENT
+      REMOVE_ELEMENT,
+	  REMOVE_ALL
     };
 
   struct log_block
@@ -161,13 +162,11 @@ module SMESH
        raises (SALOME::SALOME_Exception);
 
     /*!
-     * Export Mesh with DAT and MED Formats
+     * Export mesh to a file
+	 * @param fileName file name where to export the file
+	 * @param fileType Currently it could be either "DAT", "UNV" or "MED".
      */
-    void ExportDAT( in string file )
+    void Export( in string fileName, in string fileType )
-      raises (SALOME::SALOME_Exception);
-    void ExportMED( in string file )
-      raises (SALOME::SALOME_Exception);
-    void ExportUNV( in string file )
       raises (SALOME::SALOME_Exception);
 
     /*!

src/Driver/Document_Reader.cxx

@@ -38,3 +38,16 @@ void Document_Reader::SetDocument(SMESHDS_Document * aDoc)
 {
 	myDocument = aDoc;
 }
+
+void Document_Reader::Read()
+{
+	int myMeshId = myDocument->NewMesh();
+	SMDS_Mesh * myMesh = myDocument->GetMesh(myMeshId);
+	myReader->SetMesh(myMesh);
+	myReader->SetFile(myFile);
+	myReader->Read();
+}
+
+Document_Reader::Document_Reader(Mesh_Reader* reader): myReader(reader)
+{
+}

src/Driver/Document_Reader.h

@@ -28,17 +28,22 @@
 #define _INCLUDE_DOCUMENT_READER
 
 #include "SMESHDS_Document.hxx"
+#include "Mesh_Reader.h"
 #include <string>
 
 class Document_Reader
 {
   public:
-	virtual void Read() = 0;
+	virtual void Read();
 	void SetFile(string);
 	void SetDocument(SMESHDS_Document *);
+	Document_Reader(Mesh_Reader*);
 
   protected:
-	  SMESHDS_Document * myDocument;
+	SMESHDS_Document * myDocument;
 	string myFile;
+
+  private:
+	Mesh_Reader* myReader;
 };
 #endif

src/Driver/Document_Writer.cxx

@@ -18,14 +18,9 @@
 //  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   : Document_Writer.cxx
-//  Module : SMESH
 
-using namespace std;
 #include "Document_Writer.h"
+#include "utilities.h"
 
 void Document_Writer::SetFile(string aFile)
 {
@@ -36,3 +31,28 @@ void Document_Writer::SetDocument(SMESHDS_Document * aDoc)
 {
 	myDocument = aDoc;
 }
+
+void Document_Writer::Write()
+{
+	SCRUTE(myFile);
+	SMESHDS_Mesh * myMesh;
+	int nb_of_meshes = myDocument->NbMeshes();	//voir avec Yves
+	SCRUTE(nb_of_meshes);
+
+	int numero = 0;
+
+	myDocument->InitMeshesIterator();
+	while(myDocument->MoreMesh())
+	{
+		numero++;
+		myMesh = myDocument->NextMesh();
+		myWriter->SetMesh(myMesh);
+		myWriter->SetFile(myFile);
+		myWriter->SetMeshId(numero);
+		myWriter->Add();
+	}
+}
+
+Document_Writer::Document_Writer(Mesh_Writer* writer): myWriter(writer)
+{
+}

src/Driver/Document_Writer.h

@@ -28,17 +28,21 @@
 #define _INCLUDE_DOCUMENT_WRITER
 
 #include "SMESHDS_Document.hxx"
+#include "Mesh_Writer.h"
 #include <string>
 
 class Document_Writer
 {
 
-  public:virtual void Write() = 0;
+  public:virtual void Write();
 	void SetFile(string);
 	void SetDocument(SMESHDS_Document *);
+	Document_Writer(Mesh_Writer* );
 
-  protected:  SMESHDS_Document * myDocument;
+  protected:
+	SMESHDS_Document * myDocument;
 	string myFile;
+	Mesh_Writer * myWriter;
 
 };
 #endif

src/Driver/Makefile.in

@@ -35,11 +35,21 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= Document_Reader.h Document_Writer.h Mesh_Reader.h Mesh_Writer.h
+EXPORT_HEADERS = \
+	SMESHDriver.h \
+	Document_Reader.h \
+	Document_Writer.h \
+	Mesh_Reader.h \
+	Mesh_Writer.h
 
 # Libraries targets
 LIB = libMeshDriver.la
-LIB_SRC = Document_Reader.cxx Document_Writer.cxx Mesh_Reader.cxx Mesh_Writer.cxx
+LIB_SRC = \
+	SMESHDriver.cxx \
+	Document_Reader.cxx \
+	Document_Writer.cxx 
+#	Mesh_Reader.cxx \
+#	Mesh_Writer.cxx \
 
 LIB_CLIENT_IDL =
 

src/Driver/SMESHDriver.cxx

@@ -1,4 +1,4 @@
-//  SMESH Driver : implementaion of driver for reading and writing	
+//  SMESH Driver : implementation of driver for reading and writing	
 //
 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
@@ -18,122 +18,97 @@
 //  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   : SMESHDriver.cxx
-//  Module : SMESH
 
-using namespace std;
 #include "SMESHDriver.h"
 
 #include <dlfcn.h>
 #include <utilities.h>
 
-//A enlever
+Document_Reader* SMESHDriver::GetDocumentReader(string Extension)
-#include "DriverMED_R_SMESHDS_Document.h"
+{
-#include "DriverMED_R_SMESHDS_Mesh.h"
+	// if there is not document reader in the driver create a default
-#include "DriverMED_R_SMDS_Mesh.h"
+	// one with the mesh reader.
-#include "DriverMED_W_SMESHDS_Document.h"
+	Document_Reader * docReader=
-#include "DriverMED_W_SMESHDS_Mesh.h"
+		(Document_Reader*)getMeshDocumentDriver(Extension);
-#include "DriverMED_W_SMDS_Mesh.h"
-
-#include "DriverDAT_R_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Mesh.h"
-#include "DriverDAT_R_SMDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Document.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMDS_Mesh.h"
-//
-
-Document_Reader* SMESHDriver::GetDocumentReader(string Extension, string Class) {
-  if (Extension==string("MED")) {
-    DriverMED_R_SMESHDS_Document* myDriver = new DriverMED_R_SMESHDS_Document();
-    return (myDriver);
-  }
-  else if (Extension==string("DAT")) {
-    DriverDAT_R_SMESHDS_Document* myDriver = new DriverDAT_R_SMESHDS_Document();
-    return (myDriver);
-  }
-  else {
-    MESSAGE("No driver known for this extension");
-    return (Document_Reader*)NULL;
-  }
-
 
+	if(docReader==NULL)
+	{
+		Mesh_Reader * reader=GetMeshReader(Extension);
+		if(reader==NULL)
+		{
+	    	MESSAGE("No driver known for this extension");
+			return NULL;
+		}
+		return new Document_Reader(reader);
+	}
+	else return docReader;
 }
 
-Document_Writer* SMESHDriver::GetDocumentWriter(string Extension, string Class) {
+Document_Writer* SMESHDriver::GetDocumentWriter(string Extension)
-  if (Extension==string("MED")) {
+{
-    DriverMED_W_SMESHDS_Document* myDriver = new DriverMED_W_SMESHDS_Document();
+	Mesh_Writer * writer=GetMeshWriter(Extension);
-    return (myDriver);
+	if(writer==NULL)
-  }    
+	{
-  else if (Extension==string("DAT")) {
+    	MESSAGE("No driver known for this extension");
-    DriverDAT_W_SMESHDS_Document* myDriver = new DriverDAT_W_SMESHDS_Document();
+		return NULL;
-    return (myDriver);
+	}
-  }    
+	return new Document_Writer(writer);
-  else {
-    MESSAGE("No driver known for this extension");
-    return (Document_Writer*)NULL;
-  }
-
-
 }
 
-Mesh_Reader* SMESHDriver::GetMeshReader(string Extension, string Class) {
+Mesh_Reader* SMESHDriver::GetMeshReader(string extension)
-  if (Extension==string("MED")) {
+{
-
+	void * driver = getMeshDriver(extension, string("Reader"));
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
+	return (Mesh_Reader*)driver;
-    DriverMED_R_SMESHDS_Mesh* myDriver = new DriverMED_R_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverMED_R_SMDS_Mesh* myDriver = new DriverMED_R_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-  else if (Extension==string("DAT")) {
-
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
-    DriverDAT_R_SMESHDS_Mesh* myDriver = new DriverDAT_R_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverDAT_R_SMDS_Mesh* myDriver = new DriverDAT_R_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-
-
 }
 
-Mesh_Writer* SMESHDriver::GetMeshWriter(string Extension, string Class) {
+Mesh_Writer* SMESHDriver::GetMeshWriter(string extension)
-  if (Extension==string("MED")) {
+{
-
+	void * driver = getMeshDriver(extension, string("Writer"));
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
+	return (Mesh_Writer*)driver;
-    DriverMED_W_SMESHDS_Mesh* myDriver = new DriverMED_W_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverMED_W_SMDS_Mesh* myDriver = new DriverMED_W_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-  else if (Extension==string("DAT")) {
-
-  if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
-    DriverDAT_W_SMESHDS_Mesh* myDriver = new DriverDAT_W_SMESHDS_Mesh();
-    return (myDriver);
-  }
-  else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
-    DriverDAT_W_SMDS_Mesh* myDriver = new DriverDAT_W_SMDS_Mesh();
-    return (myDriver);
-  }
-
-  }
-
 }
 
+void * SMESHDriver::getMeshDriver(string extension, string type)
+{
+	string libName = string("libMeshDriver")+extension+string(".so");
+	void * handle = dlopen(libName.c_str(), RTLD_LAZY);
+	if(!handle)
+	{
+		fputs (dlerror(), stderr);
+		return NULL;
+	}
+	else
+	{
+		void * (*factory)();
+		string symbol = string("SMESH_create")+extension+string("Mesh")+type;
+		factory = (void * (*)()) dlsym(handle, symbol.c_str());
+		if(factory==NULL)
+		{
+			fputs (dlerror(), stderr);
+			return NULL;
+		}
+		else return factory();
+	}
+}
+
+void * SMESHDriver::getMeshDocumentDriver(string extension)
+{
+	string libName = string("libMeshDriver")+extension+string(".so");
+	void * handle = dlopen(libName.c_str(), RTLD_LAZY);
+	if(!handle)
+	{
+		fputs (dlerror(), stderr);
+		return NULL;
+	}
+	else
+	{
+		void * (*factory)();
+		string symbol = string("SMESH_create")+extension+string("DocumentReader");
+		factory = (void * (*)()) dlsym(handle, symbol.c_str());
+		if(factory==NULL)
+		{
+			fputs (dlerror(), stderr);
+			return NULL;
+		}
+		else return factory();
+	}
+}

src/Driver/SMESHDriver.h

@@ -32,14 +32,17 @@
 #include "Mesh_Reader.h"
 #include "Mesh_Writer.h"
 
-class SMESHDriver {
+class SMESHDriver
-
+{
   public :
-    static Document_Reader* GetDocumentReader(string Extension, string Class);
+    static Document_Reader* GetDocumentReader(string Extension);
-    static Document_Writer* GetDocumentWriter(string Extension, string Class);
+    static Document_Writer* GetDocumentWriter(string Extension);
 
-    static Mesh_Reader* GetMeshReader(string Extension, string Class);
+    static Mesh_Reader* GetMeshReader(string Extension);
-    static Mesh_Writer* GetMeshWriter(string Extension, string Class);
+    static Mesh_Writer* GetMeshWriter(string Extension);
 
+  private:
+	static void * getMeshDriver(string Extension, string type);
+	static void * getMeshDocumentDriver(string Extension);
 };
 #endif

src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx

@@ -24,11 +24,21 @@
 //  File   : DriverDAT_R_SMDS_Mesh.cxx
 //  Module : SMESH
 
-using namespace std;
 #include "DriverDAT_R_SMDS_Mesh.h"
-
 #include "utilities.h"
 
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createDATMeshReader()
+{
+	return new DriverDAT_R_SMDS_Mesh();
+}
+}
+
 DriverDAT_R_SMDS_Mesh::DriverDAT_R_SMDS_Mesh()
 {
 	;

src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx

@@ -24,17 +24,25 @@
 //  File   : DriverDAT_W_SMDS_Mesh.cxx
 //  Module : SMESH
 
-using namespace std;
 #include "DriverDAT_W_SMDS_Mesh.h"
-
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
-
 #include "utilities.h"
 
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createDATMeshWriter()
+{
+	return new DriverDAT_W_SMDS_Mesh();
+}
+}
+
 DriverDAT_W_SMDS_Mesh::DriverDAT_W_SMDS_Mesh()
 {
-	;
 }
 
 DriverDAT_W_SMDS_Mesh::~DriverDAT_W_SMDS_Mesh()
@@ -64,12 +72,12 @@ void DriverDAT_W_SMDS_Mesh::SetMeshId(int aMeshId)
 
 void DriverDAT_W_SMDS_Mesh::Add()
 {
-	;
+	MESSAGE("Adding a mesh to a DAT document. As DAT do not support more than one mesh in a file, the previous mesh is deleted");
+	Write();
 }
 
 void DriverDAT_W_SMDS_Mesh::Write()
 {
-
 	int nbNodes, nbCells;
 	int i;
 
@@ -80,7 +88,7 @@ void DriverDAT_W_SMDS_Mesh::Write()
 		fprintf(stderr, ">> ERREUR : ouverture du fichier %s \n", file2Read);
 		exit(EXIT_FAILURE);
 	}
-	SCRUTE(myMesh);
+
   /****************************************************************************
   *                       NOMBRES D'OBJETS                                    *
   ****************************************************************************/
@@ -97,9 +105,6 @@ void DriverDAT_W_SMDS_Mesh::Write()
 	nb_of_faces = myMesh->NbFaces();
 	nb_of_volumes = myMesh->NbVolumes();
 	nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
-	SCRUTE(nb_of_edges);
-	SCRUTE(nb_of_faces);
-	SCRUTE(nb_of_volumes);
 
 	fprintf(stdout, "%d %d\n", nbNodes, nbCells);
 	fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
@@ -118,6 +123,7 @@ void DriverDAT_W_SMDS_Mesh::Write()
 		fprintf(myFileId, "%d %e %e %e\n", node->GetID(), node->X(),
 			node->Y(), node->Z());
 	}
+	delete itNodes;
 
   /****************************************************************************
   *                       ECRITURE DES ELEMENTS                                *
@@ -127,10 +133,10 @@ void DriverDAT_W_SMDS_Mesh::Write()
 	fprintf(stdout, "(**************************)");
 	/* Ecriture des connectivites, noms, numeros des mailles */
 
-	SMDS_Iterator<const SMDS_MeshEdge *> * itEdges=myMesh->edgesIterator();
+	SMDS_Iterator<const SMDS_MeshEdge*> * itEdges=myMesh->edgesIterator();
 	while(itEdges->more())
 	{
-		const SMDS_MeshElement * elem = itEdges->next();
+		const SMDS_MeshEdge * elem = itEdges->next();
 
 		switch (elem->NbNodes())
 		{
@@ -146,11 +152,13 @@ void DriverDAT_W_SMDS_Mesh::Write()
 		}
 		}
 
-		SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
+		SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
-		while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
+		while(itNodes->more())
+			fprintf(myFileId, "%d ", itNodes->next()->GetID());
 		
 		fprintf(myFileId, "\n");
 	}
+	delete itEdges;
 
 	SMDS_Iterator<const SMDS_MeshFace *> * itFaces=myMesh->facesIterator();
 	while(itFaces->more())
@@ -176,13 +184,16 @@ void DriverDAT_W_SMDS_Mesh::Write()
 		}
 		}
 
-		SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
+		SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
-		while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
+		while(itNodes->more())
+			fprintf(myFileId, "%d ", itNodes->next()->GetID());
+		delete itNodes;
 	
 		fprintf(myFileId, "\n");
 	}
+	delete itFaces;
 
-	SMDS_Iterator<const SMDS_MeshVolume *> * itVolumes=myMesh->volumesIterator();
+	SMDS_Iterator<const SMDS_MeshVolume*> * itVolumes=myMesh->volumesIterator();
 	while(itVolumes->more())
 	{
 		const SMDS_MeshElement * elem = itVolumes->next();
@@ -196,11 +207,14 @@ void DriverDAT_W_SMDS_Mesh::Write()
 		}
 		}
 
-		SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
+		SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
-		while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
+		while(itNodes->more())
+			fprintf(myFileId, "%d ", itNodes->next()->GetID());
+		delete itNodes;	
 
 		fprintf(myFileId, "\n");
 	}
+	delete itVolumes;
 
 	fclose(myFileId);
 }

src/DriverDAT/Makefile.in

@@ -35,11 +35,23 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= DriverDAT_R_SMDS_Mesh.h DriverDAT_R_SMESHDS_Mesh.h DriverDAT_R_SMESHDS_Document.h DriverDAT_W_SMDS_Mesh.h DriverDAT_W_SMESHDS_Mesh.h DriverDAT_W_SMESHDS_Document.h 
+EXPORT_HEADERS = \
+	DriverDAT_R_SMDS_Mesh.h \
+	DriverDAT_R_SMESHDS_Mesh.h \
+	DriverDAT_W_SMDS_Mesh.h \
+	DriverDAT_W_SMESHDS_Mesh.h 
+#	DriverDAT_W_SMESHDS_Document.h \
+#	DriverDAT_R_SMESHDS_Document.h \
 
 # Libraries targets
 LIB = libMeshDriverDAT.la
-LIB_SRC = DriverDAT_R_SMDS_Mesh.cxx DriverDAT_R_SMESHDS_Mesh.cxx DriverDAT_R_SMESHDS_Document.cxx DriverDAT_W_SMDS_Mesh.cxx DriverDAT_W_SMESHDS_Mesh.cxx DriverDAT_W_SMESHDS_Document.cxx 
+LIB_SRC = \
+	DriverDAT_R_SMDS_Mesh.cxx \
+	DriverDAT_R_SMESHDS_Mesh.cxx \
+	DriverDAT_W_SMDS_Mesh.cxx \
+	DriverDAT_W_SMESHDS_Mesh.cxx 
+	#DriverDAT_W_SMESHDS_Document.cxx \
+	#DriverDAT_R_SMESHDS_Document.cxx \
 
 LIB_CLIENT_IDL =
 

src/DriverMED/DriverMED_R_SMESHDS_Document.cxx

@@ -31,13 +31,14 @@ using namespace std;
 
 extern "C"
 {
-	Document_Reader *maker()
+	void * SMESH_createMEDDocumentReader()
 	{
 		return new DriverMED_R_SMESHDS_Document;
 	}
 }
 
 DriverMED_R_SMESHDS_Document::DriverMED_R_SMESHDS_Document()
+	:Document_Reader(new DriverMED_R_SMESHDS_Mesh())
 {
 	;
 }
@@ -60,8 +61,6 @@ void DriverMED_R_SMESHDS_Document::Read()
 
 	int myMeshId;
 
-	//string myFile = string("/home/home_users/cai/projects/salome_prev04/SALOME_ROOT/data/fra1.med");
-
 /****************************************************************************
   *                      OUVERTURE DU FICHIER EN LECTURE                      *
   ****************************************************************************/

src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx

@@ -31,6 +31,18 @@ using namespace std;
 
 #include <stdlib.h>
 
+extern "C"
+{
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createMEDMeshReader()
+{
+	return new DriverMED_R_SMESHDS_Mesh();
+}
+
+}
+
 DriverMED_R_SMESHDS_Mesh::DriverMED_R_SMESHDS_Mesh()
 {
 	myFileId = -1;

src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx

@@ -33,6 +33,18 @@ using namespace std;
 #include <vector>
 #include "utilities.h"
 
+extern "C"
+{
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createMEDMeshWriter()
+{
+	return new DriverMED_W_SMESHDS_Mesh();
+}
+
+}
+
 DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
 {
 	;
@@ -65,19 +77,7 @@ void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
 
 void DriverMED_W_SMESHDS_Mesh::Write()
 {
-
+	Add();
-	string myClass = string("SMDS_Mesh");
-	string myExtension = string("MED");
-
-	DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
-
-	myWriter->SetMesh(myMesh);
-	//  myWriter->SetFile(myFile);
-	myWriter->SetMeshId(myMeshId);
-	myWriter->SetFileId(myFileId);
-
-	myWriter->Write();
-
 }
 
 void DriverMED_W_SMESHDS_Mesh::Add()
@@ -520,40 +520,45 @@ void DriverMED_W_SMESHDS_Mesh::Add()
 	{
 		int nbFamillesElts = 0;
 		SMESHDS_Mesh * mySMESHDSMesh = dynamic_cast<SMESHDS_Mesh *>(myMesh);
-		TopTools_IndexedMapOfShape myIndexToShape;
-		TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
-
 		map<int,int> mapFamille;
 
-		if (besoinfamilledemaille == 1)
+		if(!mySMESHDSMesh->ShapeToMesh().IsNull())
 		{
-			int t;
+			TopTools_IndexedMapOfShape myIndexToShape;
-			for (t = 1; t <= myIndexToShape.Extent(); t++)
+			TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
-			{
-				const TopoDS_Shape S = myIndexToShape(t);
-				if (mySMESHDSMesh->HasMeshElements(S))
-				{
-					//MESSAGE ("********* Traitement de la Famille "<<-t);
 
-					SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
+
-					SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
+			if (besoinfamilledemaille == 1)
-					bool plein = false;
+			{
-					while(ite->more())
+				int t;
+				for (t = 1; t <= myIndexToShape.Extent(); t++)
+				{
+					const TopoDS_Shape S = myIndexToShape(t);
+					if (mySMESHDSMesh->HasMeshElements(S))
 					{
-						mapFamille[ite->next()->GetID()] = -t;
+						//MESSAGE ("********* Traitement de la Famille "<<-t);
-						plein = true;
+	
-					}
+						SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
-					if (plein)
+						SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
-					{
+						bool plein = false;
-						nbFamillesElts++;
+						while(ite->more())
-						char famille[MED_TAILLE_NOM + 1];
+						{
-						sprintf(famille, "E%d", t);
+							mapFamille[ite->next()->GetID()] = -t;
-						CreateFamily(strdup(nommaa), strdup(famille), -t,
+							plein = true;
-							attvalabs++);
+						}
+						if (plein)
+						{
+							nbFamillesElts++;
+							char famille[MED_TAILLE_NOM + 1];
+							sprintf(famille, "E%d", t);
+							CreateFamily(strdup(nommaa), strdup(famille), -t,
+								attvalabs++);
+						}
 					}
 				}
 			}
 		}
+		else besoinfamilledemaille = 0;
 
 		int indice = 1;
 		for (i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)

src/DriverMED/Makefile.in

@@ -19,12 +19,9 @@
 # 
 #  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
 #
-#
-#
 #  File   : Makefile.in
 #  Author : Marc Tajchman (CEA)
 #  Module : SMESH
-#  $Header$
 
 top_srcdir=@top_srcdir@
 top_builddir=../..
@@ -35,18 +32,23 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= DriverMED_R_SMDS_Mesh.h DriverMED_R_SMESHDS_Mesh.h DriverMED_R_SMESHDS_Document.h DriverMED_W_SMDS_Mesh.h DriverMED_W_SMESHDS_Mesh.h DriverMED_W_SMESHDS_Document.h 
+EXPORT_HEADERS = \
+	DriverMED_R_SMESHDS_Mesh.h \
+	DriverMED_R_SMESHDS_Document.h \
+	DriverMED_R_SMDS_Mesh.h \
+	DriverMED_W_SMESHDS_Mesh.h 
+	#DriverMED_W_SMDS_Mesh.h \
+	#DriverMED_W_SMESHDS_Document.h 
 
 # Libraries targets
 LIB = libMeshDriverMED.la
 LIB_SRC = \
-	DriverMED_R_SMDS_Mesh.cxx \
 	DriverMED_R_SMESHDS_Mesh.cxx \
 	DriverMED_R_SMESHDS_Document.cxx \
-	DriverMED_W_SMDS_Mesh.cxx \
+	DriverMED_R_SMDS_Mesh.cxx \
-	DriverMED_W_SMESHDS_Document.cxx \
 	DriverMED_W_SMESHDS_Mesh.cxx 
-
+	#DriverMED_W_SMDS_Mesh.cxx \
+	#DriverMED_W_SMESHDS_Document.cxx 
 LIB_CLIENT_IDL =
 LIB_SERVER_IDL =
 

src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx

@@ -3,6 +3,20 @@ using namespace std;
 
 #include "utilities.h"
 
+
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createUNVMeshReader()
+{
+	return new DriverUNV_R_SMDS_Mesh();
+}
+
+}
+
 DriverUNV_R_SMDS_Mesh::DriverUNV_R_SMDS_Mesh()
 {
 	;

src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx

@@ -1,13 +1,7 @@
-using namespace std;
 #include "DriverUNV_W_SMDS_Mesh.h"
-
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
 
-
-
-
-
 #include <utilities.h>
 
 #define sNODE_UNV_ID "  2411"
@@ -19,6 +13,19 @@ using namespace std;
 #define sELT_BEAM_DESC1 "%10d        %2d         1         1         7         %1d\n"
 #define sELT_BEAM_DESC2 "         0         1         1\n"
 
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createUNVMeshWriter()
+{
+	return new DriverUNV_W_SMDS_Mesh();
+}
+
+}
+
 DriverUNV_W_SMDS_Mesh::DriverUNV_W_SMDS_Mesh()
 {
 	;
@@ -89,7 +96,6 @@ void DriverUNV_W_SMDS_Mesh::Write()
 	SCRUTE(nb_of_volumes);
 
 	fprintf(stdout, "%d %d\n", nbNodes, nbCells);
-	fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
 
   /****************************************************************************
   *                       ECRITURE DES NOEUDS                                 *

src/DriverUNV/Makefile.in

@@ -35,18 +35,23 @@ VPATH=.:@srcdir@
 @COMMENCE@
 
 # header files 
-EXPORT_HEADERS= DriverUNV_R_SMDS_Mesh.h DriverUNV_R_SMESHDS_Mesh.h DriverUNV_R_SMESHDS_Document.h \
+EXPORT_HEADERS = \
-                DriverUNV_W_SMDS_Mesh.h DriverUNV_W_SMESHDS_Mesh.h DriverUNV_W_SMESHDS_Document.h 
+	DriverUNV_R_SMDS_Mesh.h \
+	DriverUNV_W_SMDS_Mesh.h 
+	#DriverUNV_W_SMESHDS_Mesh.h \
+	#DriverUNV_W_SMESHDS_Document.h \
+	#DriverUNV_R_SMESHDS_Mesh.h \
+	#DriverUNV_R_SMESHDS_Document.h \
 
 # Libraries targets
 LIB = libMeshDriverUNV.la
 LIB_SRC = \
 	DriverUNV_R_SMDS_Mesh.cxx \
-	DriverUNV_R_SMESHDS_Mesh.cxx \
+	DriverUNV_W_SMDS_Mesh.cxx 
-	DriverUNV_R_SMESHDS_Document.cxx \
+	#DriverUNV_W_SMESHDS_Mesh.cxx \
-	DriverUNV_W_SMESHDS_Document.cxx \
+	#DriverUNV_R_SMESHDS_Mesh.cxx \
-	DriverUNV_W_SMDS_Mesh.cxx \
+	#DriverUNV_R_SMESHDS_Document.cxx \
-	DriverUNV_W_SMESHDS_Mesh.cxx 
+	#DriverUNV_W_SMESHDS_Document.cxx \
 
 LIB_CLIENT_IDL =
 

src/SMDS/SMDS_Mesh.cxx

@@ -1271,7 +1271,7 @@ SMDS_Iterator<const SMDS_MeshNode *> * SMDS_Mesh::nodesIterator() const
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-///Return an iterator on volumes of the current mesh. Once used this iterator
+///Return an iterator on egdes of the current mesh. Once used this iterator
 ///must be free by the caller
 ///////////////////////////////////////////////////////////////////////////////
 SMDS_Iterator<const SMDS_MeshEdge *> * SMDS_Mesh::edgesIterator() const
@@ -1574,3 +1574,126 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
 	delete s2;
 	delete s1;
 }
+
+/**
+ * Concat the coordinates of all nodes in an array.
+ * Its used to display the mesh.
+ * @return A array of size 3*NbNodes() containing the coordinates of nodes.
+ */
+double * SMDS_Mesh::getNodesCoordinates()
+{
+	double * toReturn=new double[3*NbNodes()];
+	SMDS_Iterator<const SMDS_MeshNode*> * it=nodesIterator();
+	int i=0;
+	while(it->more())
+	{
+		const SMDS_MeshNode * n=it->next();
+		toReturn[i]=n->X();
+		i++;
+		toReturn[i]=n->Y();
+		i++;
+		toReturn[i]=n->Z();
+		i++;
+	}
+	delete it;
+	return toReturn;
+}
+
+/**
+ * Concat the id of all nodes in an array.
+ * Its used to display the mesh.
+ * @return A array of size NbNodes() containing the ids of nodes.
+ */
+long * SMDS_Mesh::getNodesID()
+{
+	long * toReturn=new long[NbNodes()];
+	SMDS_Iterator<const SMDS_MeshNode*> * it=nodesIterator();
+	int i=0;
+	while(it->more())
+	{
+		const SMDS_MeshNode * n=it->next();		
+		toReturn[i]=n->GetID();
+		i++;
+	}
+	delete it;
+	return toReturn;
+}
+
+/**
+ * Concat the id of nodes of edges in an array.
+ * Array format is {edge_id, node1_id, node2_id}
+ * Its used to display the mesh.
+ * @return A array of size 3*NbEdges() containing the edges.
+ */
+long * SMDS_Mesh::getEdgesIndices()
+{
+	long * toReturn=new long[NbEdges()*3];
+	SMDS_Iterator<const SMDS_MeshEdge*> * it=edgesIterator();
+	int i=0;
+	
+	while(it->more())
+	{
+		const SMDS_MeshEdge * e=it->next();
+		toReturn[i]=e->GetID();
+		i++;
+		SMDS_Iterator<const SMDS_MeshElement*> * itn=e->nodesIterator();
+		while(itn->more())
+		{
+			const SMDS_MeshElement * n=itn->next();
+			toReturn[i]=n->GetID();
+			i++;
+		}
+		delete itn;
+	}
+	delete it;
+	return toReturn;
+}
+
+/**
+ * Concat the id of nodes of triangles in an array.
+ * Array format is {tria_id, node1_id, node2_id, node3_id}
+ * Its used to display the mesh.
+ * @return A array of size 4*NbTriangles() containing the edges.
+ */
+long * SMDS_Mesh::getTrianglesIndices()
+{
+	long * toReturn=new long[NbTriangles()*4];
+	SMDS_Iterator<const SMDS_MeshFace*> * it=facesIterator();
+	int i=0;
+	while(it->more())
+	{
+		const SMDS_MeshFace * f=it->next();
+		if(f->NbNodes()==3)
+		{
+			toReturn[i]=f->GetID();
+			i++;		
+			SMDS_Iterator<const SMDS_MeshElement*> * itn=f->nodesIterator();
+			while(itn->more())
+			{
+				const SMDS_MeshElement * n=itn->next();
+				toReturn[i]=n->GetID();
+				i++;
+			}
+			delete itn;
+		}
+	}
+	delete it;
+	return toReturn;
+}
+
+/**
+ * Return the number of 3 nodes faces in the mesh.
+ * This method run in O(n).
+ * @return The number of face whose number of nodes is 3
+ */
+int SMDS_Mesh::NbTriangles() const
+{
+	SMDS_Iterator<const SMDS_MeshFace*> * it=facesIterator();
+	int toReturn=0;
+	while(it->more())
+	{
+		const SMDS_MeshFace * f=it->next();
+		if(f->NbNodes()==3) toReturn++;
+	}
+	return toReturn;
+}

src/SMDS/SMDS_Mesh.hxx

@@ -167,6 +167,7 @@ class SMDS_Mesh:public SMDS_MeshObject
 	int NbNodes() const;
 	int NbEdges() const;
 	int NbFaces() const;
+	int NbTriangles() const;
 	int NbVolumes() const;
 	int NbSubMesh() const;
 	void DumpNodes() const;
@@ -184,6 +185,11 @@ class SMDS_Mesh:public SMDS_MeshObject
     void setConstructionFaces(bool);
 	void setInverseElements(bool);
 
+	double * getNodesCoordinates();
+	long * getNodesID();
+	long * getEdgesIndices();
+	long * getTrianglesIndices();
+
   private:
     SMDS_Mesh(SMDS_Mesh * parent);
     SMDS_MeshFace * createTriangle(SMDS_MeshNode * node1,

src/SMESH/Makefile.in

@@ -94,7 +94,7 @@ CXXFLAGS+= $(OCC_CXXFLAGS) $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR
 
 #IDLCXXFLAGS+= -Wbtp
 
-LDFLAGS+= $(HDF5_LIBS) $(MED2_LIBS) -lOpUtil -lSMESHDS -lSMDS -lMEFISTO2D -lMeshDriverDAT -lMeshDriverMED -lMeshDriverUNV -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+= $(HDF5_LIBS) $(MED2_LIBS) -lOpUtil -lSMESHDS -lSMDS -lMEFISTO2D -lMeshDriver -L${KERNEL_ROOT_DIR}/lib/salome
 
 ifeq (@WITHNETGEN@,yes)
   LIB_SRC+= SMESH_NETGEN_3D.cxx

src/SMESH/SMESH_Gen.cxx

@@ -30,6 +30,7 @@
 #include "SMESH_subMesh.hxx"
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
+#include "SMESHDriver.h"
 
 #include <gp_Pnt.hxx>
 #include <BRep_Tool.hxx>
@@ -126,7 +127,8 @@ throw(SALOME_Exception)
 
 //=============================================================================
 /*!
- * 
+ * @TODO Doing a full update after computation is not optimal when doing a local
+ * remeshing.
  */
 //=============================================================================
 
@@ -138,7 +140,7 @@ throw(SALOME_Exception)
 /* 
 Algo : s'appuie ou non sur une geometrie
 Si geometrie:
-Vertex : rien à faire (range le point)
+Vertex : rien <EFBFBD>faire (range le point)
 Edge, Wire, collection d'edge et wire : 1D
 Face, Shell, collection de Face et Shells : 2D
 Solid, Collection de Solid : 3D
@@ -183,6 +185,8 @@ Solid, Collection de Solid : 3D
 		smToCompute = sm->GetFirstToCompute();
 	}
 
+	aMesh.GetMeshDS()->logFullUpdate();
+
 	return ret;
 }
 
@@ -404,3 +408,40 @@ int SMESH_Gen::GetShapeDim(const TopoDS_Shape & aShape)
 //   SCRUTE(shapeDim);
 	return shapeDim;
 }
+
+/**
+ * Import a mesh from a file
+ * @param fileName file name to be imported
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ * @todo
+ */
+SMESH_Mesh * SMESH_Gen::Import(int studyId, const char * fileName,
+	const char * fileType)
+{
+	MESSAGE("SMESH_Gen::Import("<<studyId<<","<<fileName<<","<<fileType<<")");
+
+	// Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+	StudyContextStruct *myStudyContext = GetStudyContext(studyId);
+
+	// will be used with document
+	/*Document_Reader * reader = SMESHDriver::GetDocumentReader(string(fileType));
+	reader->SetDocument(myStudyContext->myDocument);
+	reader->SetFile(string(fileName));
+	reader->Read();*/
+	// currently we only read one mesh from a file (limitation on MED files).
+
+	// create a new SMESH_mesh object 
+	SMESH_Mesh *mesh = new SMESH_Mesh(_localId++, studyId, this,
+		myStudyContext->myDocument);
+	myStudyContext->mapMesh[_localId] = mesh;
+	
+	Mesh_Reader * reader = SMESHDriver::GetMeshReader(string(fileType));
+	reader->SetMesh(mesh->GetMeshDS());
+	reader->SetFile(string(fileName));
+	reader->Read();
+	
+	mesh->GetMeshDS()->logFullUpdate();
+	
+	return mesh;
+}
+

src/SMESH/SMESH_Gen.hxx

@@ -69,6 +69,7 @@ class SMESH_Gen
 
 	static int GetShapeDim(const TopoDS_Shape & aShape);
 	SMESH_Algo *GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape);
+	SMESH_Mesh *Import(int studyId, const char * fileName, const char * fileType);
  
 	// inherited methods from SALOMEDS::Driver
 

src/SMESH/SMESH_Mesh.cxx

@@ -32,13 +32,8 @@
 #include "SMESH_Hypothesis.hxx"
 #include "SMESHDS_Script.hxx"
 #include "SMDS_MeshVolume.hxx"
-
 #include "utilities.h"
-
+#include "SMESHDriver.h"
-#include "Mesh_Writer.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverUNV_W_SMESHDS_Mesh.h"
 
 #include <TCollection_AsciiString.hxx>
 
@@ -415,37 +410,22 @@ throw(SALOME_Exception)
 	return _subMeshesUsingHypothesisList;
 }
 
-//=============================================================================
 /*!
- *
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
  */
-//=============================================================================
+void SMESH_Mesh::Export(const char *fileName, const char *fileType)
-
+	throw(SALOME_Exception)
-void SMESH_Mesh::ExportMED(const char *file) throw(SALOME_Exception)
 {
-	Mesh_Writer *myWriter = new DriverMED_W_SMESHDS_Mesh;
+	MESSAGE("SMESH_Mesh::Export("<<fileName<<","<<fileType<<")");
-	myWriter->SetFile(string(file));
+	Mesh_Writer * writer = SMESHDriver::GetMeshWriter(string(fileType));
-	myWriter->SetMesh(_myMeshDS);
+	if(writer!=NULL)
-	MESSAGE(" _idDoc " << _idDoc) myWriter->SetMeshId(_idDoc);
+	{
-	myWriter->Add();
+		writer->SetMesh(GetMeshDS());
-}
+		writer->SetFile(string(fileName));
-
+		writer->Write();
-void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
+	}
-{
-	Mesh_Writer *myWriter = new DriverDAT_W_SMESHDS_Mesh;
-	myWriter->SetFile(string(file));
-	myWriter->SetMesh(_myMeshDS);
-	myWriter->SetMeshId(_idDoc);
-	myWriter->Add();
-}
-
-void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
-{
-	Mesh_Writer *myWriter = new DriverUNV_W_SMESHDS_Mesh;
-	myWriter->SetFile(string(file));
-	myWriter->SetMesh(_myMeshDS);
-	myWriter->SetMeshId(_idDoc);
-	myWriter->Add();
 }
 
 //=============================================================================

src/SMESH/SMESH_Mesh.hxx

@@ -101,9 +101,8 @@ class SMESH_Mesh
 		GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
 		throw(SALOME_Exception);
 
-	void ExportDAT(const char *file) throw(SALOME_Exception);
+	void Export(const char *fileName, const char *fileType)
-	void ExportMED(const char *file) throw(SALOME_Exception);
+		throw(SALOME_Exception);
-	void ExportUNV(const char *file) throw(SALOME_Exception);
 
 	int NbNodes() throw(SALOME_Exception);
 

src/SMESHDS/SMESHDS_Command.hxx

@@ -29,6 +29,7 @@
 
 #include "SMESHDS_CommandType.hxx"
 #include <list>
+using namespace std;
 
 class SMESHDS_Command
 {

src/SMESHDS/SMESHDS_CommandType.hxx

@@ -38,7 +38,8 @@ SMESHDS_AddPrism,
 SMESHDS_AddHexahedron,
 SMESHDS_RemoveNode,
 SMESHDS_RemoveElement,
-SMESHDS_MoveNode
+SMESHDS_MoveNode,
+SMESHDS_UpdateAll
 };
 
 

src/SMESHDS/SMESHDS_Hypothesis.cxx

@@ -97,3 +97,7 @@ int SMESHDS_Hypothesis::GetType() const
   return _type;
 }
 
+void SMESHDS_Hypothesis::SetID(int id)
+{
+	_hypId=id;
+}

src/SMESHDS/SMESHDS_Hypothesis.hxx

@@ -48,6 +48,7 @@ public:
 
   const char* GetName() const;
   int GetID() const;
+  void SetID(int id);
   int GetType() const;
 
   virtual ostream & SaveTo(ostream & save)=0;

src/SMESHDS/SMESHDS_Mesh.cxx

@@ -577,3 +577,12 @@ void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
 SMESHDS_Mesh::~SMESHDS_Mesh()
 {
 }
+
+/**
+ * Add FULL_UPDATE command to the log of this mesh. Once interpreted by the
+ * graphical client it will (re)draw the full mesh.
+ */
+void SMESHDS_Mesh::logFullUpdate()
+{
+	myScript->UpdateAll();
+}

src/SMESHDS/SMESHDS_Mesh.hxx

@@ -133,6 +133,7 @@ class SMESHDS_Mesh:public SMDS_Mesh
 	void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);
 	void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);
 	 ~SMESHDS_Mesh();
+	void logFullUpdate();
 	
   private:
 	struct HashTopoDS_Shape

src/SMESHDS/SMESHDS_Script.cxx

@@ -26,7 +26,6 @@
 //  Module : SMESH
 //  $Header: 
 
-using namespace std;
 #include "SMESHDS_Script.hxx"
 
 //=======================================================================
@@ -321,3 +320,12 @@ const list<SMESHDS_Command*>& SMESHDS_Script::GetCommands()
 {
 	return myCommands;
 }
+
+/**
+ * Add UpdateAll command to the log of this mesh. Once interpreted by the
+ * graphical client it will (re)draw the full mesh.
+ */
+void SMESHDS_Script::UpdateAll()
+{
+	myCommands.insert(myCommands.end(), new SMESHDS_Command(SMESHDS_UpdateAll));
+}

src/SMESHDS/SMESHDS_Script.hxx

@@ -52,6 +52,7 @@ class SMESHDS_Script
 	void RemoveElement(int ElementID);
 	void Clear();
 	const list<SMESHDS_Command*> & GetCommands();
+	void UpdateAll();
 	~SMESHDS_Script();
   
   private:

src/SMESHGUI/Makefile.in

@@ -126,6 +126,6 @@ CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYT
 CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
 #$(OCC_CXXFLAGS)
 
-LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lSMESHObject -lSMDS -lSMESHDS -lSMESHFiltersSelection -lGEOMClient -lMeshDriverDAT -lMeshDriverMED -lMeshDriverUNV $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
+LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lSMESHObject -lSMDS -lSMESHDS -lSMESHFiltersSelection -lGEOMClient $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
 
 @CONCLUDE@

src/SMESHGUI/SMESHGUI.cxx

@@ -87,26 +87,6 @@ using namespace std;
 #include "SALOMEGUI_QtCatchCorbaException.hxx"
 #include "utilities.h"
 
-#include "SMDS_Mesh.hxx"
-#include "SMESHDS_Document.hxx"
-#include "Document_Reader.h"
-#include "Document_Writer.h"
-#include "Mesh_Reader.h"
-#include "Mesh_Writer.h"
-
-#include "DriverDAT_R_SMESHDS_Document.h"
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverUNV_R_SMESHDS_Document.h"
-#include "DriverDAT_W_SMESHDS_Document.h"
-#include "DriverMED_W_SMESHDS_Document.h"
-#include "DriverUNV_W_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverUNV_R_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverUNV_W_SMESHDS_Mesh.h"
-
 // QT Includes
 #define	 INCLUDE_MENUITEM_DEF
 #include <qapplication.h>
@@ -237,8 +217,6 @@ SMESHGUI *SMESHGUI::GetOrCreateSMESHGUI(QAD_Desktop * desktop)
 		smeshGUI->myStudyAPI =
 			SMESHGUI_StudyAPI(smeshGUI->myStudy, smeshGUI->myComponentMesh);
 
-		smeshGUI->myDocument = new SMESHDS_Document(1);	//NBU
-
 		smeshGUI->mySimulationActors = vtkActorCollection::New();
 		smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
 	}
@@ -2104,8 +2082,7 @@ bool SMESHGUI::OnGUIEvent(int theCommandID, QAD_Desktop * parent)
 	case 112:
 	case 111:
 	{
-		Import_Document(parent, theCommandID);	//NBU
+		smeshGUI->Import_Document(parent, theCommandID);
-		//Import_Mesh(parent,theCommandID);
 		break;
 	}
 
@@ -3498,58 +3475,6 @@ SALOMEDS::Study::ListOfSObject *
 	return listSOmesh._retn();
 }
 
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-void SMESHGUI::Import_Mesh(QAD_Desktop * parent, int theCommandID)
-{
-	QString filter;
-	string myExtension;
-	Mesh_Reader *myReader;
-
-	if (theCommandID == 113)
-	{
-		filter = tr("MED files (*.med)");
-		myExtension = string("MED");
-		myReader = new DriverMED_R_SMESHDS_Mesh;
-	}
-	else if (theCommandID == 112)
-	{
-		filter = tr("IDEAS files (*.unv)");
-		myExtension = string("UNV");
-	}
-	else if (theCommandID == 111)
-	{
-		filter = tr("DAT files (*.dat)");
-		myExtension = string("MED");
-		myReader = new DriverDAT_R_SMESHDS_Mesh;
-	}
-
-	QString filename = QAD_FileDlg::getFileName(parent,
-		"",
-		filter,
-		tr("Import mesh"),
-		true);
-	if (!filename.isEmpty())
-	{
-		QApplication::setOverrideCursor(Qt::waitCursor);
-		string myClass = string("SMESHDS_Mesh");
-//    Mesh_Reader* myReader = SMESHDriver::GetMeshReader(myExtension, myClass);
-
-		int myMeshId = (smeshGUI->myDocument)->NewMesh();
-		SMDS_Mesh *myMesh = (smeshGUI->myDocument)->GetMesh(myMeshId);
-
-		myReader->SetFile(string(filename.latin1()));
-		myReader->SetMesh(myMesh);
-		myReader->SetMeshId(myMeshId);
-		myReader->Read();
-
-		QApplication::restoreOverrideCursor();
-	}
-}
-
 //=============================================================================
 /*!
  *
@@ -3577,7 +3502,7 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
 				if (!filename.isEmpty())
 				{
 					QApplication::setOverrideCursor(Qt::waitCursor);
-					aMesh->ExportMED(filename.latin1());
+					aMesh->Export(filename.latin1(), "MED");
 					QApplication::restoreOverrideCursor();
 				}
 			}
@@ -3591,7 +3516,7 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
 				if (!filename.isEmpty())
 				{
 					QApplication::setOverrideCursor(Qt::waitCursor);
-					aMesh->ExportDAT(filename.latin1());
+					aMesh->Export(filename.latin1(), "DAT");
 					QApplication::restoreOverrideCursor();
 				}
 			}
@@ -3605,11 +3530,11 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
 				if (!filename.isEmpty())
 				{
 					QApplication::setOverrideCursor(Qt::waitCursor);
-					aMesh->ExportUNV(filename.latin1());
+					aMesh->Export(filename.latin1(), "UNV");
 					QApplication::restoreOverrideCursor();
 				}
 				else
-					aMesh->ExportDAT(filename.latin1());
+					aMesh->Export(filename.latin1(), "DAT");
 
 				QApplication::restoreOverrideCursor();
 
@@ -3642,90 +3567,49 @@ void SMESHGUI::Import_Document(QAD_Desktop * parent, int theCommandID)
 {
 	QString filter;
 	string myExtension;
-	Document_Reader *myReader;
 
 	if (theCommandID == 113)
 	{
 		filter = tr("MED files (*.med)");
 		myExtension = string("MED");
-		myReader = new DriverMED_R_SMESHDS_Document;
 	}
 	else if (theCommandID == 112)
 	{
 		filter = tr("IDEAS files (*.unv)");
 		myExtension = string("UNV");
-		myReader = new DriverUNV_R_SMESHDS_Document;
 	}
 	else if (theCommandID == 111)
 	{
 		filter = tr("DAT files (*.dat)");
 		myExtension = string("DAT");
-		myReader = new DriverDAT_R_SMESHDS_Document;
 	}
 
-	QString filename = QAD_FileDlg::getFileName(parent,
+	QString filename = QAD_FileDlg::getFileName(parent, "", filter,
-		"",
+		tr("Import document"), true);
-		filter,
+
-		tr("Import document"),
-		true);
 	if (!filename.isEmpty())
 	{
 		QApplication::setOverrideCursor(Qt::waitCursor);
-		string myClass = string("SMESHDS_Document");
+		try
-//    Document_Reader* myReader = SMESHDriver::GetDocumentReader(myExtension, myClass);
+		{
-		SMESHDS_Document *newDocument = new SMESHDS_Document(1);
+			if (!myComponentMesh->_is_nil())
+			{
+				SMESH::SMESH_Mesh_var aMesh =
+					myComponentMesh->Import(myStudyId, filename.latin1(),
+					myExtension.c_str());
 	
-		myReader->SetFile(string(filename.latin1()));
+				if (!aMesh->_is_nil())
-		myReader->SetDocument(smeshGUI->myDocument);
+				{
-		myReader->Read();
+					SALOMEDS::SObject_var SM = myStudyAPI.AddNewMesh(aMesh);
-		QApplication::restoreOverrideCursor();
+					myStudyAPI.SetName(SM, filename);
-	}
+				}
-}
+			}
-
+		}
-void SMESHGUI::Export_Document(QAD_Desktop * parent, int theCommandID)
+		catch(const SALOME::SALOME_Exception & S_ex)
-{
+		{
-	QString filter;
+			QtCatchCorbaException(S_ex);
-	Document_Writer *myWriter;
+		}
-	string myExtension;
+		myActiveStudy->updateObjBrowser(true);
-
-	if (theCommandID == 122)
-	{
-		filter = tr("MED files (*.med)");
-		myExtension = string("MED");
-		myWriter = new DriverMED_W_SMESHDS_Document;
-	}
-	else if (theCommandID == 121)
-	{
-		filter = tr("DAT files (*.dat)");
-		myExtension = string("DAT");
-		myWriter = new DriverDAT_W_SMESHDS_Document;
-	}
-	else if (theCommandID == 123)
-	{
-		filter = tr("IDEAS files (*.unv)");
-		myExtension = string("UNV");
-		myWriter = new DriverUNV_W_SMESHDS_Document;
-	}
-
-	QString filename = QAD_FileDlg::getFileName(parent,
-		"",
-		filter,
-		tr("Export document"),
-		false);
-	if (!filename.isEmpty())
-	{
-		QApplication::setOverrideCursor(Qt::waitCursor);
-		string myClass = string("SMESHDS_Document");
-		//Document_Writer* myWriter = SMESHDriver::GetDocumentWriter(myExtension, myClass);
-
-		myWriter->SetFile(string(filename.latin1()));
-		myWriter->SetDocument(smeshGUI->myDocument);
-
-		//StudyContextStruct* myStudyContext = _impl.GetStudyContext(myStudyId);
-		//Handle(SMESHDS_Document) myDocument = myStudyContext->myDocument;
-		//myWriter->SetDocument(myDocument);
-
-		myWriter->Write();
 		QApplication::restoreOverrideCursor();
 	}
 }
@@ -3817,9 +3701,6 @@ bool SMESHGUI::SetSettings(QAD_Desktop * parent)
 		smeshGUI->myAutomaticUpdate = false;
 	}
 
-	/* menus disable */
-	parent->menuBar()->setItemEnabled(11, false);	// IMPORT
-
 	return true;
 }
 
@@ -4098,13 +3979,13 @@ bool SMESHGUI::CustomPopup(QAD_Desktop * parent,
 	return false;
 }
 
-//=============================================================================
+/**
-/*! Method:  BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
+ * Ensures that the actor for the given <theIO> exists in the active VTK view
- *  Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
+ * @TODO Handle multiple selection.
  */
-//=============================================================================
 void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
 {
+	MESSAGE("SMESHGUI::BuildPresentation("<<theIO->getEntry()<<")");
 	/* Create or retrieve an object SMESHGUI */
 	SMESHGUI::GetOrCreateSMESHGUI(QAD_Application::getDesktop());
 
@@ -4113,7 +3994,8 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
 	if (activeFrame->getTypeView() == VIEW_VTK)
 	{
 		// VTK
-		SALOMEDS::SObject_var fatherSF =
+		// Some ideas to handle multiple selection...
+		/*SALOMEDS::SObject_var fatherSF =
 			smeshGUI->myStudy->FindObjectID(activeFrame->entry());
 
 		SALOME_Selection *Sel =
@@ -4121,8 +4003,8 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
 			getSelection());
 		SALOME_ListIteratorOfListIO It(Sel->StoredIObjects());
 
-//    for(;It.More();It.Next()) {
+	    for(;It.More();It.Next()) {
-//      Handle(SALOME_InteractiveObject) IObject = It.Value();
+      Handle(SALOME_InteractiveObject) IObject = It.Value();*/
 		Handle(SALOME_InteractiveObject) IObject = theIO;
 		if (IObject->hasEntry())
 		{
@@ -4131,41 +4013,38 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
 			SMESH_Actor *ac =
 				smeshGUI->FindActorByEntry(IObject->getEntry(), res, false);
 			
-			// Actor not found at all -> mesh is not computed -> do nothing!!!
 			if (!res)
 			{
-				/*SMESH::SMESH_Mesh_var aM;
+				SALOMEDS::SObject_var aMorSM=smeshGUI->myStudy->FindObjectID( IObject->getEntry());
-				 * SALOMEDS::SObject_var aMorSM = smeshGUI->myStudy->FindObjectID( IObject->getEntry() );
+				SALOMEDS::GenericAttribute_var anAttr;
-				 * SALOMEDS::SObject_var father = aMorSM->GetFather();
+				SALOMEDS::AttributeIOR_var     anIOR;
-				 * SALOMEDS::SObject_var fatherComp = aMorSM->GetFatherComponent();
+				if(aMorSM->FindAttribute(anAttr, "AttributeIOR"))
-				 * 
+				{
-				 * // Non-displayable objects (Hypo, Algo) have tags < 3 or have a father different from component
+					anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
-				 * if (aMorSM->Tag() < 3 || strcmp(father->GetID(), fatherComp->GetID()) != 0)
+					SMESH::SMESH_Mesh_var aM =
-				 * continue;
+						SMESH::SMESH_Mesh::_narrow( _orb->string_to_object(anIOR->Value()));
-				 * 
+					if(!aM->_is_nil())
-				 * SALOMEDS::GenericAttribute_var anAttr;
+					{
-				 * SALOMEDS::AttributeIOR_var     anIOR;
+						smeshGUI->InitActor(aM);
-				 * if ( !aMorSM->_is_nil() ) {
+						ac = smeshGUI->ReadScript(aM);
-				 * if (aMorSM->FindAttribute(anAttr, "AttributeIOR") ) {
+						smeshGUI->DisplayActor( ac, true );
-				 * anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+						smeshGUI->DisplayEdges( ac );
-				 * aM = SMESH::SMESH_Mesh::_narrow( _orb->string_to_object(anIOR->Value()) );
+						smeshGUI->ChangeRepresentation( ac, ac->getDisplayMode() );
-				 * }
+					}
-				 * }
+					else
-				 * 
+					{
-				 * if (!aM->_is_nil()) {
+						MESSAGE("Do not know how to display something which is not a SMESH_Mesh");
-				 * smeshGUI->InitActor(aM);
+					}
-				 * ac = smeshGUI->ReadScript(aM);
+				}
-				 * }
+				else
-				 * 
+				{
-				 * if (ac) {
+					MESSAGE("The object "<<theIO->getEntry()<<
-				 * smeshGUI->DisplayActor( ac, true );
+						" do not have \"AttributeIOR\" attribute");
-				 * smeshGUI->DisplayEdges( ac ); 
+				}
-				 * smeshGUI->ChangeRepresentation( ac, ac->getDisplayMode() );
-				 * } */
-//    continue;
 			}
 			else
-			{					// The actor exists in some view
+			{
+				// The actor exists in some view
 				// Check whether the actor belongs to the active view
 				VTKViewer_RenderWindowInteractor *rwInter =
 					((VTKViewer_ViewFrame *) activeFrame->getRightFrame()->
@@ -4188,12 +4067,11 @@ void SMESHGUI::BuildPresentation(const Handle(SALOME_InteractiveObject) & theIO)
 				smeshGUI->ChangeRepresentation(ac, ac->getDisplayMode());
 			}
 		}
-//    }
 	}
 	else
 	{
-	MESSAGE
+		MESSAGE("BuildPresentation() must not be called while non-VTK view is active");
-			("BuildPresentation() must not be called while non-VTK view is active")}
+	}
 }
 
 //=============================================================================
@@ -4216,13 +4094,14 @@ void SMESHGUI::setOrb()
 	ASSERT(!CORBA::is_nil(_orb));
 }
 
-//=============================================================================
+/**
-/*!
+ * Get the history of all commands made in the SMESH server. This list of command
- *
+ * is used to display the mesh in the VTK view
+ * @TODO Handle the REMOVE_ALL command.
  */
-//=============================================================================
 SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
 {
+	MESSAGE("SMESHGUI::ReadScript");
 	SMESH_Actor *MeshActor;
 	if (!aMesh->_is_nil())
 	{
@@ -4231,11 +4110,8 @@ SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
 		if (result)
 		{
 			SMESH::log_array_var aSeq = aMesh->GetLog(true);
-
+			MESSAGE("SMESHGUI::ReadScript: The log contains "<<aSeq->length()
-			if (aSeq->length() == 0)
+				<<" commands.");
-			{
-				MESSAGE("ReadScript(): log is empty") return MeshActor;
-			}
 
 			for (unsigned int ind = 0; ind < aSeq->length(); ind++)
 			{
@@ -4296,6 +4172,10 @@ SMESH_Actor *SMESHGUI::ReadScript(SMESH::SMESH_Mesh_ptr aMesh)
 						aSeq[ind].coords, aSeq[ind].indexes);
 					break;
 				}
+				case SMESH::REMOVE_ALL:
+					MESSAGE("REMOVE_ALL command not yet implemented");
+					break;
+				default: MESSAGE("Warning: Unknown script command.");
 				}
 			}
 			return MeshActor;
@@ -4348,6 +4228,7 @@ void SMESHGUI::Dump(SMESH_Actor * Mactor)
 void SMESHGUI::AddNodes(SMESH_Actor * Mactor, int number,
 	const SMESH::double_array & coords, const SMESH::long_array & indexes)
 {
+	MESSAGE("SMESHGUI::AddNodes(number="<<number<<", indexes.length()="<<indexes.length()<<")");
 	QApplication::setOverrideCursor(Qt::waitCursor);
 	if (Mactor->GetMapper() == NULL)
 	{
@@ -4405,8 +4286,9 @@ void SMESHGUI::AddNode(SMESH_Actor * Mactor, int idnode, float x, float y,
 	float z)
 {
 	QApplication::setOverrideCursor(Qt::waitCursor);
-	MESSAGE("SMESHGUI::AddNode " << idnode << " : " << x << ";" << y << ";" <<
+	MESSAGE("SMESHGUI::AddNode " << idnode << " : " << x << ";" << y << ";" << z);
-		z) if (Mactor->GetMapper() == NULL)
+	
+	if (Mactor->GetMapper() == NULL)
 	{
 		vtkPoints *Pts = vtkPoints::New();
 		int idVTK = Pts->InsertNextPoint(x, y, z);
@@ -5067,6 +4949,9 @@ void SMESHGUI::AddEdge(SMESH_Actor * Mactor, int idedge, int idnode1,
 void SMESHGUI::AddTriangles(SMESH_Actor * Mactor, int number,
 	const SMESH::double_array & coords, const SMESH::long_array & indexes)
 {
+	MESSAGE("SMESHGUI::AddTriangles(number="<<number<<", indexes.length="
+		<<indexes.length()<<")");
+
 	QApplication::setOverrideCursor(Qt::waitCursor);
 	//vtkUnstructuredGrid* ugrid = vtkUnstructuredGrid::SafeDownCast( Mactor->DataSource );
 	SMESH_Grid *ugrid = SMESH_Grid::SafeDownCast(Mactor->DataSource);
@@ -6011,6 +5896,7 @@ void SMESHGUI::InitActor(SMESH::SMESH_Mesh_ptr aMesh)
 //=============================================================================
 void SMESHGUI::Update()
 {
+	MESSAGE("SMESHGUI::Update");
 	if (myActiveStudy->getActiveStudyFrame()->getTypeView() == VIEW_VTK)
 	{							//VTK
 		vtkRenderer *theRenderer =

src/SMESHGUI/SMESHGUI.h

@@ -88,8 +88,6 @@ private :
 
   //  vtkScalarBarActor*    myScalarBar;
 
-  SMESHDS_Document *        myDocument;//NBU
-
   bool                      myAutomaticUpdate;
 
 public :
@@ -303,9 +301,7 @@ public :
   static void setOrb();
 
   /* Import/Export */ //NBU
-  static void Import_Document(QAD_Desktop* parent, int theCommandID);
+  void Import_Document(QAD_Desktop* parent, int theCommandID);
-  static void Export_Document(QAD_Desktop* parent, int theCommandID);
-  static void Import_Mesh(QAD_Desktop* parent, int theCommandID);
   static void Export_Mesh(QAD_Desktop* parent, int theCommandID);
 
 signals:

src/SMESHGUI/SMESHGUI_StudyAPI.cxx

@@ -99,7 +99,7 @@ SMESHGUI_StudyAPI::SMESHGUI_StudyAPI ( SALOMEDS::Study_ptr aStudy,
   // NRI
 
   SALOMEDS::SComponent_var father = aStudy->FindComponent("MESH");
-  SALOMEDS::GenericAttribute_var anAttr;
+  /*SALOMEDS::GenericAttribute_var anAttr;
   SALOMEDS::AttributeName_var    aName;
   SALOMEDS::AttributePixMap_var  aPixmap;
   
@@ -115,7 +115,7 @@ SMESHGUI_StudyAPI::SMESHGUI_StudyAPI ( SALOMEDS::Study_ptr aStudy,
   aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
   
   myStudyBuilder->DefineComponentInstance(father, CompMesh );
-  mySComponentMesh = SALOMEDS::SComponent::_narrow( father );
+  mySComponentMesh = SALOMEDS::SComponent::_narrow( father );*/
 }
 
 //=======================================================================

src/SMESH_I/SMESH_Gen_i.hxx

@@ -96,6 +96,8 @@ public:
                                    const SMESH::shape_array& listOfSubShape)
     throw (SALOME::SALOME_Exception);
 
+	SMESH::SMESH_Mesh_ptr Import(CORBA::Long studyId, const char* fileName,
+		const char* fileType);
 
   // inherited methods from SALOMEDS::Driver
 
@@ -153,6 +155,24 @@ protected:
                                GEOM::GEOM_Shape_ptr aShape);
   
 private:
+	void loadMesh(char * name, HDFfile * hdf_file, char * meshFile,
+		SALOMEDS::Study_var study);
+	void loadHypothesis(char * name, HDFfile * hdf_file, char * hypothesisFile,
+		int studyId);
+	void loadAlgorithms(char * name, HDFfile * hdf_file, char * algorithmsFile,
+		int studyId);
+	void loadAppliedHypothesis(HDFgroup * hdfGroupMeshId, bool _found,
+		SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh,
+		GEOM::GEOM_Shape_var aShape);
+	GEOM::GEOM_Gen_var getGeomEngine();
+	GEOM::GEOM_Shape_var getShape(SALOMEDS::Study_var Study, char * refFromFile);
+
+void loadAppliedAlgorithms(HDFgroup * hdfGroupMeshId, 
+	bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, 
+	GEOM::GEOM_Shape_var aShape);
+void loadSubMeshes(HDFgroup * hdfGroupMeshId, char * msgname,
+	SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh);
+			
   SMESH_HypothesisFactory_i _hypothesisFactory_i;
   ::SMESH_Gen _impl;  // no namespace here
   int _localId; // unique Id of created objects, within SMESH_Gen_i entity

src/SMESH_I/SMESH_Hypothesis_i.cxx

@@ -81,3 +81,8 @@ CORBA::Long SMESH_Hypothesis_i::GetId()
   MESSAGE("GetId");
   return _baseImpl->GetID();
 }
+
+::SMESH_Hypothesis* SMESH_Hypothesis_i::getImpl()
+{
+	return _baseImpl;
+}

src/SMESH_I/SMESH_Hypothesis_i.hxx

@@ -44,6 +44,7 @@ public:
 
   char* GetName();
   CORBA::Long GetId();
+  ::SMESH_Hypothesis* getImpl();
   
 protected:
   ::SMESH_Hypothesis* _baseImpl;

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -162,18 +162,15 @@ CORBA::Boolean
 	return ret;
 };
 
-//=============================================================================
+/**
-/*!
+ *@TODO Not implemented
- *  
  */
-//=============================================================================
-
 SMESH::ListOfHypothesis *
 	SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Shape_ptr aSubShape)
 throw(SALOME::SALOME_Exception)
 {
-	MESSAGE("GetHypothesisList");
+	MESSAGE("GetHypothesisList: Not implemented");
-	// ****
+	return NULL;
 };
 
 //=============================================================================
@@ -230,25 +227,101 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetElementsOnShape(GEOM::
 	return SMESH::SMESH_subMesh::_duplicate(_mapSubMeshIor[subMeshId]);
 }
 
-//=============================================================================
+/**
-/*!
+ * Translate the UpdateAll SMESHDS_Command to a set of SMESH::log_command.
- *  
+ * As the input log need to be resized, it is realocated.
+ * @param logBlock The log where to insert created commands
+ * @param index The place where to insert created commands in log. It is updated
+ * with the place to put new elements.
+ * @return The realocated and resized log.
+ * @TODO Add support for other type of elements
  */
-//=============================================================================
+SMESH::log_array_var SMESH_Mesh_i::
+	createUpdateAllCommand(SMESH::log_array_var log, int * index)
+{
+	MESSAGE("SMESH_Mesh_i::createUpdateAllCommand");
+	SMESH::log_array_var aLog=new SMESH::log_array(log->length()+3);
+	aLog->length(log->length()+3);
 	
+	for(int i=0;i<*index;i++)
+	{		
+		aLog[i]=log[i];
+	}
+	
+	log->length(0);
+	int id=*index;
+		
+	//Remove all elements
+	aLog[id].commandType=SMESH::REMOVE_ALL;
+	id++;
+	
+	//Export nodes
+	aLog[id].commandType=SMESH::ADD_NODE;
+	aLog[id].number=_impl->GetMeshDS()->NbNodes();
+
+	double * nodesCoordinates=_impl->GetMeshDS()->getNodesCoordinates();
+	aLog[id].coords=SMESH::double_array(
+		aLog[id].number*3,
+		aLog[id].number*3,
+		nodesCoordinates);
+
+	long * nodesID=_impl->GetMeshDS()->getNodesID();
+	aLog[id].indexes=SMESH::long_array(
+		aLog[id].number,
+		aLog[id].number,
+		nodesID);
+
+	id++;
+	
+	MESSAGE("Export edges");
+	//Export edges
+	aLog[id].commandType=SMESH::ADD_EDGE;
+	aLog[id].number=_impl->GetMeshDS()->NbEdges();	
+	aLog[id].coords.length(0);
+
+	long * edgesIndices=_impl->GetMeshDS()->getEdgesIndices();
+	aLog[id].indexes=SMESH::long_array(
+		aLog[id].number*3,
+		aLog[id].number*3,
+		edgesIndices);
+
+	id++;
+	
+	MESSAGE("Export triangles");
+	//Export triangles
+	aLog[id].commandType=SMESH::ADD_TRIANGLE;
+	aLog[id].number=_impl->GetMeshDS()->NbTriangles();	
+	aLog[id].coords.length(0);
+
+	long * triasIndices=_impl->GetMeshDS()->getTrianglesIndices();
+	aLog[id].indexes=SMESH::long_array(
+		aLog[id].number*4,
+		aLog[id].number*4,
+		triasIndices);
+
+	(*index)=id;
+	return aLog;
+}
+
+/**
+ * Return the log of the current mesh. CORBA wrap of the SMESH::GetLog method
+ * with a special treatment for SMESHDS_UpdateAll commands
+ * @param clearAfterGet Tell if the log must be cleared after being returned
+ * @return the log
+ */
 SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
-throw(SALOME::SALOME_Exception)
+	throw(SALOME::SALOME_Exception)
 {
 	MESSAGE("SMESH_Mesh_i::GetLog");
 
 	SMESH::log_array_var aLog;
-	try
+	/*try
-	{
+	{*/
 		list < SMESHDS_Command * >logDS = _impl->GetLog();
 		aLog = new SMESH::log_array;
 		int indexLog = 0;
 		int lg = logDS.size();
-		SCRUTE(lg);
+		MESSAGE("Number of command in the log: "<<lg);
 		aLog->length(lg);
 		list < SMESHDS_Command * >::iterator its = logDS.begin();
 		while (its != logDS.end())
@@ -267,32 +340,38 @@ throw(SALOME::SALOME_Exception)
 			//SCRUTE(rnum);
 			list < double >::const_iterator ir = coordList.begin();
 			aLog[indexLog].commandType = comType;
-			aLog[indexLog].number = lgcom;
+			if(comType==SMESHDS_UpdateAll)
-			aLog[indexLog].coords.length(rnum);
-			aLog[indexLog].indexes.length(inum);
-			for (int i = 0; i < rnum; i++)
 			{
-				aLog[indexLog].coords[i] = *ir;
+				aLog=createUpdateAllCommand(aLog, &indexLog);
-				//MESSAGE(" "<<i<<" "<<ir.Value());
-				ir++;
 			}
-			for (int i = 0; i < inum; i++)
+			else
 			{
-				aLog[indexLog].indexes[i] = *ii;
+				aLog[indexLog].number = lgcom;
-				//MESSAGE(" "<<i<<" "<<ii.Value());
+				aLog[indexLog].coords.length(rnum);
-				ii++;
+				aLog[indexLog].indexes.length(inum);
+				for (int i = 0; i < rnum; i++)
+				{
+					aLog[indexLog].coords[i] = *ir;
+					//MESSAGE(" "<<i<<" "<<ir.Value());
+					ir++;
+				}
+				for (int i = 0; i < inum; i++)
+				{
+					aLog[indexLog].indexes[i] = *ii;
+					//MESSAGE(" "<<i<<" "<<ii.Value());
+					ii++;
+				}
+				indexLog++;
 			}
-			indexLog++;
 			its++;
 		}
-		if (clearAfterGet)
+		if (clearAfterGet) _impl->ClearLog();
-			_impl->ClearLog();
+		return aLog._retn();
-	}
+	/*}
 	catch(SALOME_Exception & S_ex)
 	{
 		THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
-	}
+	}*/
-	return aLog._retn();
 }
 
 //  SMESH::string_array* SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
@@ -530,25 +609,6 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
  */
 //=============================================================================
 
-void SMESH_Mesh_i::ExportMED(const char *file) throw(SALOME::SALOME_Exception)
-{
-	_impl->ExportMED(file);
-}
-void SMESH_Mesh_i::ExportDAT(const char *file) throw(SALOME::SALOME_Exception)
-{
-	_impl->ExportDAT(file);
-}
-void SMESH_Mesh_i::ExportUNV(const char *file) throw(SALOME::SALOME_Exception)
-{
-	_impl->ExportUNV(file);
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
 SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
 {
 	SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
@@ -625,3 +685,14 @@ CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
 {
 	return _impl->NbSubMesh();
 }
+
+/*!
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ */
+void SMESH_Mesh_i::Export(const char* fileName, const char* fileType)
+	throw (SALOME::SALOME_Exception)
+{
+	_impl->Export(fileName, fileType);
+}

src/SMESH_I/SMESH_Mesh_i.hxx

@@ -91,6 +91,9 @@ public:
   CORBA::Long GetStudyId()
     throw (SALOME::SALOME_Exception);
 
+  void Export(const char* fileName, const char* fileType)
+	throw (SALOME::SALOME_Exception);
+
   // --- C++ interface
 
   void SetImpl(::SMESH_Mesh* impl);
@@ -100,13 +103,6 @@ public:
   void SetIor(SMESH::SMESH_Mesh_ptr myIor);
   SMESH::SMESH_Mesh_ptr GetIor();
 
-  void ExportMED( const char* file )
-    throw (SALOME::SALOME_Exception);
-  void ExportDAT( const char* file )
-    throw (SALOME::SALOME_Exception);
-  void ExportUNV( const char* file )
-    throw (SALOME::SALOME_Exception);
-
   SALOME_MED::MESH_ptr GetMEDMesh()
     throw (SALOME::SALOME_Exception);
   
@@ -142,7 +138,7 @@ public:
   map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
 
 private:
-
+  SMESH::log_array_var createUpdateAllCommand(SMESH::log_array_var log, int * index);
   ::SMESH_Mesh* _impl;  // :: force no namespace here
   SMESH_Gen_i* _gen_i;
   //   CORBA::ORB_ptr _orb;