Start implementation of DumpPython for SMESH

src/SMESH_I/Makefile.in

@@ -56,6 +56,7 @@ LIB= libSMESHEngine.la
 LIB_SRC = \
 	SMESH_Gen_i.cxx \
 	SMESH_Gen_i_1.cxx \
+	SMESH_Gen_i_DumpPython.cxx \
 	SMESH_Mesh_i.cxx \
 	SMESH_MEDMesh_i.cxx \
         SMESH_MEDFamily_i.cxx \

src/SMESH_I/SMESH_Gen_i.cxx

@@ -472,12 +472,23 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypNam
   SMESH::SMESH_Hypothesis_var hyp = this->createHypothesis( theHypName, theLibName );
 
   // Publish hypothesis/algorithm in the study
-  if ( CanPublishInStudy( hyp ) )
+  if ( CanPublishInStudy( hyp ) ) {
-    PublishHypothesis( myCurrentStudy, hyp );
+    SALOMEDS::SObject_var aSO = PublishHypothesis( myCurrentStudy, hyp );
+
+    // Update Python script
+    TCollection_AsciiString aStr (aSO->GetID());
+    aStr += " = smesh.CreateHypothesis(\"";
+    aStr += Standard_CString(theHypName);
+    aStr += "\", \"";
+    aStr += Standard_CString(theLibName);
+    aStr += "\")";
+
+    AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+  }
 
   return hyp._retn();
 }
