X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_2smeshpy.cxx;h=60c0b2491a8bff050377059d5e62baf3a723e1e7;hb=fa3a593199ed2de967bebf43bd0a48858cbbd578;hp=4fa56d6ca8e4fce911d80ee1b0919fcceb5fdfd2;hpb=741e8ae5225418d849046be4680a9e3bfaeafa4d;p=modules%2Fsmesh.git

diff --git a/src/SMESH_I/SMESH_2smeshpy.cxx b/src/SMESH_I/SMESH_2smeshpy.cxx
index 4fa56d6ca..60c0b2491 100644
--- a/src/SMESH_I/SMESH_2smeshpy.cxx
+++ b/src/SMESH_I/SMESH_2smeshpy.cxx
@@ -196,8 +196,16 @@ namespace {
         cmd->Clear();
       return;
     }
-    // comment a command having not created args
-    for ( int iArg = cmd->GetNbArgs(); iArg; --iArg )
+    // check if an Object was created in the script
+    _AString comment;
+    const _pyID& obj = cmd->GetObject();
+    if ( !obj.IsEmpty() && cmd->IsStudyEntry( obj ) && !presentObjects.count( obj ))
+    {
+      comment = "not created Object";
+      theGen->ObjectCreationRemoved( obj );
+    }
+    // check if a command has not created args
+    for ( int iArg = cmd->GetNbArgs(); iArg && comment.IsEmpty(); --iArg )
     {
       const _pyID& arg = cmd->GetArg( iArg );
       if ( arg.IsEmpty() || arg.Value( 1 ) == '"' || arg.Value( 1 ) == '\'' )
@@ -207,34 +215,29 @@ namespace {
       for ( ; id != idList.end(); ++id )
         if ( !theGen->IsGeomObject( *id ) && !presentObjects.count( *id ))
         {
-          cmd->Comment();
-          cmd->GetString() += " ### " ;
-          cmd->GetString() += *id + " has not been yet created";
-          for ( int i = 0; i < cmd->GetNbResultValues(); i++ ) {
-            _pyID objID = cmd->GetResultValue( i+1 );
-            theGen->ObjectCreationRemoved( objID ); // objID.SetName( name ) is not needed
-          }
-          return;
+          comment += *id + " has not been yet created";
+          break;
         }
     }
-    // comment a command having not created Object
-    const _pyID& obj = cmd->GetObject();
-    if ( !obj.IsEmpty() && cmd->IsStudyEntry( obj ) && !presentObjects.count( obj ))
+    // treat result objects
+    const _pyID& result = cmd->GetResultValue();
+    if ( !result.IsEmpty() && result.Value( 1 ) != '"' && result.Value( 1 ) != '\'' )
+    {
+      list< _pyID > idList = cmd->GetStudyEntries( result );
+      list< _pyID >::iterator id = idList.begin();
+      for ( ; id != idList.end(); ++id )
+        if ( comment.IsEmpty() )
+          presentObjects.insert( *id );
+        else
+          theGen->ObjectCreationRemoved( *id ); // objID.SetName( name ) is not needed
+    }
+    // comment the command
+    if ( !comment.IsEmpty() )
     {
       cmd->Comment();
-      cmd->GetString() += " ### not created object" ;
-      for ( int i = 0; i < cmd->GetNbResultValues(); i++ ) {
-        _pyID objID = cmd->GetResultValue( i+1 );
-        theGen->ObjectCreationRemoved( objID ); // objID.SetName( name ) is not needed
-      }
+      cmd->GetString() += " ### ";
+      cmd->GetString() += comment;
     }
-    const _pyID& result = cmd->GetResultValue();
-    if ( result.IsEmpty() || result.Value( 1 ) == '"' || result.Value( 1 ) == '\'' )
-      return;
-    list< _pyID > idList = cmd->GetStudyEntries( result );
-    list< _pyID >::iterator id = idList.begin();
-    for ( ; id != idList.end(); ++id )
-      presentObjects.insert( *id );
   }
 
   //================================================================================
@@ -307,6 +310,8 @@ namespace {
       undef2newItems[ 44 ].push_back( 37 );
       undef2newItems[ 45 ].push_back( 36 );
       undef2newItems[ 46 ].push_back( 39 );
+
+      ASSERT( undef2newItems.rbegin()->first == SMESH::FT_Undefined );
     }
 
     int iType     = Type.IntegerValue();
@@ -342,6 +347,91 @@ namespace {
       BinaryOp = TCollection_AsciiString( iBinaryOp );
     }
   }
