IMP199929 Script simplification and correct Set Name of the Mesh

src/SMESHGUI/SMESHGUI.cxx

@@ -2027,7 +2027,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
       if( aSel )
         aSel->selectedObjects( selected );
 
-      bool isAny = false; // iss there any appropriate object selected
+      bool isAny = false; // is there any appropriate object selected
 
       SALOME_ListIteratorOfListIO It( selected );
       for ( ; It.More(); It.Next() )
@@ -2055,14 +2055,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
               newName = LightApp_NameDlg::getName(desktop(), newName);
               if ( !newName.isEmpty() )
               {
-                //old source: aStudy->renameIObject( IObject, newName );
+                SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), newName.toLatin1().data());
-                aName->SetValue( newName.toLatin1().constData() );
-
-                // if current object is group update group's name
-                SMESH::SMESH_GroupBase_var aGroup =
-                  SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
-                if (!aGroup->_is_nil() )
-                  aGroup->SetName( newName.toLatin1().constData() );
 
                 updateObjBrowser();
               }

src/SMESHGUI/SMESHGUI_MeshOp.cxx

@@ -1493,6 +1493,9 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess )
 
   // create sub-mesh
   SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toLatin1().data() );
+  _PTR(SObject) aSubMeshSO = SMESH::FindSObject( aSubMeshVar.in() );
+  if ( aSubMeshSO )
+    SMESH::SetName( aSubMeshSO, aName.toLatin1().data() );
 
   for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ )
   {

src/SMESHGUI/SMESHGUI_Utils.cxx

@@ -131,12 +131,7 @@ namespace SMESH
     _PTR(Study) aStudy = GetActiveStudyDocument();
     if (aStudy->GetProperties()->IsLocked())
       return;
-    _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
+    SMESHGUI::GetSMESHGen()->SetName(theSObject->GetIOR().c_str(), theName.toLatin1().data());
-    _PTR(GenericAttribute) anAttr =
-      aBuilder->FindOrCreateAttribute(theSObject, "AttributeName");
-    _PTR(AttributeName) aName = anAttr;
-    if (aName)
-      aName->SetValue(theName.toLatin1().data());
   }
 
   void SetValue (_PTR(SObject) theSObject, const QString& theValue)

src/SMESH_I/Makefile.am

@@ -121,6 +121,7 @@ libSMESHEngine_la_LDFLAGS  = \
 	-lSalomeGenericObj \
 	$(MED_LDFLAGS) \
 	-lMEDWrapper_V2_2 \
+        -lSalomeIDLMED \
 	$(CAS_LDPATH) \
 	-lTKCDF \
 	-lTKBO \

src/SMESH_I/SMESH_2smeshpy.cxx

@@ -46,8 +46,10 @@ IMPLEMENT_STANDARD_HANDLE (_pyObject          ,Standard_Transient);
 IMPLEMENT_STANDARD_HANDLE (_pyCommand         ,Standard_Transient);
 IMPLEMENT_STANDARD_HANDLE (_pyGen             ,_pyObject);
 IMPLEMENT_STANDARD_HANDLE (_pyMesh            ,_pyObject);
+IMPLEMENT_STANDARD_HANDLE (_pySubMesh         ,_pyObject);
 IMPLEMENT_STANDARD_HANDLE (_pyMeshEditor      ,_pyObject);
 IMPLEMENT_STANDARD_HANDLE (_pyHypothesis      ,_pyObject);
+IMPLEMENT_STANDARD_HANDLE (_pyFilterManager   ,_pyObject);
 IMPLEMENT_STANDARD_HANDLE (_pyAlgorithm       ,_pyHypothesis);
 IMPLEMENT_STANDARD_HANDLE (_pyComplexParamHypo,_pyHypothesis);
 IMPLEMENT_STANDARD_HANDLE (_pyNumberOfSegmentsHyp,_pyHypothesis);
@@ -56,8 +58,10 @@ IMPLEMENT_STANDARD_RTTIEXT(_pyObject          ,Standard_Transient);
 IMPLEMENT_STANDARD_RTTIEXT(_pyCommand         ,Standard_Transient);
 IMPLEMENT_STANDARD_RTTIEXT(_pyGen             ,_pyObject);
 IMPLEMENT_STANDARD_RTTIEXT(_pyMesh            ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh         ,_pyObject);
 IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor      ,_pyObject);
 IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis      ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyFilterManager   ,_pyObject);
 IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm       ,_pyHypothesis);
 IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
 IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
@@ -120,9 +124,10 @@ namespace {
 
 TCollection_AsciiString
 SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript,
-                              Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod)
+                              Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
+			      Resource_DataMapOfAsciiStringAsciiString& theObjectNames)
 {
-  theGen = new _pyGen( theEntry2AccessorMethod );
+  theGen = new _pyGen( theEntry2AccessorMethod, theObjectNames );
 
   // split theScript into separate commands
   int from = 1, end = theScript.Length(), to;
@@ -133,11 +138,13 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript,
       theGen->AddCommand( theScript.SubString( from, to - 1 ));
     from = to + 1;
   }