-  
+
 //=============================================================================
 /*!
  *  SMESH_Gen_i::CreateMesh
@@ -497,9 +508,20 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObj
   SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
   ASSERT( meshServant );
   meshServant->SetShape( theShapeObject );
+
   // publish mesh in the study
-  if ( CanPublishInStudy( mesh ) )
+  if ( CanPublishInStudy( mesh ) ) {
-    PublishMesh( myCurrentStudy, mesh.in() );
+    SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, mesh.in() );
+
+    // Update Python script
+    TCollection_AsciiString aStr (aSO->GetID());
+    aStr += " = smesh.CreateMesh(salome.IDToObject(\"";
+    aStr += theShapeObject->GetStudyEntry();
+    aStr += "\"))";
+
+    AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+  }
+
   return mesh._retn();
 }
 
@@ -520,8 +542,17 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName
   SMESH::SMESH_Mesh_var aMesh = createMesh();
   string aFileName; // = boost::filesystem::path(theFileName).leaf();
   // publish mesh in the study
-  if ( CanPublishInStudy( aMesh ) )
+  if ( CanPublishInStudy( aMesh ) ) {
-    PublishMesh( myCurrentStudy, aMesh.in(), aFileName.c_str() );
+    SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, aMesh.in(), aFileName.c_str() );
+
+    // Update Python script
+    TCollection_AsciiString aStr (aSO->GetID());
+    aStr += " = smesh.CreateMeshesFromUNV(\"";
+    aStr += Standard_CString(theFileName);
+    aStr += "\")";
+
+    AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+  }
 
   SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
   ASSERT( aServant );
@@ -544,6 +575,9 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
   Unexpect aCatch(SALOME_SalomeException);
   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" );
 
+  // Python Dump
+  TCollection_AsciiString aStr ("([");
+
   // Retrieve mesh names from the file
   DriverMED_R_SMESHDS_Mesh myReader;
   myReader.SetFile( theFileName );
@@ -552,19 +586,30 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
   list<string> aNames = myReader.GetMeshNames(aStatus);
   SMESH::mesh_array_var aResult = new SMESH::mesh_array();
   theStatus = (SMESH::DriverMED_ReadStatus)aStatus;
-  if(theStatus == SMESH::DRS_OK){
+  if (theStatus == SMESH::DRS_OK) {
     aResult->length( aNames.size() );
     int i = 0;
     
     // Iterate through all meshes and create mesh objects
     for ( list<string>::iterator it = aNames.begin(); it != aNames.end(); it++ ) {
+      // Python Dump
+      if (i > 0) aStr += ", ";
+
       // create mesh
       SMESH::SMESH_Mesh_var mesh = createMesh();
       
       // publish mesh in the study
-      if ( CanPublishInStudy( mesh ) )
+      if ( CanPublishInStudy( mesh ) ) {
-        PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() );
+        SALOMEDS::SObject_var aSO = PublishMesh( myCurrentStudy, mesh.in(), (*it).c_str() );
-      
+
+        // Python Dump
+        aStr += aSO->GetID();
+      } else {
+        // Python Dump
+        aStr += "mesh_";
+        aStr += TCollection_AsciiString(i);
+      }
+
       // Read mesh data (groups are published automatically by ImportMEDFile())
       SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
       ASSERT( meshServant );
@@ -576,6 +621,17 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
       aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
     }
   }
+
+  // Update Python script
+  aStr += "], status) = smesh.CreateMeshesFromMED(\"";
+  aStr += Standard_CString(theFileName);
+  aStr += "\")";
+
+  AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+
+  aStr = "print \"CreateMeshesFromMED: \", status";
+  AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+
   return aResult._retn();
 }
 
@@ -596,8 +652,18 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName
   SMESH::SMESH_Mesh_var aMesh = createMesh();
   string aFileName; // = boost::filesystem::path(theFileName).leaf();
   // publish mesh in the study
-  if ( CanPublishInStudy( aMesh ) )
+  if ( CanPublishInStudy( aMesh ) ) {
-    PublishInStudy( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
+    SALOMEDS::SObject_var aSO = PublishInStudy
+      ( myCurrentStudy, SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
+
+    // Update Python script
+    TCollection_AsciiString aStr (aSO->GetID());
+    aStr += " = smesh.CreateMeshesFromSTL(\"";
+    aStr += Standard_CString(theFileName);
+    aStr += "\")";
+
+    AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+  }
 
   SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
   ASSERT( aServant );
@@ -744,6 +810,19 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
                                   SALOME::BAD_PARAM );
 
+  // Update Python script
+  SALOMEDS::SObject_var aSO = ObjectToSObject(myCurrentStudy, theMesh);
+  TCollection_AsciiString aStr ("isDone = smesh.Compute(");
+  aStr += aSO->GetID();
+  aStr += ", salome.IDToObject(\"";
+  aStr += theShapeObject->GetStudyEntry();
+  aStr += "\"))";
+
+  AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+
+  aStr = "print \"Compute: \", isDone";
+  AddToPythonScript(myCurrentStudy->StudyId(), aStr);
+
   try {
     // get mesh servant
     SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
@@ -785,6 +864,9 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
        theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() )
     SetCurrentStudy( theComponent->GetStudy() );
 
+  // Store study contents as a set of python commands
+  SavePython(myCurrentStudy);
+
   StudyContext* myStudyContext = GetCurrentStudyContext();
   
   // Declare a byte stream

src/SMESH_I/SMESH_Gen_i.hxx

@@ -45,6 +45,10 @@
 #include "SMESH_Gen.hxx"
 #include "GEOM_Client.hxx"
 
+#include <TCollection_AsciiString.hxx>
+#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
+#include <TColStd_HSequenceOfAsciiString.hxx>
+
 #include <map>
 
 class SMESH_Mesh_i;
@@ -273,6 +277,24 @@ public:
     return aResultSO._retn();
   }
 
+  virtual Engines::TMPFile* DumpPython(CORBA::Object_ptr theStudy, 
+				       CORBA::Boolean isPublished, 
+				       CORBA::Boolean& isValidScript);
+
+  void AddToPythonScript (int theStudyID, const TCollection_AsciiString& theString);
+
+  void SavePython (SALOMEDS::Study_ptr theStudy);
+
+  TCollection_AsciiString DumpPython_impl (int theStudyID, 
+                                           Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
+                                           bool isPublished, 
+                                           bool& aValidScript,
+                                           const TCollection_AsciiString& theSavedTrace);
+
+  TCollection_AsciiString GetNewPythonLines (int theStudyID);
+
+  void CleanPythonTrace (int theStudyID);
+
   // *****************************************
   // Internal methods
   // *****************************************
@@ -369,6 +391,9 @@ private:
 
   GEOM_Client*              myShapeReader;      // Shape reader
   SALOMEDS::Study_var       myCurrentStudy;     // Current study
+
+  // Dump Python: trace of API methods calls
+  std::map < int, Handle(TColStd_HSequenceOfAsciiString) > myPythonScripts;
 };
 
 #endif

src/SMESH_I/SMESH_Gen_i_DumpPython.cxx

@@ -0,0 +1,314 @@
+// File    : SMESH_Gen_i_DumpPython.cxx
+// Created : Thu Mar 24 17:17:59 2005
+// Author  : Julia DOROVSKIKH
+// Module  : SMESH
+// $Header : $
+
+#include "SMESH_Gen_i.hxx"
+
+#include <TColStd_HSequenceOfInteger.hxx>
+
+//=======================================================================
+//function : DumpPython
+//purpose  : 
+//=======================================================================
+Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy, 
+                                           CORBA::Boolean isPublished, 
+                                           CORBA::Boolean& isValidScript)
+{
+  SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow(theStudy);
+  if (CORBA::is_nil(aStudy))
+    return new Engines::TMPFile(0);   
+
+  SALOMEDS::SObject_var aSO = aStudy->FindComponent(ComponentDataType());
+  if (CORBA::is_nil(aSO))
+    return new Engines::TMPFile(0);  
+
+  // Map study entries to object names
+  Resource_DataMapOfAsciiStringAsciiString aMap;
+  TCollection_AsciiString s ("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_");
+
+  SALOMEDS::ChildIterator_var Itr = aStudy->NewChildIterator(aSO);
+  for (Itr->InitEx(true); Itr->More(); Itr->Next()) {
+    SALOMEDS::SObject_var aValue = Itr->Value();
+
+    TCollection_AsciiString aName (aValue->GetName());
+    int p, p2 = 1, e = aName.Length();
+    while ((p = aName.FirstLocationNotInSet(s, p2, e))) {
+      aName.SetValue(p, '_');
+      p2 = p;
+    }  
+    aMap.Bind(TCollection_AsciiString(aValue->GetID()), aName);
+  }
+
+  // Get trace of restored study
+  //SALOMEDS::SObject_var aSO = SMESH_Gen_i::ObjectToSObject(theStudy, _this());
+  SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
+  SALOMEDS::GenericAttribute_var anAttr =
+    aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
+
+  char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject();
+  TCollection_AsciiString aSavedTrace (oldValue);
+
+  // Add trace of API methods calls and replace study entries by names
+  bool aValidScript;
+  //TCollection_AsciiString aScript = myGen.DumpPython
+  TCollection_AsciiString aScript = DumpPython_impl
+    (aStudy->StudyId(), aMap, isPublished, aValidScript, aSavedTrace);
+
+  int aLen = aScript.Length(); 
+  unsigned char* aBuffer = new unsigned char[aLen+1];
+  strcpy((char*)aBuffer, aScript.ToCString());
+
+  CORBA::Octet* anOctetBuf =  (CORBA::Octet*)aBuffer;
+  Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1); 
+  isValidScript = aValidScript;
+
+  return aStreamFile._retn(); 
+}
+
+//=============================================================================
+/*!
+ *  AddToPythonScript
+ */
+//=============================================================================
+void SMESH_Gen_i::AddToPythonScript (int theStudyID, const TCollection_AsciiString& theString)
+{
+  if (myPythonScripts.find(theStudyID) == myPythonScripts.end()) {
+    myPythonScripts[theStudyID] = new TColStd_HSequenceOfAsciiString;
+  }
+  myPythonScripts[theStudyID]->Append(theString);
+}
+
+//=======================================================================
+//function : SavePython
+//purpose  : 
+//=======================================================================
+void SMESH_Gen_i::SavePython (SALOMEDS::Study_ptr theStudy)
+{
+  // Dump trace of API methods calls
+  TCollection_AsciiString aScript = GetNewPythonLines(theStudy->StudyId());
+
+  // Check contents of PythonObject attribute
+  SALOMEDS::SObject_var aSO = theStudy->FindComponent(ComponentDataType());
+  //SALOMEDS::SObject_var aSO = SMESH_Gen_i::ObjectToSObject(theStudy, _this());
+  SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
+  SALOMEDS::GenericAttribute_var anAttr =
+    aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
+
+  char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject();
+  TCollection_AsciiString oldScript (oldValue);
+
+  if (oldScript.Length() > 0) {
+    oldScript += "\n";
+    oldScript += aScript;
+  } else {
+    oldScript = aScript;
+  }
+
+  // Store in PythonObject attribute
+  SALOMEDS::AttributePythonObject::_narrow(anAttr)->SetObject(oldScript.ToCString(), 1);
+
+  // Clean trace of API methods calls
+  CleanPythonTrace(theStudy->StudyId());
+}
+
+
+// impl
+
+
+//=============================================================================
+/*!
+ *  FindEntries: Returns a sequence of start/end positions of entries in the string
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfInteger) FindEntries (TCollection_AsciiString& theString)
+{
+  Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger;
+  Standard_Integer aLen = theString.Length();
+  Standard_Boolean isFound = Standard_False;
+
+  char* arr = theString.ToCString();
+  Standard_Integer i = 0, j;
+
+  while(i < aLen) {
+    int c = (int)arr[i];
+    j = i+1;
+    if(c >= 48 && c <= 57) { //Is digit?
+ 
+      isFound = Standard_False;
+      while((j < aLen) && ((c >= 48 && c <= 57) || c == 58) ) { //Check if it is an entry
+	c = (int)arr[j++];  
+	if(c == 58) isFound = Standard_True;
+      }
+
+      if (isFound) {
+        int prev = (i < 1) ? 0 : (int)arr[i - 1];
+        // last char should be a diggit,
+        // previous char should not be '"'.
+        if (arr[j-2] != 58 && prev != 34) {
+          aSeq->Append(i+1); // +1 because AsciiString starts from 1
+          aSeq->Append(j-1);
+        }
+      }
+    }
+
+    i = j;
+  }
+
+  return aSeq;
+}
+
+//=============================================================================
+/*!
+ *  DumpPython
+ */
+//=============================================================================
+TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
+                        (int theStudyID, 
+                         Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
+                         bool isPublished, 
+                         bool& aValidScript,
+                         const TCollection_AsciiString& theSavedTrace)
+{
+  TCollection_AsciiString aScript;
+  aScript += "import salome\n";
+  aScript += "import geompy\n\n";
+  aScript += "import SMESH\n";
+  aScript += "import StdMeshers\n\n";
+  aScript += "def RebuildData(theStudy):";
+  aScript += "\n\tsmesh = salome.lcc.FindOrLoadComponent(\"FactoryServer\", \"SMESH\")";
+  aScript += "\n\tsmesh.SetCurrentStudy(theStudy)";
+
+  // Dump trace of restored study
+  if (theSavedTrace.Length() > 0) {
+    aScript += "\n";
+    aScript += theSavedTrace;
+  }
+
+  // Dump trace of API methods calls
+  TCollection_AsciiString aNewLines = GetNewPythonLines(theStudyID);
+  if (aNewLines.Length() > 0) {
+    aScript += "\n";
+    aScript += aNewLines;
+  }
+//  if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) {
+//    aScript += "\n";
+//    Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID];
+//    Standard_Integer istr, aLen = aPythonScript->Length();
+//    for (istr = 1; istr <= aLen; istr++) {
+//      aScript += "\n\t";
+//      aScript += aPythonScript->Value(istr);
+//    }
+//    aScript += "\n";
+//  }
+
+  // Find entries to be replaced by names
+  Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aScript);
+  Standard_Integer aLen = aSeq->Length();
+
+  if (aLen == 0)
+    return aScript;
+
+  // Replace entries by the names
+  Resource_DataMapOfAsciiStringAsciiString aNames;
+  Standard_Integer objectCounter = 0, aStart = 1, aScriptLength = aScript.Length();
+  TCollection_AsciiString anUpdatedScript, anEntry, aName, aBaseName("geomObj_");
+
+  for (Standard_Integer i = 1; i <= aLen; i += 2) {
+    anUpdatedScript += aScript.SubString(aStart, aSeq->Value(i) - 1);
+    anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
+    if (theObjectNames.IsBound(anEntry)) {
+      aName = theObjectNames.Find(anEntry);
+      if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) {
+        // diff objects have same name - make a new name
+        TCollection_AsciiString aName2;
+        Standard_Integer i = 0;
+        do {
+          aName2 = aName + "_" + ++i;
+        } while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2));
+        aName = aName2;
+        theObjectNames(anEntry) = aName;
+      }
+    } else {
+      do {
+        aName = aBaseName + TCollection_AsciiString(++objectCounter);
+      } while (theObjectNames.IsBound(aName));
+      theObjectNames.Bind(anEntry, aName);
+    }
+    theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
+
+    anUpdatedScript += aName;
+    aNames.Bind(aName, "1");
+    aStart = aSeq->Value(i + 1) + 1;
+  }
+
+  // add final part of the script
+  if (aSeq->Value(aLen) < aScriptLength)
+    anUpdatedScript += aScript.SubString(aSeq->Value(aLen) + 1, aScriptLength);
+
+  // Set object names
+  anUpdatedScript += "\n\tisGUIMode = 1";
+  anUpdatedScript += "\n\tif isGUIMode:";
+  anUpdatedScript += "\n\t\tsmeshgui = salome.ImportComponentGUI(\"SMESH\")";
+  anUpdatedScript += "\n\t\tsmeshgui.Init(theStudy._get_StudyId())";
+  anUpdatedScript += "\n";
+
+  Resource_DataMapOfAsciiStringAsciiString mapEntries;
+  for (Standard_Integer i = 1; i <= aLen; i += 2) {
+    anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
+    if (theObjectNames.IsBound(anEntry) && !mapEntries.IsBound(anEntry)) {
+      aName = theObjectNames.Find(anEntry);
+      mapEntries.Bind(anEntry, aName);
+      anUpdatedScript += "\n\t\tsmeshgui.SetName(salome.ObjectToID(";
+      anUpdatedScript += aName + "), \"" + aName + "\")";
+      //anUpdatedScript += "\n\t\tsmeshgui.SetName(\"";
+      //anUpdatedScript += anEntry + "\", \"" + aName + "\")";
+    }
+  }
+  anUpdatedScript += "\n\n\t\tsalome.sg.updateObjBrowser(0)";
+
+  anUpdatedScript += "\n\n\tpass\n";
+
+  aValidScript = true;
+
+  return anUpdatedScript;
+}
+
+//=============================================================================
+/*!
+ *  GetNewPythonLines
+ */
+//=============================================================================
+TCollection_AsciiString SMESH_Gen_i::GetNewPythonLines (int theStudyID)
+{
+  TCollection_AsciiString aScript;
+
+  // Dump trace of API methods calls
+  if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) {
+    Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID];
+    Standard_Integer istr, aLen = aPythonScript->Length();
+    for (istr = 1; istr <= aLen; istr++) {
+      aScript += "\n\t";
+      aScript += aPythonScript->Value(istr);
+    }
+    aScript += "\n";
+  }
+
+  return aScript;
+}
+
+//=============================================================================
+/*!
+ *  CleanPythonTrace
+ */
+//=============================================================================
+void SMESH_Gen_i::CleanPythonTrace (int theStudyID)
+{
+  TCollection_AsciiString aScript;
+
+  // Clean trace of API methods calls
+  if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) {
+    myPythonScripts[theStudyID]->Clear();
+  }
+}