+
+  //================================================================================
+  /*!
+   * \brief Replaces "SMESH.PointStruct(x,y,z)" and "SMESH.DirStruct( SMESH.PointStruct(x,y,z))"
+   *        arguments of a given command by a list "[x,y,z]" if the list is accesible
+   *        type of argument.
+   */
+  //================================================================================
+
+  void StructToList( Handle( _pyCommand)& theCommand )
+  {
+    static TStringSet methodsAcceptingList;
+    if ( methodsAcceptingList.empty() ) {
+      const char * methodNames[] = {
+        "GetCriterion","Reorient2D","ExtrusionSweep","ExtrusionSweepMakeGroups0D",
+        "ExtrusionSweepMakeGroups","ExtrusionSweep0D",
+        "AdvancedExtrusion","AdvancedExtrusionMakeGroups",
+        "ExtrusionSweepObject","ExtrusionSweepObject0DMakeGroups",
+        "ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
+        "ExtrusionSweepObject1D","ExtrusionSweepObject1DMakeGroups",
+        "ExtrusionSweepObject2D","ExtrusionSweepObject2DMakeGroups",
+        "Translate","TranslateMakeGroups","TranslateMakeMesh",
+        "TranslateObject","TranslateObjectMakeGroups", "TranslateObjectMakeMesh",
+        "ExtrusionAlongPathX","ExtrusionAlongPathObjX"
+        ,"" }; // <- mark of the end
+      methodsAcceptingList.Insert( methodNames );
+    }
+    if ( methodsAcceptingList.Contains( theCommand->GetMethod() ))
+    {
+      for ( int i = theCommand->GetNbArgs(); i > 0; --i )
+      {
+        const _AString & arg = theCommand->GetArg( i );
+        if ( arg.Search( "SMESH.PointStruct" ) == 1 ||
+             arg.Search( "SMESH.DirStruct"   ) == 1 )
+        {
+          Handle(_pyCommand) workCmd = new _pyCommand( arg );
+          if ( workCmd->GetNbArgs() == 1 ) // SMESH.DirStruct( SMESH.PointStruct(x,y,z))
+          {
+            workCmd = new _pyCommand( workCmd->GetArg( 1 ) );
+          }
+          if ( workCmd->GetNbArgs() == 3 ) // SMESH.PointStruct(x,y,z)
+          {
+            _AString newArg = "[ ";
+            newArg += ( workCmd->GetArg( 1 ) + ", " +
+                        workCmd->GetArg( 2 ) + ", " +
+                        workCmd->GetArg( 3 ) + " ]");
+            theCommand->SetArg( i, newArg );
+          }
+        }
+      }
+    }
+  }
+  //================================================================================
+  /*!
+   * \brief Replaces "mesh.GetIDSource([id1,id2])" argument of a given command by
+   *        a list "[id1,id2]" if the list is an accesible type of argument.
+   */
+  //================================================================================
+
+  void GetIDSourceToList( Handle( _pyCommand)& theCommand )
+  {
+    static TStringSet methodsAcceptingList;
+    if ( methodsAcceptingList.empty() ) {
+      const char * methodNames[] = {
+        "ExportPartToMED","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
+        "ExportCGNS","ExportGMF",
+        "Create0DElementsOnAllNodes","Reorient2D","QuadTo4Tri",
+        "ScaleMakeGroups","Scale","ScaleMakeMesh",
+        "FindCoincidentNodesOnPartBut","DoubleElements"
+        ,"" }; // <- mark of the end
+      methodsAcceptingList.Insert( methodNames );
+    }
+    if ( methodsAcceptingList.Contains( theCommand->GetMethod() ))
+    {
+      for ( int i = theCommand->GetNbArgs(); i > 0; --i )
+      {
+        _pyCommand argCmd( theCommand->GetArg( i ));
+        if ( argCmd.GetMethod() == "GetIDSource" &&
+             argCmd.GetNbArgs() == 2 )
+        {
+          theCommand->SetArg( i, argCmd.GetArg( 1 ));
+        }
+      }
+    }
+  }
 }
 
 //================================================================================
@@ -532,10 +622,23 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
 
   // Prevent moving a command creating a sub-mesh to the end of the script
   // if the sub-mesh is used in theCommand as argument
-  if ( _pySubMesh::CanBeArgOfMethod( aCommand->GetMethod() ))
-  {
-    PlaceSubmeshAfterItsCreation( aCommand );
-  }
+  // if ( _pySubMesh::CanBeArgOfMethod( aCommand->GetMethod() ))
+  // {
+  //   PlaceSubmeshAfterItsCreation( aCommand );
+  // }
+
+  // Method( SMESH.PointStruct(x,y,z)... -> Method( [x,y,z]...
+  StructToList( aCommand );
+
+  // not to erase _pySelfEraser's etc. used as args in some commands
+  std::list< _pyID >::const_iterator id = myKeepAgrCmdsIDs.begin();
+  for ( ; id != myKeepAgrCmdsIDs.end(); ++id )
+    if ( *id != objID && theCommand.Search( *id ) > id->Length() )
+    {
+      Handle(_pyObject) obj = FindObject( *id );
+      if ( !obj.IsNull() )
+        obj->AddArgCmd( aCommand );
+    }
 
   // Find an object to process theCommand
 
@@ -543,6 +646,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
   if ( objID == this->GetID() || objID == SMESH_2smeshpy::GenName())
   {
     this->Process( aCommand );
+    //addFilterUser( aCommand, theGen ); // protect filters from clearing
     return aCommand;
   }
 
@@ -563,9 +667,15 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
     else if ( aCommand->GetMethod() == "GetSubMesh" ) { // SubMesh creation
       _pyID subMeshID = aCommand->GetResultValue();
       Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand );
+      CheckObjectIsReCreated( subMesh );
       myObjects.insert( make_pair( subMeshID, subMesh ));
     }
 
+    // Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2]
+    GetIDSourceToList( aCommand );
+
+    //addFilterUser( aCommand, theGen ); // protect filters from clearing
+
     id_mesh->second->Process( aCommand );
     id_mesh->second->AddProcessedCmd( aCommand );
     return aCommand;
@@ -575,6 +685,11 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
   map< _pyID, Handle(_pyMeshEditor) >::iterator id_editor = myMeshEditors.find( objID );
   if ( id_editor != myMeshEditors.end() )
   {
+    // Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2]
+    GetIDSourceToList( aCommand );
+
+    //addFilterUser( aCommand, theGen ); // protect filters from clearing
+
     const TCollection_AsciiString& method = aCommand->GetMethod();
 
     // some commands of SMESH_MeshEditor create meshes and groups
@@ -613,8 +728,9 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
          !myMeshes.count( meshID ) &&
          aCommand->IsStudyEntry( meshID ))
     {
-      TCollection_AsciiString processedCommand = aCommand->GetString();
+      _AString processedCommand = aCommand->GetString();
       Handle(_pyMesh) mesh = new _pyMesh( aCommand, meshID );
+      CheckObjectIsReCreated( mesh );
       myMeshes.insert( make_pair( meshID, mesh ));
       aCommand->Clear();
       aCommand->GetString() = processedCommand; // discard changes made by _pyMesh
@@ -640,13 +756,13 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
   } // SMESH_MeshEditor methods
 
   // SMESH_Hypothesis method?
-  list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
-  for ( ; hyp != myHypos.end(); ++hyp )
-    if ( !(*hyp)->IsAlgo() && objID == (*hyp)->GetID() ) {
-      (*hyp)->Process( aCommand );
-      (*hyp)->AddProcessedCmd( aCommand );
-      return aCommand;
-    }
+  Handle(_pyHypothesis) hyp = FindHyp( objID );
+  if ( !hyp.IsNull() && !hyp->IsAlgo() )
+  {
+    hyp->Process( aCommand );
+    hyp->AddProcessedCmd( aCommand );
+    return aCommand;
+  }
 
   // aFilterManager.CreateFilter() ?
   if ( aCommand->GetMethod() == "CreateFilter" )