+
   // finish conversion
   theGen->Flush();
 #ifdef DUMP_CONVERSION
   MESSAGE_BEGIN ( std::endl << " ######## RESULT ######## " << std::endl<< std::endl );
 #endif
+
   // reorder commands after conversion
   list< Handle(_pyCommand) >::iterator cmd;
   bool orderChanges;
@@ -173,9 +180,11 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript,
  */
 //================================================================================
 
-_pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod)
+_pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
+	       Resource_DataMapOfAsciiStringAsciiString& theObjectNames)
   : _pyObject( new _pyCommand( TPythonDump::SMESHGenName(), 0 )),
-    myID2AccessorMethod( theEntry2AccessorMethod )
+    myID2AccessorMethod( theEntry2AccessorMethod ),
+    myObjectNames( theObjectNames )
 {
   myNbCommands = 0;
   myHasPattern = false;
@@ -221,18 +230,43 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
     this->Process( aCommand );
     return aCommand;
   }
+  
+  // SMESH_subMesh method?
+  map< _pyID, Handle(_pySubMesh) >::iterator id_subMesh = mySubMeshes.find( objID );
+  if ( id_subMesh != mySubMeshes.end() ) {
+    id_subMesh->second->Process( aCommand );
+    return aCommand;
+  }
+
   // SMESH_Mesh method?
   map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( objID );
   if ( id_mesh != myMeshes.end() ) {
+    // check for mesh editor object
     if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
       _pyID editorID = aCommand->GetResultValue();
       Handle(_pyMeshEditor) editor = new _pyMeshEditor( aCommand );
       myMeshEditors.insert( make_pair( editorID, editor ));
       return aCommand;
+    } 
+    // check for SubMesh objects
+    else if ( aCommand->GetMethod() == "GetSubMesh" ) { // SubMesh creation
+      _pyID subMeshID = aCommand->GetResultValue();
+      Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand );
+      mySubMeshes.insert( make_pair( subMeshID, subMesh ));
     }
     id_mesh->second->Process( aCommand );
     return aCommand;
   }
+
+  //SMESH_FilterManager method?
+  if ( theCommand.Search( "aFilterManager" ) != -1 ) {
+    if ( theCommand.Search( "CreateFilterManager" ) != -1 )
+      myFilterManager = new _pyFilterManager( aCommand );
+    else if ( !myFilterManager.IsNull() )
+      myFilterManager->Process( aCommand );
+    return aCommand;
+  }
+
   // SMESH_MeshEditor method?
   map< _pyID, Handle(_pyMeshEditor) >::iterator id_editor = myMeshEditors.find( objID );
   if ( id_editor != myMeshEditors.end() ) {
@@ -297,6 +331,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
   // Compute( mesh, geom )
   // mesh creation
   TCollection_AsciiString method = theCommand->GetMethod();
+
   if ( method == "CreateMesh" || method == "CreateEmptyMesh")
   {
     Handle(_pyMesh) mesh = new _pyMesh( theCommand );
@@ -321,6 +356,15 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
   // CreateHypothesis()
   if ( method == "CreateHypothesis" )
   {
+    // issue 199929, remove standard library name (default parameter)
+    const TCollection_AsciiString & aLibName = theCommand->GetArg( 2 );
+    if ( aLibName.Search( "StdMeshersEngine" ) != -1 ) {
+      // keep first argument
+      TCollection_AsciiString arg = theCommand->GetArg( 1 );
+      theCommand->RemoveArgs();
+      theCommand->SetArg( 1, arg );
+    }
+
     myHypos.push_back( _pyHypothesis::NewHypothesis( theCommand ));
     return;
   }
@@ -386,6 +430,12 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
 
 void _pyGen::Flush()
 {
+  // create empty command
+  myLastCommand = new _pyCommand();
+
+  if ( !myFilterManager.IsNull() )
+    myFilterManager->Flush();
+
   map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.begin();
   for ( ; id_mesh != myMeshes.end(); ++id_mesh )
     if ( ! id_mesh->second.IsNull() )
@@ -399,6 +449,14 @@ void _pyGen::Flush()
       if ( !(*hyp)->IsWrapped() )
         (*hyp)->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() );
     }
+
+  map< _pyID, Handle(_pySubMesh) >::iterator id_subMesh = mySubMeshes.begin();
+  for ( ; id_subMesh != mySubMeshes.end(); ++id_subMesh )
+    if ( ! id_subMesh->second.IsNull() )
+      id_subMesh->second->Flush();
+
+  myLastCommand->SetOrderNb( ++myNbCommands );
+  myCommands.push_back( myLastCommand );
 }
 
 //================================================================================
@@ -475,12 +533,32 @@ Handle(_pyHypothesis) _pyGen::FindAlgo( const _pyID& theGeom, const _pyID& theMe
     if ( !hyp->IsNull() &&
          (*hyp)->IsAlgo() &&
          theHypothesis->CanBeCreatedBy( (*hyp)->GetAlgoType() ) &&
-         (*hyp)->GetGeom() == theGeom &&
+	 (*hyp)->GetGeom() == theGeom &&
          (*hyp)->GetMesh() == theMesh )
       return *hyp;
   return 0;
 }
 
