From: ptv Date: Tue, 9 Dec 2008 11:11:15 +0000 (+0000) Subject: IMP199929 Script simplification and correct Set Name of the Mesh X-Git-Tag: Phase8_Part1_16122008~6 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=326d4252be2d48227b13d02ebbe80f3046ebeafc;p=modules%2Fsmesh.git IMP199929 Script simplification and correct Set Name of the Mesh --- diff --git a/src/SMESHGUI/SMESHGUI.cxx b/src/SMESHGUI/SMESHGUI.cxx index 5ccf0626b..277671a60 100644 --- a/src/SMESHGUI/SMESHGUI.cxx +++ b/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 ); - aName->SetValue( newName.toLatin1().constData() ); - - // if current object is group update group's name - SMESH::SMESH_GroupBase_var aGroup = - SMESH::IObjectToInterface(IObject); - if (!aGroup->_is_nil() ) - aGroup->SetName( newName.toLatin1().constData() ); + SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), newName.toLatin1().data()); updateObjBrowser(); } diff --git a/src/SMESHGUI/SMESHGUI_MeshOp.cxx b/src/SMESHGUI/SMESHGUI_MeshOp.cxx index fbe5bae27..01470b95b 100644 --- a/src/SMESHGUI/SMESHGUI_MeshOp.cxx +++ b/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++ ) { diff --git a/src/SMESHGUI/SMESHGUI_Utils.cxx b/src/SMESHGUI/SMESHGUI_Utils.cxx index 4462fa4cd..5a8866a66 100644 --- a/src/SMESHGUI/SMESHGUI_Utils.cxx +++ b/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(); - _PTR(GenericAttribute) anAttr = - aBuilder->FindOrCreateAttribute(theSObject, "AttributeName"); - _PTR(AttributeName) aName = anAttr; - if (aName) - aName->SetValue(theName.toLatin1().data()); + SMESHGUI::GetSMESHGen()->SetName(theSObject->GetIOR().c_str(), theName.toLatin1().data()); } void SetValue (_PTR(SObject) theSObject, const QString& theValue) diff --git a/src/SMESH_I/Makefile.am b/src/SMESH_I/Makefile.am index c58d29629..e79fa420f 100644 --- a/src/SMESH_I/Makefile.am +++ b/src/SMESH_I/Makefile.am @@ -121,6 +121,7 @@ libSMESHEngine_la_LDFLAGS = \ -lSalomeGenericObj \ $(MED_LDFLAGS) \ -lMEDWrapper_V2_2 \ + -lSalomeIDLMED \ $(CAS_LDPATH) \ -lTKCDF \ -lTKBO \ diff --git a/src/SMESH_I/SMESH_2smeshpy.cxx b/src/SMESH_I/SMESH_2smeshpy.cxx index f3e8d5746..4a9979ea8 100644 --- a/src/SMESH_I/SMESH_2smeshpy.cxx +++ b/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_ -//cout << "SET\t" << theAfterCmd->GetString() << endl << "BEFORE\t" << theCmd->GetString() << endl<::iterator pos; pos = find( myCommands.begin(), myCommands.end(), theCmd ); myCommands.erase( pos ); - pos = find( myCommands.begin(), myCommands.end(), theAfterCmd ); - myCommands.insert( ++pos, theCmd ); + pos = find( myCommands.begin(), myCommands.end(), theOtherCmd ); + 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 ) { - Handle(_pyCommand) subCmd = *cmd2; + list < Handle(_pySubMesh) >::iterator smIt; + 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 theMesh - - * \retval bool - + * \param theAdditionCmd - command to be converted + * \param theMesh - mesh instance + * \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() ); +} diff --git a/src/SMESH_I/SMESH_2smeshpy.hxx b/src/SMESH_I/SMESH_2smeshpy.hxx index b8826d890..a9fab1ba3 100644 --- a/src/SMESH_I/SMESH_2smeshpy.hxx +++ b/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 diff --git a/src/SMESH_I/SMESH_DumpPython.cxx b/src/SMESH_I/SMESH_DumpPython.cxx index d08e923e0..35ed7f21f 100644 --- a/src/SMESH_I/SMESH_DumpPython.cxx +++ b/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()){ - std::string aString = myStream.str(); - TCollection_AsciiString aCollection(Standard_CString(aString.c_str())); + if(!aStudy->_is_nil() && !aCollection.IsEmpty()){ 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"; // ----------------------------------------------------------------- diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx index 5bb47f630..56e227039 100644 --- a/src/SMESH_I/SMESH_Gen_i.cxx +++ b/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 diff --git a/src/SMESH_I/SMESH_Gen_i.hxx b/src/SMESH_I/SMESH_Gen_i.hxx index 1a548d41b..66dfc97e5 100644 --- a/src/SMESH_I/SMESH_Gen_i.hxx +++ b/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 ); diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx index 933f62939..ed84d70f0 100644 --- a/src/SMESH_I/SMESH_Mesh_i.cxx +++ b/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 ); + } +} diff --git a/src/SMESH_I/SMESH_Mesh_i.hxx b/src/SMESH_I/SMESH_Mesh_i.hxx index 83bccf2f6..684cbd534 100644 --- a/src/SMESH_I/SMESH_Mesh_i.hxx +++ b/src/SMESH_I/SMESH_Mesh_i.hxx @@ -471,6 +471,12 @@ public: std::map _mapSubMesh_i; //NRI std::map _mapSubMesh; //NRI +private: + /*! + * Check and correct names of mesh groups + */ + void checkGroupNames(); + private: static int myIdGenerator; diff --git a/src/SMESH_I/SMESH_PythonDump.hxx b/src/SMESH_I/SMESH_PythonDump.hxx index e310992a2..edd5c5dbf 100644 --- a/src/SMESH_I/SMESH_PythonDump.hxx +++ b/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 diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 7bd3fd783..faa079cee 100644 --- a/src/SMESH_SWIG/smeshDC.py +++ b/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 )