@@ -661,6 +777,14 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
     Handle(_pyObject) filter( new _pyFilter( aCommand, newID ));
     AddObject( filter );
   }
+  // aFreeNodes0x5011f80 = aFilterManager.CreateFreeNodes() ## issue 0020976
+  else if ( theCommand.Search( "aFilterManager.Create" ) > 0 )
+  {
+    // create _pySelfEraser for functors
+    Handle(_pySelfEraser) functor = new _pySelfEraser( aCommand );
+    functor->IgnoreOwnCalls(); // to erase if not used as an argument
+    AddObject( functor );
+  }
 
   // other object method?
   map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.find( objID );
@@ -719,6 +843,9 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
     UnaryOp  = SMESH + SMESH::FunctorTypeToString( SMESH::FunctorType( UnaryOp.IntegerValue() ));
     BinaryOp = SMESH + SMESH::FunctorTypeToString( SMESH::FunctorType( BinaryOp.IntegerValue() ));
 
+    if ( Compare == "SMESH.FT_EqualTo" )
+      Compare = "'='";
+
     aCommand->RemoveArgs();
     aCommand->SetObject( SMESH_2smeshpy::GenName() );
     aCommand->SetMethod( "GetCriterion" );
@@ -808,7 +935,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
   if ( method == "CreateMesh" || method == "CreateEmptyMesh")
   {
     Handle(_pyMesh) mesh = new _pyMesh( theCommand );
-    myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+    AddObject( mesh );
     return;
   }
   if ( method == "CreateMeshesFromUNV" ||
@@ -816,7 +943,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
        method == "CopyMesh" ) // command result is a mesh
   {
     Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
-    myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+    AddObject( mesh );
     return;
   }
   if( method == "CreateMeshesFromMED" ||
@@ -829,7 +956,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
       _pyID meshID = theCommand->GetResultValue(ind+1);
       if ( !theCommand->IsStudyEntry( meshID ) ) continue;
       Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1));
-      myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+      AddObject( mesh );
     }
     if ( method == "CreateMeshesFromGMF" )
     {
@@ -847,13 +974,16 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
     // issue 199929, remove standard library name (default parameter)
     const TCollection_AsciiString & aLibName = theCommand->GetArg( 2 );
     if ( aLibName.Search( "StdMeshersEngine" ) != -1 ) {
-      // keep first argument
+      // keep the first argument
       TCollection_AsciiString arg = theCommand->GetArg( 1 );
       theCommand->RemoveArgs();
       theCommand->SetArg( 1, arg );
     }
 
-    myHypos.push_back( _pyHypothesis::NewHypothesis( theCommand ));
+    Handle(_pyHypothesis) hyp = _pyHypothesis::NewHypothesis( theCommand );
+    CheckObjectIsReCreated( hyp );
+    myHypos.insert( make_pair( hyp->GetID(), hyp ));
+
     return;
   }
 
@@ -890,7 +1020,8 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
   // SMESH_Pattern, FilterManager
   if ( method == "GetPattern" ||
        method == "CreateFilterManager" ||
-       method == "CreateMeasurements" ) {
+       method == "CreateMeasurements" )
+  {
     Handle(_pyObject) obj = new _pySelfEraser( theCommand );
     if ( !myObjects.insert( make_pair( obj->GetID(), obj )).second )
       theCommand->Clear(); // already created
@@ -903,7 +1034,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
       theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" );
     }
     Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
-    myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+    AddObject( mesh );
     AddMeshAccessorMethod( theCommand );
   }
   else if ( method == "SetName" ) // SetName(obj,name)
@@ -947,15 +1078,15 @@ void _pyGen::Flush()
 
   map< _pyID, Handle(_pyMesh) >::iterator id_mesh;
   map< _pyID, Handle(_pyObject) >::iterator id_obj;
-  list< Handle(_pyHypothesis) >::iterator hyp;
+  map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp;
 
   if ( IsToKeepAllCommands() ) // historical dump
   {
     // set myIsPublished = true to all objects
     for ( id_mesh = myMeshes.begin(); id_mesh != myMeshes.end(); ++id_mesh )
       id_mesh->second->SetRemovedFromStudy( false );
-    for ( hyp = myHypos.begin(); hyp != myHypos.end(); ++hyp )
-      (*hyp)->SetRemovedFromStudy( false );
+    for ( id_hyp = myHypos.begin(); id_hyp != myHypos.end(); ++id_hyp )
+      id_hyp->second->SetRemovedFromStudy( false );
     for ( id_obj = myObjects.begin(); id_obj != myObjects.end(); ++id_obj )
       id_obj->second->SetRemovedFromStudy( false );
   }
@@ -964,9 +1095,9 @@ void _pyGen::Flush()
     // let hypotheses find referred objects in order to prevent clearing
     // not published referred hyps (it's needed for hyps like "LayerDistribution")
     list< Handle(_pyMesh) > fatherMeshes;
-    for ( hyp = myHypos.begin(); hyp != myHypos.end(); ++hyp )
-      if ( !hyp->IsNull() )
-        (*hyp)->GetReferredMeshesAndGeom( fatherMeshes );
+    for ( id_hyp = myHypos.begin(); id_hyp != myHypos.end(); ++id_hyp )
+      if ( !id_hyp->second.IsNull() )
+        id_hyp->second->GetReferredMeshesAndGeom( fatherMeshes );
   }
   // set myIsPublished = false to all objects depending on
   // meshes built on a removed geometry
@@ -980,12 +1111,12 @@ void _pyGen::Flush()
       id_mesh->second->Flush();
 
   // Flush hyps
-  for ( hyp = myHypos.begin(); hyp != myHypos.end(); ++hyp )
-    if ( !hyp->IsNull() ) {
-      (*hyp)->Flush();
+  for ( id_hyp = myHypos.begin(); id_hyp != myHypos.end(); ++id_hyp )
+    if ( !id_hyp->second.IsNull() ) {
+      id_hyp->second->Flush();
       // smeshgen.CreateHypothesis() --> smesh.CreateHypothesis()
-      if ( !(*hyp)->IsWrapped() )
-        (*hyp)->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() );
+      if ( !id_hyp->second->IsWrapped() )
+        id_hyp->second->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() );
     }
 
   // Flush other objects
