ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

IMP199929 Script simplification and correct Set Name of the Mesh

Browse Source
This commit is contained in:
ptv 2008-12-09 11:11:15 +00:00
parent c324294de9
commit 326d4252be
13 changed files with 472 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/SMESHGUI/SMESHGUI.cxx
View File

@ -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<SMESH::SMESH_GroupBase>(IObject);
if (!aGroup->_is_nil() )
aGroup->SetName( newName.toLatin1().constData() );
SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), newName.toLatin1().data());
updateObjBrowser();
}

3
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -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++ )
{

7
src/SMESHGUI/SMESHGUI_Utils.cxx
View File

@ -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)

1
src/SMESH_I/Makefile.am
View File

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

308
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -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<<endl;
#endif
setNeighbourCommand( theCmd, theAfterCmd, true );
}
//================================================================================
/*!
* \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 );
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() );
}

64
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -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

16
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -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";
// -----------------------------------------------------------------

19
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -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

4
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -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 );

62
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -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 );
}
}

6
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -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;

3
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -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

41
src/SMESH_SWIG/smeshDC.py
View File

@ -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 )