+//================================================================================
+/*!
+ * \brief Find subMesh by ID (entry)
+  * \param theSubMeshID - The subMesh ID
+  * \retval Handle(_pySubMesh) - The found subMesh
+ */
+//================================================================================
+
+Handle(_pySubMesh) _pyGen::FindSubMesh( const _pyID& theSubMeshID )
+{
+  map< _pyID, Handle(_pySubMesh) >::iterator id_subMesh = mySubMeshes.begin();
+  for ( ; id_subMesh != mySubMeshes.end(); ++id_subMesh ) {
+    Handle(_pySubMesh) sm = id_subMesh->second;
+    if ( !id_subMesh->second.IsNull() && theSubMeshID == id_subMesh->second->GetID() )
+      return sm;
+  }
+  return Handle(_pySubMesh)();
+}
+
+
 //================================================================================
 /*!
  * \brief Change order of commands in the script
@@ -516,20 +594,57 @@ void _pyGen::ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) th
 
 void _pyGen::SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd )
 {
-#ifdef _DEBUG_
+  setNeighbourCommand( theCmd, theAfterCmd, true );
-//cout << "SET\t" << theAfterCmd->GetString() << endl << "BEFORE\t" << theCmd->GetString() << endl<<endl;
+}
-#endif
+
+//================================================================================
+/*!
+ * \brief Set one command before the other
+  * \param theCmd - Command to move
+  * \param theBeforeCmd - Command before which to insert the first one
+ */
+//================================================================================
+
+void _pyGen::SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd )
+{
+  setNeighbourCommand( theCmd, theBeforeCmd, false );
+}
+
+//================================================================================
+/*!
+ * \brief Set one command before or after the other
+  * \param theCmd - Command to move
+  * \param theOtherCmd - Command ater or before which to insert the first one
+ */
+//================================================================================
+
+void _pyGen::setNeighbourCommand( Handle(_pyCommand)& theCmd,
+				  Handle(_pyCommand)& theOtherCmd,
+				  const bool theIsAfter )
+{
   list< Handle(_pyCommand) >::iterator pos;
   pos = find( myCommands.begin(), myCommands.end(), theCmd );
   myCommands.erase( pos );
-  pos = find( myCommands.begin(), myCommands.end(), theAfterCmd );
+  pos = find( myCommands.begin(), myCommands.end(), theOtherCmd );
-  myCommands.insert( ++pos, theCmd );
+  myCommands.insert( (theIsAfter ? ++pos : pos), theCmd );
 
   int i = 1;
   for ( pos = myCommands.begin(); pos != myCommands.end(); ++pos)
     (*pos)->SetOrderNb( i++ );
 }
 