@@ -1037,10 +1168,10 @@ void _pyGen::ClearCommands()
   for ( ; id_mesh != myMeshes.end(); ++id_mesh )
     id_mesh->second->ClearCommands();
 
-  list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
-  for ( ; hyp != myHypos.end(); ++hyp )
-    if ( !hyp->IsNull() )
-      (*hyp)->ClearCommands();
+  map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.begin();
+  for ( ; id_hyp != myHypos.end(); ++id_hyp )
+    if ( !id_hyp->second.IsNull() )
+      id_hyp->second->ClearCommands();
 
   map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.begin();
   for ( ; id_obj != myObjects.end(); ++id_obj )
@@ -1070,10 +1201,10 @@ void _pyGen::Free()
     id_obj->second->Free();
   myObjects.clear();
 
-  list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
-  for ( ; hyp != myHypos.end(); ++hyp )
-    if ( !hyp->IsNull() )
-      (*hyp)->Free();
+  map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.begin();
+  for ( ; id_hyp != myHypos.end(); ++id_hyp )
+    if ( !id_hyp->second.IsNull() )
+      id_hyp->second->Free();
   myHypos.clear();
 
   myFile2ExportedMesh.clear();
@@ -1109,12 +1240,14 @@ bool _pyGen::AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const
 bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const
 {
   bool added = false;
-  list< Handle(_pyHypothesis) >::const_iterator hyp = myHypos.begin();
-  for ( ; hyp != myHypos.end(); ++hyp ) {
-    if ( (*hyp)->IsAlgo() && /*(*hyp)->IsWrapped() &&*/
-         theCmd->AddAccessorMethod( (*hyp)->GetID(), (*hyp)->AccessorMethod() ))
+  map< _pyID, Handle(_pyHypothesis) >::const_iterator id_hyp = myHypos.begin();
+  for ( ; id_hyp != myHypos.end(); ++id_hyp )
+    if ( !id_hyp->second.IsNull() &&
+         id_hyp->second->IsAlgo() && /*(*hyp)->IsWrapped() &&*/
+         theCmd->AddAccessorMethod( id_hyp->second->GetID(),
+                                    id_hyp->second->AccessorMethod() ))
       added = true;
-  }
+
   return added;
 }
 
@@ -1128,19 +1261,20 @@ bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const
 
 Handle(_pyHypothesis) _pyGen::FindHyp( const _pyID& theHypID )
 {
-  list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
-  for ( ; hyp != myHypos.end(); ++hyp )
-    if ( !hyp->IsNull() && theHypID == (*hyp)->GetID() )
-      return *hyp;
+  map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.find( theHypID );
+  if ( id_hyp != myHypos.end() &&
+       !id_hyp->second.IsNull() &&
+       theHypID == id_hyp->second->GetID() )
+    return id_hyp->second;
   return Handle(_pyHypothesis)();
 }
 
 //================================================================================
 /*!
- * \brief Find algorithm the created algorithm
+ * \brief Find algorithm able to create a hypothesis
   * \param theGeom - The shape ID the algorithm was created on
   * \param theMesh - The mesh ID that created the algorithm
-  * \param dim - The algo dimension
+  * \param theHypothesis - The hypothesis the algorithm sould be able to create
   * \retval Handle(_pyHypothesis) - The found algo
  */
 //================================================================================
@@ -1148,15 +1282,15 @@ Handle(_pyHypothesis) _pyGen::FindHyp( const _pyID& theHypID )
 Handle(_pyHypothesis) _pyGen::FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
                                         const Handle(_pyHypothesis)& theHypothesis )
 {
-  list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
-  for ( ; hyp != myHypos.end(); ++hyp )
-    if ( !hyp->IsNull() &&
-         (*hyp)->IsAlgo() &&
-         theHypothesis->CanBeCreatedBy( (*hyp)->GetAlgoType() ) &&
-         (*hyp)->GetGeom() == theGeom &&
-         (*hyp)->GetMesh() == theMesh )
-      return *hyp;
-  return 0;
+  map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.begin();
+  for ( ; id_hyp != myHypos.end(); ++id_hyp )
+    if ( !id_hyp->second.IsNull() &&
+         id_hyp->second->IsAlgo() &&
+         theHypothesis->CanBeCreatedBy( id_hyp->second->GetAlgoType() ) &&
+         id_hyp->second->GetGeom() == theGeom &&
+         id_hyp->second->GetMesh() == theMesh )
+      return id_hyp->second;
+  return Handle(_pyHypothesis)();
 }
 
 //================================================================================
@@ -1250,6 +1384,37 @@ void _pyGen::setNeighbourCommand( Handle(_pyCommand)& theCmd,
     (*pos)->SetOrderNb( i++ );
 }
 
