ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 10:10:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

Start implementation of DumpPython for SMESH

Browse Source
This commit is contained in:
jfa 2005-03-24 14:37:16 +00:00
parent ec3c747ef2
commit e57f6e4178
6 changed files with 485 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SMESH_I/Makefile.in
View File

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

108
src/SMESH_I/SMESH_Gen_i.cxx
View File

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

25
src/SMESH_I/SMESH_Gen_i.hxx
View File

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

314
src/SMESH_I/SMESH_Gen_i_DumpPython.cxx Normal file
View File

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

21
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

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

33
src/SMESH_I/SMESH_Mesh_i.cxx
View File

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