+//================================================================================
+/*!
+ * \brief Set command be last in list of commands
+  * \param theCmd - Command to be last
+ */
+//================================================================================
+
+Handle(_pyCommand)& _pyGen::GetLastCommand()
+{
+  return myLastCommand;
+}
+
 //================================================================================
 /*!
  * \brief Set method to access to object wrapped with python class
@@ -543,6 +658,28 @@ void _pyGen::SetAccessorMethod(const _pyID& theID, const char* theMethod )
   myID2AccessorMethod.Bind( theID, (char*) theMethod );
 }
 
+//================================================================================
+/*!
+ * \brief Generated new ID for object and assign with existing name
+  * \param theID - ID of existing object
+ */
+//================================================================================
+
+_pyID _pyGen::GenerateNewID( const _pyID& theID )
+{
+  int index = 1;
+  _pyID aNewID;
+  do {
+    aNewID = theID + _pyID( ":" ) + _pyID( index++ );
+  }
+  while ( myObjectNames.IsBound( aNewID ) );
+    
+  myObjectNames.Bind( aNewID, myObjectNames.IsBound( theID ) 
+		      ? (myObjectNames.Find( theID ) + _pyID( "_" ) + _pyID( index-1 ))
+		      : _pyID( "A" ) + aNewID );
+  return aNewID;
+}
+
 //================================================================================
 /*!
  * \brief Find out type of geom group
@@ -666,7 +803,11 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
   const TCollection_AsciiString method = theCommand->GetMethod();
   // ----------------------------------------------------------------------
   if ( method == "GetSubMesh" ) {
-    mySubmeshes.push_back( theCommand );
+    Handle(_pySubMesh) subMesh = theGen->FindSubMesh( theCommand->GetResultValue() );
+    if ( !subMesh.IsNull() ) {
+      subMesh->SetCreator( this );
+      mySubmeshes.push_back( subMesh );
+    }
   }
   // ----------------------------------------------------------------------
   else if ( method == "AddHypothesis" ) { // mesh.AddHypothesis(geom, HYPO )
@@ -783,20 +924,43 @@ bool _pyMesh::NeedMeshAccess( const Handle(_pyCommand)& theCommand )
 
 void _pyMesh::Flush()
 {
-  list < Handle(_pyCommand) >::iterator cmd, cmd2;
+  list < Handle(_pyCommand) >::iterator cmd;
 
   // try to convert algo addition like this:
   // mesh.AddHypothesis(geom, ALGO ) --> ALGO = mesh.Algo()
   for ( cmd = myAddHypCmds.begin(); cmd != myAddHypCmds.end(); ++cmd )
   {
     Handle(_pyCommand) addCmd = *cmd;
+
     _pyID algoID = addCmd->GetArg( 2 );
     Handle(_pyHypothesis) algo = theGen->FindHyp( algoID );
     if ( algo.IsNull() || !algo->IsAlgo() )
       continue;
-    // try to convert
+
+    // check and create new algorithm instance if it is already wrapped
+    if ( algo->IsWrapped() ) {
+      _pyID localAlgoID = theGen->GenerateNewID( algoID );
+      TCollection_AsciiString aNewCmdStr = localAlgoID +
+	TCollection_AsciiString( " = " ) + theGen->GetID() +
+	TCollection_AsciiString( ".CreateHypothesis( \"" ) + algo->GetAlgoType() +
+	TCollection_AsciiString( "\" )" );
+      
+      Handle(_pyCommand) newCmd = theGen->AddCommand( aNewCmdStr );
+      Handle(_pyAlgorithm) newAlgo = Handle(_pyAlgorithm)::DownCast(theGen->FindHyp( localAlgoID ));
+      if ( !newAlgo.IsNull() ) {
+	newAlgo->Assign( algo, this->GetID() );
+	newAlgo->SetCreationCmd( newCmd );
+	algo = newAlgo;
+	// set algorithm creation
+	theGen->SetCommandBefore( newCmd, addCmd );
+      }
+      else
+	newCmd->Clear();
+    }
     _pyID geom = addCmd->GetArg( 1 );
     bool isLocalAlgo = ( geom != GetGeom() );
+    
+    // try to convert
     if ( algo->Addition2Creation( addCmd, this->GetID() )) // OK
     {
       // wrapped algo is created atfer mesh creation
@@ -807,12 +971,14 @@ void _pyMesh::Flush()
         addCmd->SetArg( addCmd->GetNbArgs() + 1,
                         TCollection_AsciiString( "geom=" ) + geom );
         // sm = mesh.GetSubMesh(geom, name) --> sm = ALGO.GetSubMesh()
-        for ( cmd2 = mySubmeshes.begin(); cmd2 != mySubmeshes.end(); ++cmd2 ) {
+	list < Handle(_pySubMesh) >::iterator smIt;
-          Handle(_pyCommand) subCmd = *cmd2;
+        for ( smIt = mySubmeshes.begin(); smIt != mySubmeshes.end(); ++smIt ) {
+	  Handle(_pySubMesh) subMesh = *smIt;
+          Handle(_pyCommand) subCmd = subMesh->GetCreationCmd();
           if ( geom == subCmd->GetArg( 1 )) {
             subCmd->SetObject( algo->GetID() );
             subCmd->RemoveArgs();
-            addCmd->AddDependantCmd( subCmd );
+	    subMesh->SetCreator( algo );
           }
         }
       }
@@ -1207,7 +1373,10 @@ bool _pyHypothesis::Addition2Creation( const Handle(_pyCommand)& theCmd,
   }
   // set a new creation command
   GetCreationCmd()->Clear();
-  SetCreationCmd( theCmd );
+  // set dependance between creation and addition to mesh
+  // SetCreationCmd( theCmd );
+  GetCreationCmd()->AddDependantCmd( theCmd );
+    
 
   // clear commands setting arg values
   list < Handle(_pyCommand) >::iterator argCmd = myArgCommands.begin();
@@ -1298,6 +1467,30 @@ void _pyHypothesis::ClearAllCommands()
     ( *cmd )->Clear();
 }
 
+
+//================================================================================
+/*!
+ * \brief Assign fields of theOther to me except myIsWrapped
+ */
+//================================================================================
+
+void _pyHypothesis::Assign( const Handle(_pyHypothesis)& theOther,
+			    const _pyID&                 theMesh )
+{
+  myIsWrapped = false;
+  myMesh = theMesh;
+
+  // myCreationCmd = theOther->myCreationCmd;
+  myIsAlgo = theOther->myIsAlgo;
+  myGeom = theOther->myGeom;
+  myType2CreationMethod = theOther->myType2CreationMethod;
+  myArgs = theOther->myArgs;
+  myArgMethods = theOther->myArgMethods;
+  myNbArgsByMethod = theOther->myNbArgsByMethod;
+  myArgCommands = theOther->myArgCommands;
+  myUnknownCommands = theOther->myUnknownCommands;
+}
+
 //================================================================================
 /*!
  * \brief Remember hypothesis parameter values
@@ -1387,9 +1580,9 @@ void _pyLayerDistributionHypo::Process( const Handle(_pyCommand)& theCommand)
 //================================================================================
 /*!
  * \brief 
-  * \param theAdditionCmd - 
+  * \param theAdditionCmd - command to be converted
-  * \param theMesh - 
+  * \param theMesh - mesh instance
-  * \retval bool - 
+  * \retval bool - status
  */
 //================================================================================
 