+//================================================================================
+/*!
+ * \brief Call _pyFilter.AddUser() if a filter is used as a command arg
+ */
+//================================================================================
+
+// void _pyGen::addFilterUser( Handle(_pyCommand)& theCommand, const Handle(_pyObject)& user )
+// {
+  // No more needed after adding _pyObject::myArgCommands
+
+//   const char filterPrefix[] = "aFilter0x";
+//   if ( theCommand->GetString().Search( filterPrefix ) < 1 )
+//     return;
+
+//   for ( int i = theCommand->GetNbArgs(); i > 0; --i )
+//   {
+//     const _AString & arg = theCommand->GetArg( i );
+//     // NOT TREATED CASE: arg == "[something, aFilter0x36a2f60]"
+//     if ( arg.Search( filterPrefix ) != 1 )
+//       continue;
+
+//     Handle(_pyFilter) filter = Handle(_pyFilter)::DownCast( FindObject( arg ));
+//     if ( !filter.IsNull() )
+//     {
+//       filter->AddUser( user );
+//       if ( !filter->GetNewID().IsEmpty() )
+//         theCommand->SetArg( i, filter->GetNewID() );
+//     }
+//   }
+//}
+
 //================================================================================
 /*!
  * \brief Set command be last in list of commands
@@ -1307,6 +1472,8 @@ void _pyGen::AddObject( Handle(_pyObject)& theObj )
 {
   if ( theObj.IsNull() ) return;
 
+  CheckObjectIsReCreated( theObj );
+
   if ( theObj->IsKind( STANDARD_TYPE( _pyMesh )))
     myMeshes.insert( make_pair( theObj->GetID(), Handle(_pyMesh)::DownCast( theObj )));
 
@@ -1317,6 +1484,41 @@ void _pyGen::AddObject( Handle(_pyObject)& theObj )
     myObjects.insert( make_pair( theObj->GetID(), theObj ));
 }
 
+//================================================================================
+/*!
+ * \brief Erases an existing object with the same ID. This method should be called
+ *        before storing theObj in _pyGen
+ */
+//================================================================================
+
+void _pyGen::CheckObjectIsReCreated( Handle(_pyObject)& theObj )
+{
+  if ( theObj.IsNull() || !_pyCommand::IsStudyEntry( theObj->GetID() ))
+    return;
+
+  const bool isHyp = theObj->IsKind( STANDARD_TYPE( _pyHypothesis ));
+  Handle(_pyObject) existing =
+    isHyp ? FindHyp( theObj->GetID() ) : FindObject( theObj->GetID() );
+  if ( !existing.IsNull() && existing != theObj )
+  {
+    existing->SetRemovedFromStudy( true );
+    existing->ClearCommands();
+    if ( isHyp )
+    {
+      if ( myHypos.count( theObj->GetID() ))
+        myHypos.erase( theObj->GetID() );
+    }
+    else if ( myMeshes.count( theObj->GetID() ))
+    {
+      myMeshes.erase( theObj->GetID() );
+    }
+    else if ( myObjects.count( theObj->GetID() ))
+    {
+      myObjects.erase( theObj->GetID() );
+    }
+  }
+}
+
 //================================================================================
 /*!
  * \brief Re-register an object with other ID to make it Process() commands of
@@ -1407,7 +1609,7 @@ bool _pyGen::IsNotPublished(const _pyID& theObjID) const
 
 //================================================================================
 /*!
- * \brief Remove object name from myObjectNames that leads to that SetName() for
+ * \brief Add an object to myRemovedObjIDs that leads to that SetName() for
  *        this object is not dumped
  *  \param [in] theObjID - entry of the object whose creation command was eliminated
  */
@@ -1616,39 +1818,77 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
     myGroups.push_back( group );
     theGen->AddObject( group );
   }
+  // ----------------------------------------------------------------------
   // update list of groups
   else if ( method == "GetGroups" )
   {
+    bool allGroupsRemoved = true;
     TCollection_AsciiString grIDs = theCommand->GetResultValue();
-    list< _pyID > idList = theCommand->GetStudyEntries( grIDs );
-    list< _pyID >::iterator grID = idList.begin();
+    list< _pyID >          idList = theCommand->GetStudyEntries( grIDs );
+    list< _pyID >::iterator  grID = idList.begin();
+    const int nbGroupsBefore = myGroups.size();
+    Handle(_pyObject) obj;
     for ( ; grID != idList.end(); ++grID )
     {
-      Handle(_pyObject) obj = theGen->FindObject( *grID );
+      obj = theGen->FindObject( *grID );
       if ( obj.IsNull() )
       {
         Handle(_pyGroup) group = new _pyGroup( theCommand, *grID );
         theGen->AddObject( group );
         myGroups.push_back( group );
+        obj = group;
       }
+      if ( !obj->CanClear() )
+        allGroupsRemoved = false;
+    }
+    if ( nbGroupsBefore == myGroups.size() ) // no new _pyGroup created
+      obj->AddProcessedCmd( theCommand ); // to clear theCommand if all groups are removed
+
+    if ( !allGroupsRemoved && !theGen->IsToKeepAllCommands() )
+    {
+      // check if the preceding command is Compute();
+      // if GetGroups() is just after Compute(), this can mean that the groups
+      // were created by some algorithm and hence Compute() should not be discarded
+      std::list< Handle(_pyCommand) >& cmdList = theGen->GetCommands();
+      std::list< Handle(_pyCommand) >::iterator cmd = cmdList.begin();
+      while ( (*cmd)->GetMethod() == "GetGroups" )
+        ++cmd;
+      if ( myLastComputeCmd == (*cmd))
+        // protect last Compute() from clearing by the next Compute()
+        myLastComputeCmd.Nullify();
     }
   }
+  // ----------------------------------------------------------------------
   // notify a group about full removal