src/SMESH_I/SMESH_MeshEditor_i.cxx

@@ -67,9 +67,28 @@ CORBA::Boolean SMESH_MeshEditor_i::RemoveElements(const SMESH::
 {
   ::SMESH_MeshEditor anEditor( _myMesh );
   list< int > IdList;
-  for (int i = 0; i < IDsOfElements.length(); i++)
+
+  // Update Python script
+  TCollection_AsciiString aStr ("isDone = mesh_editor.RemoveElements([");
+
+  for (int i = 0; i < IDsOfElements.length(); i++) {
+    // convert long_array into list< int >
     IdList.push_back( IDsOfElements[i] );
 
+    if (i > 0) aStr += ", ";
+    aStr += TCollection_AsciiString((int)IDsOfElements[i]);
+  }
+
+  aStr += "])";
+
+  SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+  aSMESHGen->AddToPythonScript(aSMESHGen->GetCurrentStudy()->StudyId(), aStr);
+
+  aStr = "print \"RemoveElements: \", isDone";
+
+  aSMESHGen->AddToPythonScript(aSMESHGen->GetCurrentStudy()->StudyId(), aStr);
+
+  // Remove Elements
   return anEditor.Remove( IdList, false );
 };
 

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -336,6 +336,23 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubS
 
   if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
 
+  // Update Python script
+  SALOMEDS::SObject_var aMeshSO = SMESH_Gen_i::ObjectToSObject(_gen_i->GetCurrentStudy(), _this());
+  SALOMEDS::SObject_var aHypoSO = SMESH_Gen_i::ObjectToSObject(_gen_i->GetCurrentStudy(), anHyp);
+
+  TCollection_AsciiString aStr ("status = ");
+  aStr += aMeshSO->GetID();
+  aStr += ".AddHypothesis(salome.IDToObject(\"";
+  aStr += aSubShapeObject->GetStudyEntry();
+  aStr += "\"), ";
+  aStr += aHypoSO->GetID();
+  aStr += ")";
+
+  _gen_i->AddToPythonScript(_gen_i->GetCurrentStudy()->StudyId(), aStr);
+
+  aStr = "print \"AddHypothesis: \", status";
+  _gen_i->AddToPythonScript(_gen_i->GetCurrentStudy()->StudyId(), aStr);
+
   return ConvertHypothesisStatus(status);
 }
 
@@ -1050,9 +1067,19 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
 
 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
 {
-	SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( _impl );
+  // Update Python script
-	SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
+  SALOMEDS::SObject_var aSO =
-	return aMesh._retn();
+    SMESH_Gen_i::ObjectToSObject(_gen_i->GetCurrentStudy(), _this());
+  TCollection_AsciiString aStr ("mesh_editor = ");
+  aStr += aSO->GetID();
+  aStr += ".GetMeshEditor()";
+
+  _gen_i->AddToPythonScript(_gen_i->GetCurrentStudy()->StudyId(), aStr);
+
+  // Create MeshEditor
+  SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( _impl );
+  SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
+  return aMesh._retn();
 }
 
 //=============================================================================