@@ -2058,3 +2251,78 @@ _pyID _pyObject::FatherID(const _pyID & childID)
     return childID.SubString( 1, colPos-1 );
   return "";
 }
+
+//================================================================================
+/*!
+ * \brief FilterManager creates only if at least one command invoked
+ */
+//================================================================================
+
+_pyFilterManager::_pyFilterManager(const Handle(_pyCommand)& theCreationCmd):
+  _pyObject( theCreationCmd ),
+  myCmdCount( 0 )
+{
+}
+
+//================================================================================
+/*!
+ * \brief count invoked commands
+ */
+//================================================================================
+
+void _pyFilterManager::Process( const Handle(_pyCommand)& /*theCommand*/)
+{
+  myCmdCount++;
+}
+
+//================================================================================
+/*!
+ * \brief Clear creatin command if no commands invoked
+ */
+//================================================================================
+
+void _pyFilterManager::Flush()
+{
+  if ( !myCmdCount )
+    GetCreationCmd()->Clear();
+}
+
+
+//================================================================================
+/*!
+ * \brief SubMesh creation can be moved to the end of engine commands
+ */
+//================================================================================
+
+_pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd):
+  _pyObject( theCreationCmd ),
+  myCmdCount( 0 )
+{
+}
+
+//================================================================================
+/*!
+ * \brief count invoked commands
+ */
+//================================================================================
+
+void _pySubMesh::Process( const Handle(_pyCommand)& theCommand )
+{
+  myCmdCount++;
+  GetCreationCmd()->AddDependantCmd( theCommand );
+}
+
+//================================================================================
+/*!
+ * \brief Clear creatin command if no commands invoked
+ */
+//================================================================================
+
+void _pySubMesh::Flush()
+{
+  if ( !myCmdCount ) // 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() );
+}

src/SMESH_I/SMESH_2smeshpy.hxx

@@ -63,15 +63,19 @@ class _pyCommand;
 class _pyObject;
 class _pyGen;
 class _pyMesh;
+class _pySubMesh;
 class _pyHypothesis;
 class _pyAlgorithm;
+class _pyFilterManager;
 
 DEFINE_STANDARD_HANDLE (_pyCommand   ,Standard_Transient);
 DEFINE_STANDARD_HANDLE (_pyObject    ,Standard_Transient);
 DEFINE_STANDARD_HANDLE (_pyGen       ,_pyObject);
 DEFINE_STANDARD_HANDLE (_pyMesh      ,_pyObject);
+DEFINE_STANDARD_HANDLE (_pySubMesh   ,_pyObject);
 DEFINE_STANDARD_HANDLE (_pyMeshEditor,_pyObject);
 DEFINE_STANDARD_HANDLE (_pyHypothesis,_pyObject);
+DEFINE_STANDARD_HANDLE (_pyFilterManager,_pyObject);
 DEFINE_STANDARD_HANDLE (_pyAlgorithm ,_pyHypothesis);
 
 typedef TCollection_AsciiString _pyID;
@@ -171,7 +175,8 @@ public:
 class _pyGen: public _pyObject
 {
 public:
-  _pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod);
+  _pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
+         Resource_DataMapOfAsciiStringAsciiString& theObjectNames);
   //~_pyGen();
   Handle(_pyCommand) AddCommand( const TCollection_AsciiString& theCommand );
   void Process( const Handle(_pyCommand)& theCommand );
@@ -179,21 +184,35 @@ public:
   Handle(_pyHypothesis) FindHyp( const _pyID& theHypID );
   Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
                                   const Handle(_pyHypothesis)& theHypothesis);
+  Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
   void ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) theCmd2 );
   void SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd );
+  void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
+  Handle(_pyCommand)& GetLastCommand();
   std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
   void SetAccessorMethod(const _pyID& theID, const char* theMethod );
   bool AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const;
   bool AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const;
   const char* AccessorMethod() const;
+  _pyID GenerateNewID( const _pyID& theID );
+
+private:
+  void setNeighbourCommand( Handle(_pyCommand)& theCmd,
+                            Handle(_pyCommand)& theOtherCmd,
+                            const bool theIsAfter );
+  
 private:
   std::map< _pyID, Handle(_pyMesh) >       myMeshes;
+  std::map< _pyID, Handle(_pySubMesh) >    mySubMeshes;
   std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
   std::list< Handle(_pyHypothesis) >       myHypos;
   std::list< Handle(_pyCommand) >          myCommands;
   int                                      myNbCommands;
   bool                                     myHasPattern;
   Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
+  Resource_DataMapOfAsciiStringAsciiString& myObjectNames;
+  Handle(_pyCommand)                       myLastCommand;
+  Handle(_pyFilterManager)                 myFilterManager;
 
   DEFINE_STANDARD_RTTI (_pyGen)
 };