-  else if ( method == "RemoveGroupWithContents" )
+  else if ( method == "RemoveGroupWithContents" ||
+            method == "RemoveGroup")
   {
     if ( !theGen->IsToKeepAllCommands() ) { // snapshot mode
       const _pyID groupID = theCommand->GetArg( 1 );
       Handle(_pyGroup) grp = Handle(_pyGroup)::DownCast( theGen->FindObject( groupID ));
       if ( !grp.IsNull() )
-        grp->RemovedWithContents();
+      {
+        if ( method == "RemoveGroupWithContents" )
+          grp->RemovedWithContents();
+        // to clear RemoveGroup() if the group creation is cleared
+        grp->AddProcessedCmd( theCommand );
+      }
     }
   }
   // ----------------------------------------------------------------------
   else if ( theCommand->MethodStartsFrom( "Export" ))
   {
-    if ( method == "ExportToMED" ||   // ExportToMED()  --> ExportMED()
-         method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED()
+    if ( method == "ExportToMED" ||  // ExportToMED()  --> ExportMED()
+         method == "ExportToMEDX" )  // ExportToMEDX() --> ExportMED()
+    {
       theCommand->SetMethod( "ExportMED" );
+      if ( theCommand->GetNbArgs() == 5 )
+      {
+        // ExportToMEDX(...,autoDimension) -> ExportToMEDX(...,meshPart=None,autoDimension)
+        _AString autoDimension = theCommand->GetArg( 5 );
+        theCommand->SetArg( 5, "None" );
+        theCommand->SetArg( 6, autoDimension );
+      }
     }
     else if ( method == "ExportCGNS" )
     { // ExportCGNS(part, ...) -> ExportCGNS(..., part)
@@ -1673,9 +1913,9 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
       TCollection_AsciiString newMethod = method;
       newMethod.Remove( 7, 6 );
       theCommand->SetMethod( newMethod );
-      // make the 1st arg be the last one
+      // make the 1st arg be the last one (or last but one for ExportMED())
       _pyID partID = theCommand->GetArg( 1 );
-      int nbArgs = theCommand->GetNbArgs();
+      int nbArgs = theCommand->GetNbArgs() - (newMethod == "ExportMED");
       for ( int i = 2; i <= nbArgs; ++i )
         theCommand->SetArg( i-1, theCommand->GetArg( i ));
       theCommand->SetArg( nbArgs, partID );
@@ -2060,29 +2300,36 @@ _pyMeshEditor::_pyMeshEditor(const Handle(_pyCommand)& theCreationCmd):
 
 void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
 {
-  // names of SMESH_MeshEditor methods fully equal to methods of the python class Mesh, so
-  // commands calling this methods are converted to calls of Mesh methods
+  // Names of SMESH_MeshEditor methods fully equal to methods of the python class Mesh, so
+  // commands calling these methods are converted to calls of Mesh methods without
+  // additional modifs, only object is changed from MeshEditor to Mesh.
   static TStringSet sameMethods;
   if ( sameMethods.empty() ) {
     const char * names[] = {
-      "RemoveElements","RemoveNodes","RemoveOrphanNodes","AddNode","Add0DElement","AddEdge","AddFace","AddPolygonalFace","AddBall",
-      "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","MoveNode", "MoveClosestNodeToPoint",
+      "RemoveElements","RemoveNodes","RemoveOrphanNodes",
+      "AddNode","Add0DElement","AddEdge","AddFace","AddPolygonalFace","AddBall",
+      "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces",
+      "MoveNode", "MoveClosestNodeToPoint",
       "InverseDiag","DeleteDiag","Reorient","ReorientObject",
       "TriToQuad","TriToQuadObject", "QuadTo4Tri", "SplitQuad","SplitQuadObject",
       "BestSplit","Smooth","SmoothObject","SmoothParametric","SmoothParametricObject",
       "ConvertToQuadratic","ConvertFromQuadratic","RenumberNodes","RenumberElements",
       "RotationSweep","RotationSweepObject","RotationSweepObject1D","RotationSweepObject2D",
-      "ExtrusionSweep","AdvancedExtrusion","ExtrusionSweepObject","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
-      "ExtrusionAlongPath","ExtrusionAlongPathObject","ExtrusionAlongPathX",
-      "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
+      "ExtrusionSweep","AdvancedExtrusion","ExtrusionSweepObject","ExtrusionSweepObject1D",
+      "ExtrusionSweepObject2D","ExtrusionAlongPath","ExtrusionAlongPathObject",
+      "ExtrusionAlongPathX","ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
       "Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject",
-      "FindCoincidentNodes",/*"FindCoincidentNodesOnPart",*/"MergeNodes","FindEqualElements",
+      "FindCoincidentNodes","MergeNodes","FindEqualElements",
       "MergeElements","MergeEqualElements","SewFreeBorders","SewConformFreeBorders",
       "SewBorderToSide","SewSideElements","ChangeElemNodes","GetLastCreatedNodes",
       "GetLastCreatedElems",
-      "MirrorMakeMesh","MirrorObjectMakeMesh","TranslateMakeMesh",
-      "TranslateObjectMakeMesh","RotateMakeMesh","RotateObjectMakeMesh","MakeBoundaryMesh",
-      "MakeBoundaryElements", "SplitVolumesIntoTetra"
+      "MirrorMakeMesh","MirrorObjectMakeMesh","TranslateMakeMesh","TranslateObjectMakeMesh",
+      "Scale","ScaleMakeMesh","RotateMakeMesh","RotateObjectMakeMesh","MakeBoundaryMesh",
+      "MakeBoundaryElements", "SplitVolumesIntoTetra",
+      "DoubleElements","DoubleNodes","DoubleNode","DoubleNodeGroup","DoubleNodeGroups",
+      "DoubleNodeElem","DoubleNodeElemInRegion","DoubleNodeElemGroup",
+      "DoubleNodeElemGroupInRegion","DoubleNodeElemGroups","DoubleNodeElemGroupsInRegion",
+      "DoubleNodesOnGroupBoundaries","CreateFlatElementsOnFacesGroups","CreateHoleSkin"
       ,"" }; // <- mark of the end
     sameMethods.Insert( names );
   }
@@ -2107,7 +2354,7 @@ void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
   if (diffLastTwoArgsMethods.empty() ) {
     const char * names[] = {
       "MirrorMakeGroups","MirrorObjectMakeGroups",
-      "TranslateMakeGroups","TranslateObjectMakeGroups",
+      "TranslateMakeGroups","TranslateObjectMakeGroups","ScaleMakeGroups",
       "RotateMakeGroups","RotateObjectMakeGroups",
       ""};// <- mark of the end
     diffLastTwoArgsMethods.Insert( names );
@@ -3172,6 +3419,7 @@ int _pyCommand::GetBegPos( int thePartIndex )
     return EMPTY;
   if ( myBegPos.Length() < thePartIndex )
     return UNKNOWN;
+  ASSERT( thePartIndex > 0 );
   return myBegPos( thePartIndex );
 }
 
@@ -3187,6 +3435,7 @@ void _pyCommand::SetBegPos( int thePartIndex, int thePosition )
 {
   while ( myBegPos.Length() < thePartIndex )
     myBegPos.Append( UNKNOWN );
+  ASSERT( thePartIndex > 0 );
   myBegPos( thePartIndex ) = thePosition;
 }
 
@@ -3298,7 +3547,7 @@ const TCollection_AsciiString & _pyCommand::GetObject()
   if ( GetBegPos( OBJECT_IND ) == UNKNOWN )
   {
     // beginning
-    int begPos = GetBegPos( RESULT_IND ) + myRes.Length();
+    int begPos = GetBegPos( RESULT_IND );
     if ( begPos < 1 ) {
       begPos = myString.Location( "=", 1, Length() ) + 1;
       // is '=' in the string argument (for example, name) or not
@@ -3315,6 +3564,9 @@ const TCollection_AsciiString & _pyCommand::GetObject()
       if ( nb1 % 2 != 0 || nb2 % 2 != 0 )
         begPos = 1;
     }
+    else {
+      begPos += myRes.Length();
+    }
     myObj = GetWord( myString, begPos, true );
     if ( begPos != EMPTY )
     {
@@ -3717,7 +3969,7 @@ void _pyCommand::Comment()
   if ( i <= Length() )
   {
     myString.Insert( i, "#" );
-    for ( int iPart = 0; iPart < myBegPos.Length(); ++iPart )
+    for ( int iPart = 1; iPart <= myBegPos.Length(); ++iPart )
     {
       int begPos = GetBegPos( iPart + 1 );
       if ( begPos != UNKNOWN )
@@ -3865,19 +4117,48 @@ _pyID _pyObject::FatherID(const _pyID & childID)
  */
 //================================================================================
 
+_pySelfEraser::_pySelfEraser(const Handle(_pyCommand)& theCreationCmd)
+  :_pyObject(theCreationCmd), myIgnoreOwnCalls(false)
+{
+  myIsPublished = true; // prevent clearing as a not published
+  theGen->KeepAgrCmds( GetID() ); // ask to fill myArgCmds
+}
+
+//================================================================================
+/*!
+ * \brief SelfEraser erases creation command if no more it's commands invoked
+ */
+//================================================================================
+
 void _pySelfEraser::Flush()
 {
-  int nbCalls = GetNbCalls();
-  if ( nbCalls > 0 )
+  bool toErase = false;
+  if ( myIgnoreOwnCalls ) // check if this obj is used as argument
   {
-    // ignore cleared commands
-    std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
-    std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
-    for ( ; cmd != cmds.end(); ++cmd )
-      nbCalls -= (*cmd)->IsEmpty();
+    int nbArgUses = 0;
+    list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
+    for ( ; cmd != myArgCmds.end(); ++cmd )
+      nbArgUses += !(*cmd)->IsEmpty();
+    toErase = ( nbArgUses < 1 );
+  }
+  else
+  {
+    int nbCalls = GetNbCalls();
+    if ( nbCalls > 0 )
+    {
+      // ignore cleared commands
+      std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
+      std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
+      for ( ; cmd != cmds.end(); ++cmd )
+        nbCalls -= (*cmd)->IsEmpty();
+    }
+    toErase = ( nbCalls < 1 );
+  }
+  if ( toErase )
+  {
+    myIsPublished = false;
+    _pyObject::ClearCommands();
   }
-  if ( nbCalls < 1 )
-    GetCreationCmd()->Clear();
 }
 
 //================================================================================
@@ -3890,6 +4171,7 @@ _pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd):
   _pyObject(theCreationCmd)
 {
   myMesh = ObjectToMesh( theGen->FindObject( theCreationCmd->GetObject() ));
+  theGen->KeepAgrCmds( GetID() ); // ask to fill myArgCmds
 }
 
 //================================================================================
@@ -3900,39 +4182,40 @@ _pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd):
 
 bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
 {
-  // names of all methods where a sub-mesh can be used as argument
-  static TStringSet methods;
-  if ( methods.empty() ) {
-    const char * names[] = {
-      // methods of SMESH_Gen
-      "CopyMesh",
-      // methods of SMESH_Group
-      "AddFrom",
-      // methods of SMESH_Measurements
-      "MinDistance",
-      // methods of SMESH_Mesh
-      "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
-      "RemoveSubMesh",
-      // methods of SMESH_MeshEditor
-      "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
-      "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
-      "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
-      "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
-      "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
-      "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
-      "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
-      "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
-      "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
-      "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
-      "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
-      "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
-      "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
-      "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
-      "MakeBoundaryMesh","Create0DElementsOnAllNodes",
-      "" }; // <- mark of end
-    methods.Insert( names );
-  }
-  return methods.Contains( theMethodName );
+  return false;
+//   // names of all methods where a sub-mesh can be used as argument
+//   static TStringSet methods;
+//   if ( methods.empty() ) {
+//     const char * names[] = {
+//       // methods of SMESH_Gen
+//       "CopyMesh",
+//       // methods of SMESH_Group
+//       "AddFrom",
+//       // methods of SMESH_Measurements
+//       "MinDistance",
+//       // methods of SMESH_Mesh
+//       "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
+//       "RemoveSubMesh",
+//       // methods of SMESH_MeshEditor
+//       "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
+//       "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
+//       "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
+//       "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
+//       "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
+//       "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
+//       "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
+//       "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
+//       "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
+//       "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
+//       "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
+//       "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
+//       "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
+//       "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
+//       "MakeBoundaryMesh","Create0DElementsOnAllNodes",
+//       "" }; // <- mark of end
+//     methods.Insert( names );
+//   }
+//   return methods.Contains( theMethodName );
 }
 
 //================================================================================
@@ -3944,7 +4227,6 @@ bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
 void _pySubMesh::Process( const Handle(_pyCommand)& theCommand )
 {
   _pyObject::Process(theCommand); // count calls of Process()
-  GetCreationCmd()->AddDependantCmd( theCommand );
 }
 
 //================================================================================
@@ -3955,11 +4237,17 @@ void _pySubMesh::Process( const Handle(_pyCommand)& theCommand )
 
 void _pySubMesh::Flush()
 {
-  if ( GetNbCalls() == 0 ) // move to the end of all commands
+  if ( GetNbCalls() == 0 && myArgCmds.empty() ) // move to the end of all commands
     theGen->GetLastCommand()->AddDependantCmd( GetCreationCmd() );
   else if ( !myCreator.IsNull() )
     // move to be just after creator
     myCreator->GetCreationCmd()->AddDependantCmd( GetCreationCmd() );
+
+  // move sub-mesh usage after creation cmd
+  list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
+  for ( ; cmd != myArgCmds.end(); ++cmd )
+    if ( !(*cmd)->IsEmpty() )
+      GetCreationCmd()->AddDependantCmd( *cmd );
 }
 
 //================================================================================
@@ -4014,10 +4302,14 @@ _pyGroup::_pyGroup(const Handle(_pyCommand)& theCreationCmd, const _pyID & id)
     {
       if ( !filter->GetNewID().IsEmpty() )
         theCreationCmd->SetArg( 3, filter->GetNewID() );
-      filter->AddUser( this );
+      //filter->AddUser( this );
     }
     myFilter = filter;
   }
+  else if ( method == "GetGroups" )
+  {
+    myCanClearCreationCmd = ( theCreationCmd->GetNbResultValues() == 1 );
+  }
   else
   {
     // theCreationCmd does something else apart from creation of this group
@@ -4026,6 +4318,47 @@ _pyGroup::_pyGroup(const Handle(_pyCommand)& theCreationCmd, const _pyID & id)
   }
 }
 
+//================================================================================
+/*!
+ * \brief Check if "[ group1, group2 ] = mesh.GetGroups()" creation command 
+ *        can be cleared
+ */
+//================================================================================
+
+bool _pyGroup::CanClear()
+{
+  if ( IsInStudy() )
+    return false;
+
+  if ( !myCanClearCreationCmd &&
+       !myCreationCmd.IsNull() &&
+       myCreationCmd->GetMethod() == "GetGroups" )
+  {
+    TCollection_AsciiString grIDs = myCreationCmd->GetResultValue();
+    list< _pyID >          idList = myCreationCmd->GetStudyEntries( grIDs );
+    list< _pyID >::iterator  grID = idList.begin();
+    if ( GetID() == *grID )
+    {
+      myCanClearCreationCmd = true;
+      list< Handle(_pyGroup ) > groups;
+      for ( ; grID != idList.end(); ++grID )
+      {
+        Handle(_pyGroup) group = Handle(_pyGroup)::DownCast( theGen->FindObject( *grID ));
+        if ( group.IsNull() ) continue;
+        groups.push_back( group );
+        if ( group->IsInStudy() )
+          myCanClearCreationCmd = false;
+      }
+      // set myCanClearCreationCmd == true to all groups
+      list< Handle(_pyGroup ) >::iterator group = groups.begin();
+      for ( ; group != groups.end(); ++group )
+        (*group)->myCanClearCreationCmd = myCanClearCreationCmd;
+    }
+  }
+
+  return myCanClearCreationCmd;
+}
+
 //================================================================================
 /*!
  * \brief set myCanClearCreationCmd = true if the main action of the creation
@@ -4085,6 +4418,7 @@ void _pyGroup::Process( const Handle(_pyCommand)& theCommand)
       makeGroupCmd->SetMethod( "MakeGroupByFilter" );
       makeGroupCmd->SetArg( 1, name );
       makeGroupCmd->SetArg( 2, idSource );
+      filter->AddArgCmd( makeGroupCmd );
     }
   }
   else if ( theCommand->GetMethod() == "SetFilter" )
@@ -4109,8 +4443,8 @@ void _pyGroup::Process( const Handle(_pyCommand)& theCommand)
     }
   }
 
-  if ( !filter.IsNull() )
-    filter->AddUser( this );
+  // if ( !filter.IsNull() )
+  //   filter->AddUser( this );
 
   theGen->AddMeshAccessorMethod( theCommand );
 }
@@ -4124,7 +4458,7 @@ void _pyGroup::Process( const Handle(_pyCommand)& theCommand)
 void _pyGroup::Flush()
 {
   if ( !theGen->IsToKeepAllCommands() &&
-       myCreationCmd && !myCanClearCreationCmd )
+       !myCreationCmd.IsNull() && !myCanClearCreationCmd )
   {
     myCreationCmd.Nullify(); // this way myCreationCmd won't be cleared
   }
@@ -4139,6 +4473,8 @@ void _pyGroup::Flush()
 _pyFilter::_pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID/*=""*/)
   :_pyObject(theCreationCmd), myNewID( newID )
 {
+  //myIsPublished = true; // prevent clearing as a not published
+  theGen->KeepAgrCmds( GetID() ); // ask to fill myArgCmds
 }
 
 //================================================================================
@@ -4171,8 +4507,11 @@ void _pyFilter::Process( const Handle(_pyCommand)& theCommand)
     theCommand->SetObject( SMESH_2smeshpy::GenName() );
     theCommand->SetMethod( "GetFilterFromCriteria" );
 
-    // Clear aFilterManager.CreateFilter()
+    // Swap "aFilterManager.CreateFilter()" and "smesh.GetFilterFromCriteria(criteria)"
     GetCreationCmd()->Clear();
+    GetCreationCmd()->GetString() = theCommand->GetString();
+    theCommand->Clear();
+    theCommand->AddDependantCmd( GetCreationCmd() );
   }
   else if ( theCommand->GetMethod() == "SetMesh" )
   {
@@ -4186,13 +4525,31 @@ void _pyFilter::Process( const Handle(_pyCommand)& theCommand)
 
 //================================================================================
 /*!
- * \brief Set new filter name to the creation command
+ * \brief Set new filter name to the creation command and to myArgCmds
  */
 //================================================================================
 
 void _pyFilter::Flush()
 {
-  if ( !myNewID.IsEmpty() && !GetCreationCmd()->IsEmpty() )
+  if ( myNewID.IsEmpty() ) return;
+  
+  list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
+  for ( ; cmd != myArgCmds.end(); ++cmd )
+    if ( !(*cmd)->IsEmpty() )
+    {
+      _AString cmdStr = (*cmd)->GetString();
+      _AString id     = GetID();
+      int pos = cmdStr.Search( id );
+      if ( pos > 0 )
+      {
+        cmdStr.Remove( pos, id.Length() );
+        cmdStr.Insert( pos, myNewID );
+      }
+      (*cmd)->Clear();
+      (*cmd)->GetString() = cmdStr;
+    }
+
+  if ( !GetCreationCmd()->IsEmpty() )
     GetCreationCmd()->SetResultValue( myNewID );
 }
 
@@ -4202,14 +4559,17 @@ void _pyFilter::Flush()
  */
 //================================================================================
 
-bool _pyFilter::CanClear()
+bool _pyObject::CanClear()
 {
-  list< Handle(_pyObject) >::iterator obj = myUsers.begin();
-  for ( ; obj != myUsers.end(); ++obj )
-    if ( !(*obj)->CanClear() )
-      return false;
-
-  return true;
+  list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
+  for ( ; cmd != myArgCmds.end(); ++cmd )
+    if ( !(*cmd)->IsEmpty() )
+    {
+      Handle(_pyObject) obj = theGen->FindObject( (*cmd)->GetObject() );
+      if ( !obj.IsNull() && !obj->CanClear() )
+        return false;
+    }
+  return ( !myIsPublished );
 }
 
 //================================================================================