@@ -208,7 +227,7 @@ class _pyMesh: public _pyObject
 {
   std::list< Handle(_pyHypothesis) > myHypos;
   std::list< Handle(_pyCommand) > myAddHypCmds;
-  std::list< Handle(_pyCommand) > mySubmeshes;
+  std::list< Handle(_pySubMesh) > mySubmeshes;
   bool                            myHasEditor;
 public:
   _pyMesh(const Handle(_pyCommand) creationCmd);
@@ -297,12 +316,14 @@ public:
   { return myType2CreationMethod.find( algoType ) != myType2CreationMethod.end(); }
   const TCollection_AsciiString& GetCreationMethod(const TCollection_AsciiString& algoType) const
   { return myType2CreationMethod.find( algoType )->second; }
-  bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped && myMesh == theMesh; }
+  virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped && myMesh == theMesh; }
   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
                                   const _pyID&              theMesh);
   static Handle(_pyHypothesis) NewHypothesis( const Handle(_pyCommand)& theCreationCmd);
   void Process( const Handle(_pyCommand)& theCommand);
   void Flush();
+  virtual void Assign( const Handle(_pyHypothesis)& theOther,
+		       const _pyID&                 theMesh );
 
   DEFINE_STANDARD_RTTI (_pyHypothesis)
 };
@@ -319,6 +340,7 @@ public:
   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
                                   const _pyID&              theMesh);
   const char* AccessorMethod() const { return "GetAlgorithm()"; }
+  virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
 
   DEFINE_STANDARD_RTTI (_pyAlgorithm)
 };
@@ -390,4 +412,40 @@ public:
 };
 DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
 
+// -------------------------------------------------------------------------------------
+/*!
+ * \brief FilterManager creates only if at least one command invoked
+ */
+// -------------------------------------------------------------------------------------
+class _pyFilterManager: public _pyObject
+{
+public:
+  _pyFilterManager(const Handle(_pyCommand)& theCreationCmd);
+  void Process( const Handle(_pyCommand)& theCommand);
+  virtual void Flush();
+
+  DEFINE_STANDARD_RTTI (_pyFilterManager)
+private:
+  int myCmdCount;
+};
+
+// -------------------------------------------------------------------------------------
+/*!
+ * \brief SubMesh creation can be moved to the end of engine commands
+ */
+// -------------------------------------------------------------------------------------
+class _pySubMesh:  public _pyObject
+{
+public:
+  _pySubMesh(const Handle(_pyCommand)& theCreationCmd);
+  void Process( const Handle(_pyCommand)& theCommand);
+  virtual void Flush();
+  void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
+
+  DEFINE_STANDARD_RTTI (_pyFilterManager)
+private:
+  int               myCmdCount;
+  Handle(_pyObject) myCreator;
+};
+
 #endif

src/SMESH_I/SMESH_DumpPython.cxx

@@ -59,10 +59,10 @@ namespace SMESH
   {
     if(--myCounter == 0){
       SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+      std::string aString = myStream.str();
+      TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
       SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
-      if(!aStudy->_is_nil()){
+      if(!aStudy->_is_nil() && !aCollection.IsEmpty()){
-	std::string aString = myStream.str();
-	TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
 	aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection);
 	if(MYDEBUG) MESSAGE(aString);
       }
@@ -684,7 +684,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
   // Some objects are wrapped with python classes and
   // Resource_DataMapOfAsciiStringAsciiString holds methods returning wrapped objects
   Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod;
-  aScript = SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod );
+  aScript = SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod, theObjectNames );
 
   // Find entries to be replaced by names
   Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aScript);
@@ -832,8 +832,6 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
 
   // Set object names
   anUpdatedScript += "\n\t## set object names";
-  anUpdatedScript += helper + "  \n\tisGUIMode = " + isPublished;
-  anUpdatedScript += "\n\tif isGUIMode and salome.sg.hasDesktop():";
 //   anUpdatedScript += "\n\t\tsmeshgui = salome.ImportComponentGUI(\"SMESH\")";
 //   anUpdatedScript += "\n\t\tsmeshgui.Init(theStudy._get_StudyId())";
 //   anUpdatedScript += "\n";
@@ -852,13 +850,14 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
       aName = theObjectNames.Find(anEntry);
       aGUIName = theNames.Find(anEntry);
       mapEntries.Bind(anEntry, aName);
-      anUpdatedScript += helper + "\n\t\t" + aSmeshpy + ".SetName(" + aName;
+      anUpdatedScript += helper + "\n\t" + aSMESHGen + ".SetName(" + aName;
       if ( anEntry2AccessorMethod.IsBound( anEntry ) )
         anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
       anUpdatedScript += helper + ", '" + aGUIName + "')";
     }
   }
-  anUpdatedScript += "\n\n\t\tsalome.sg.updateObjBrowser(0)";
+  anUpdatedScript += "\n\tif salome.sg.hasDesktop():";
+  anUpdatedScript += "\n\t\tsalome.sg.updateObjBrowser(0)";
 
   // -----------------------------------------------------------------
   // store visual properties of displayed objects
@@ -874,7 +873,6 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
       CORBA::string_free(script);
     }
   }
-
   anUpdatedScript += "\n\n\tpass\n";
 
   // -----------------------------------------------------------------

src/SMESH_I/SMESH_Gen_i.cxx

@@ -4146,6 +4146,25 @@ CORBA::Long SMESH_Gen_i::GetObjectId(CORBA::Object_ptr theObject)
   return 0;
 }
 
+//=============================================================================
+/*!
+ *  SMESH_Gen_i::SetName
+ *
+ *  Set a new object name
+ */
+//=============================================================================
+void SMESH_Gen_i::SetName(const char* theIOR,
+                          const char* theName)
+{
+  if ( theIOR && strcmp( theIOR, "" ) ) {
+    CORBA::Object_var anObject = GetORB()->string_to_object( theIOR );
+    SALOMEDS::SObject_var aSO = ObjectToSObject( myCurrentStudy, anObject );
+    if ( !aSO->_is_nil() ) {
+      SetName( aSO, theName );
+    }
+  }
+}
+
 //=============================================================================
 /*! 
  *  SMESHEngine_factory

src/SMESH_I/SMESH_Gen_i.hxx

@@ -176,6 +176,10 @@ public:
   // *****************************************
   // Interface methods
   // *****************************************
+  // Set a new Mesh object name
+  void SetName(const char* theIOR,
+	       const char* theName);
+
   //GEOM::GEOM_Gen_ptr SetGeomEngine( const char* containerLoc );
   void SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo );
 

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -1988,10 +1988,6 @@ void SMESH_Mesh_i::ExportToMED (const char* file,
 {
   Unexpect aCatch(SALOME_SalomeException);
 
-  // Update Python script
-  TPythonDump() << _this() << ".ExportToMED( '"
-                << file << "', " << auto_groups << ", " << theVersion << " )";
-
   // Perform Export
   PrepareForWriting(file);
   const char* aMeshName = "Mesh";
@@ -2000,10 +1996,6 @@ void SMESH_Mesh_i::ExportToMED (const char* file,
     SALOMEDS::SObject_var aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() );
     if ( !aMeshSO->_is_nil() ) {
       aMeshName = aMeshSO->GetName();
-      //SCRUTE(file);
-      //SCRUTE(aMeshName);
-      //SCRUTE(aMeshSO->GetID());
-
       // asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes
       if ( !aStudy->GetProperties()->IsLocked() )
 	{
@@ -2022,6 +2014,16 @@ void SMESH_Mesh_i::ExportToMED (const char* file,
 	}
     }
   }
+  // Update Python script
+  // set name of mesh before export
+  TPythonDump() << _gen_i << ".SetName(" << _this() << ", '" << aMeshName << "')";
+  
+  // check names of groups
+  checkGroupNames();
+
+  TPythonDump() << _this() << ".ExportToMED( '"
+                << file << "', " << auto_groups << ", " << theVersion << " )";
+
   _impl->ExportMED( file, aMeshName, auto_groups, theVersion );
 }
 
@@ -2038,6 +2040,8 @@ void SMESH_Mesh_i::ExportDAT (const char *file)
   Unexpect aCatch(SALOME_SalomeException);
 
   // Update Python script
+  // check names of groups
+  checkGroupNames();
   TPythonDump() << _this() << ".ExportDAT( '" << file << "' )";
 
   // Perform Export
@@ -2051,6 +2055,8 @@ void SMESH_Mesh_i::ExportUNV (const char *file)
   Unexpect aCatch(SALOME_SalomeException);
 
   // Update Python script
+  // check names of groups
+  checkGroupNames();
   TPythonDump() << _this() << ".ExportUNV( '" << file << "' )";
 
   // Perform Export
@@ -2064,6 +2070,8 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
   Unexpect aCatch(SALOME_SalomeException);
 
   // Update Python script
+  // check names of groups
+  checkGroupNames();
   TPythonDump() << _this() << ".ExportSTL( '" << file << "', " << isascii << " )";
 
   // Perform Export
@@ -3000,3 +3008,41 @@ SALOME_MED::MedFileInfo* SMESH_Mesh_i::GetMEDFileInfo()
   }
   return res._retn();
 }
+
+//=============================================================================
+/*!
+ * \brief Check and correct names of mesh groups
+ */
+//=============================================================================
+
+void SMESH_Mesh_i::checkGroupNames()
+{
+  int nbGrp = NbGroups();
+  if ( !nbGrp )
+    return;
+
+  SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
+  if ( aStudy->_is_nil() )
+    return; // nothing to do
+  
+  SMESH::ListOfGroups* grpList = 0;
+  // avoid dump of "GetGroups"
+  {
+    // store python dump into a local variable inside local scope
+    SMESH::TPythonDump pDump; // do not delete this line of code
+    grpList = GetGroups();
+  }
+
+  for ( int gIndx = 0; gIndx < nbGrp; gIndx++ ) {
+    SMESH::SMESH_GroupBase_ptr aGrp = (*grpList)[ gIndx ];
+    if ( !aGrp )
+      continue;
+    SALOMEDS::SObject_var aGrpSO = _gen_i->ObjectToSObject( aStudy, aGrp );
+    if ( aGrpSO->_is_nil() )
+      continue;
+    // correct name of the mesh group if necessary
+    const char* guiName = aGrpSO->GetName();
+    if ( strcmp(guiName, aGrp->GetName()) )
+      aGrp->SetName( guiName );
+  }
+}

src/SMESH_I/SMESH_Mesh_i.hxx

@@ -471,6 +471,12 @@ public:
   std::map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI
   std::map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
 
+private:
+  /*!
+   * Check and correct names of mesh groups
+   */
+  void checkGroupNames();
+
 private:
 
   static int myIdGenerator;

src/SMESH_I/SMESH_PythonDump.hxx

@@ -53,7 +53,8 @@ public:
    */
   static TCollection_AsciiString
   ConvertScript(const TCollection_AsciiString& theScript,
-                Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod);
+                Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
+		Resource_DataMapOfAsciiStringAsciiString& theObjectNames);
 
   /*!
    * \brief Return the name of the python file wrapping IDL API

src/SMESH_SWIG/smeshDC.py

@@ -172,18 +172,6 @@ def GetName(obj):
         attr = sobj.FindAttribute("AttributeName")[1]
         return attr.Value()
 
-## Sets a name to the object
-def SetName(obj, name):
-    if isinstance( obj, Mesh ):
-        obj = obj.GetMesh()
-    elif isinstance( obj, Mesh_Algorithm ):
-        obj = obj.GetAlgorithm()
-    ior  = salome.orb.object_to_string(obj)
-    sobj = salome.myStudy.FindObjectIOR(ior)
-    if not sobj is None:
-        attr = sobj.FindAttribute("AttributeName")[1]
-        attr.SetValue(name)
-
 ## Prints error message if a hypothesis was not assigned.
 def TreatHypoStatus(status, hypName, geomName, isAlgo):
     if isAlgo:
@@ -314,6 +302,19 @@ class smeshDC(SMESH._objref_SMESH_Gen):
     # From SMESH_Gen interface:
     # ------------------------
 
+    ## Sets the given name to the object
+    #  @param obj the object to rename
+    #  @param name a new object name
+    #  @ingroup l1_auxiliary
+    def SetName(self, obj, name):
+        print "obj_name = ", name
+        if isinstance( obj, Mesh ):
+            obj = obj.GetMesh()
+        elif isinstance( obj, Mesh_Algorithm ):
+            obj = obj.GetAlgorithm()
+        ior  = salome.orb.object_to_string(obj)
+        SMESH._objref_SMESH_Gen.SetName(self, ior, name)
+
     ## Sets the current mode
     #  @ingroup l1_auxiliary
     def SetEmbeddedMode( self,theMode ):
@@ -557,6 +558,12 @@ class smeshDC(SMESH._objref_SMESH_Gen):
         else:
             print "Error: given parameter is not numerucal functor type."
 
+    ## Creates hypothesis
+    #  @param 
+    #  @param 
+    #  @return created hypothesis instance
+    def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"):
+        return SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName )
 
 import omniORB
 #Registering the new proxy for SMESH_Gen
@@ -600,9 +607,9 @@ class Mesh:
         else:
             self.mesh = self.smeshpyD.CreateEmptyMesh()
         if name != 0:
-            SetName(self.mesh, name)
+            self.smeshpyD.SetName(self.mesh, name)
         elif obj != 0:
-            SetName(self.mesh, GetName(obj))
+            self.smeshpyD.SetName(self.mesh, GetName(obj))
 
         if not self.geom:
             self.geom = self.mesh.GetShapeToMesh()
@@ -633,7 +640,7 @@ class Mesh:
     #  @param name a new name of the mesh
     #  @ingroup l2_construct
     def SetName(self, name):
-        SetName(self.GetMesh(), name)
+        self.smeshpyD.SetName(self.GetMesh(), name)
 
     ## Gets the subMesh object associated to a \a theSubObject geometrical object.
     #  The subMesh object gives access to the IDs of nodes and elements.
@@ -2915,7 +2922,7 @@ class Mesh_Algorithm:
 
     ## Sets the name to the algorithm
     def SetName(self, name):
-        SetName(self.algo, name)
+        self.mesh.smeshpyD.SetName(self.algo, name)
 
     ## Gets the id of the algorithm
     def GetId(self):
@@ -2978,7 +2985,7 @@ class Mesh_Algorithm:
                 s = ","
                 i = i + 1
                 pass
-            SetName(hypo, hyp + a)
+            self.mesh.smeshpyD.SetName(hypo, hyp + a)
             pass
         status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
         TreatHypoStatus( status, GetName(hypo), GetName(self.geom), 0 )