-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <SALOMEDS_wrap.hxx>
+#include <LDOMParser.hxx>
+#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx>
-#include <LDOMParser.hxx>
#ifdef _DEBUG_
static int MYDEBUG = 0;
static int MYDEBUG = 0;
#endif
+#include "SMESH_TryCatch.hxx"
+
namespace SMESH
{
size_t TPythonDump::myCounter = 0;
const char theNotPublishedObjectName[] = "__NOT__Published__Object__";
- TVar::TVar(CORBA::Double value):myVals(1) { myVals[0] = SMESH_Comment(value); }
- TVar::TVar(CORBA::Long value):myVals(1) { myVals[0] = SMESH_Comment(value); }
- TVar::TVar(CORBA::Short value):myVals(1) { myVals[0] = SMESH_Comment(value); }
- TVar::TVar(const SMESH::double_array& value):myVals(value.length())
+ TVar::TVar(CORBA::Double value):myVals(1), myIsList(false) { myVals[0] = SMESH_Comment(value); }
+ TVar::TVar(CORBA::Long value):myVals(1), myIsList(false) { myVals[0] = SMESH_Comment(value); }
+ TVar::TVar(CORBA::Short value):myVals(1), myIsList(false) { myVals[0] = SMESH_Comment(value); }
+ TVar::TVar(const SMESH::double_array& value):myVals(value.length()), myIsList(true)
{
for ( size_t i = 0; i < value.length(); i++)
myVals[i] = SMESH_Comment(value[i]);
operator<<(const TVar& theVarValue)
{
const std::vector< int >& varIDs = SMESH_Gen_i::GetSMESHGen()->GetLastParamIndices();
- if ( theVarValue.myVals.size() != 1 )
+ if ( theVarValue.myIsList )
{
myStream << "[ ";
for ( size_t i = 1; i <= theVarValue.myVals.size(); ++i )
{
- if ( myVarsCounter < varIDs.size() && varIDs[ myVarsCounter ] >= 0 )
+ if ( myVarsCounter < (int)varIDs.size() && varIDs[ myVarsCounter ] >= 0 )
myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote();
else
myStream << theVarValue.myVals[i-1];
}
else
{
- if ( myVarsCounter < varIDs.size() && varIDs[ myVarsCounter ] >= 0 )
+ if ( myVarsCounter < (int)varIDs.size() && varIDs[ myVarsCounter ] >= 0 )
myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote();
else
myStream << theVarValue.myVals[0];
return *this;
}
+ TPythonDump&
+ TPythonDump::
+ operator<<(const std::string& theArg){
+ myStream<<theArg;
+ return *this;
+ }
+
TPythonDump&
TPythonDump::
operator<<(const SMESH::ElementType& theArg)
case Entity_TriQuad_Hexa: myStream<<"Entity_TriQuad_Hexa"; break;
case Entity_Penta: myStream<<"Entity_Penta"; break;
case Entity_Quad_Penta: myStream<<"Entity_Quad_Penta"; break;
+ case Entity_BiQuad_Penta: myStream<<"Entity_BiQuad_Penta"; break;
case Entity_Hexagonal_Prism: myStream<<"Entity_Hexagonal_Prism"; break;
case Entity_Polyhedra: myStream<<"Entity_Polyhedra"; break;
case Entity_Quad_Polyhedra: myStream<<"Entity_Quad_Polyhedra"; break;
template<class TArray>
void DumpArray(const TArray& theArray, TPythonDump & theStream)
{
- theStream << "[ ";
- for (int i = 1; i <= theArray.length(); i++) {
- theStream << theArray[i-1];
- if ( i < theArray.length() )
- theStream << ", ";
+ if ( theArray.length() == 0 )
+ {
+ theStream << "[]";
+ }
+ else
+ {
+ theStream << "[ ";
+ for (CORBA::ULong i = 1; i <= theArray.length(); i++) {
+ theStream << theArray[i-1];
+ if ( i < theArray.length() )
+ theStream << ", ";
+ }
+ theStream << " ]";
}
- theStream << " ]";
}
TPythonDump&
return *this;
}
+ TPythonDump&
+ TPythonDump::operator<<(const SMESH::nodes_array& theArg)
+ {
+ DumpArray( theArg, *this );
+ return *this;
+ }
+
TPythonDump&
TPythonDump::operator<<(const SMESH::string_array& theArray)
{
myStream << "[ ";
- for (int i = 1; i <= theArray.length(); i++) {
+ for ( CORBA::ULong i = 1; i <= theArray.length(); i++ ) {
myStream << "'" << theArray[i-1] << "'";
if ( i < theArray.length() )
myStream << ", ";
SMESH::SMESH_Mesh_var mesh = theArg->GetMesh();
SMESH::long_array_var anElementsId = theArg->GetIDs();
SMESH::array_of_ElementType_var types = theArg->GetTypes();
- SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL;
- return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
+ SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL;
+ SALOMEDS::SObject_wrap meshSO = SMESH_Gen_i::ObjectToSObject(aStudy,mesh);
+ if ( meshSO->_is_nil() ) // don't waste memory for dumping not published objects
+ return *this << mesh << ".GetIDSource([], " << type << ")";
+ else
+ return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
}
return *this << theNotPublishedObjectName;
}
case FT_MultiConnection2D: myStream<< "aMultiConnection2D"; break;
case FT_Length: myStream<< "aLength"; break;
case FT_Length2D: myStream<< "aLength2D"; break;
+ case FT_Deflection2D: myStream<< "aDeflection2D"; break;
+ case FT_NodeConnectivityNumber:myStream<< "aNodeConnectivityNumber";break;
+ case FT_BelongToMeshGroup: myStream<< "aBelongToMeshGroup"; break;
case FT_BelongToGeom: myStream<< "aBelongToGeom"; break;
case FT_BelongToPlane: myStream<< "aBelongToPlane"; break;
case FT_BelongToCylinder: myStream<< "aBelongToCylinder"; break;
case FT_LogicalNOT: myStream<< "aLogicalNOT"; break;
case FT_LogicalAND: myStream<< "aLogicalAND"; break;
case FT_LogicalOR: myStream<< "aLogicalOR"; break;
- case FT_Undefined:
- default: myStream<< "anUndefined"; break;
+ case FT_Undefined: myStream<< "anUndefined"; break;
+ //default: -- commented to have a compilation warning
}
myStream<<theArg;
}
switch (theVersion) {
case SMESH::MED_V2_1: myStream << "SMESH.MED_V2_1"; break;
case SMESH::MED_V2_2: myStream << "SMESH.MED_V2_2"; break;
+ case SMESH::MED_LATEST: myStream << "SMESH.MED_LATEST"; break;
+ case SMESH::MED_MINOR_0: myStream << "SMESH.MED_MINOR_0"; break;
+ case SMESH::MED_MINOR_1: myStream << "SMESH.MED_MINOR_1"; break;
+ case SMESH::MED_MINOR_2: myStream << "SMESH.MED_MINOR_2"; break;
+ case SMESH::MED_MINOR_3: myStream << "SMESH.MED_MINOR_3"; break;
+ case SMESH::MED_MINOR_4: myStream << "SMESH.MED_MINOR_4"; break;
+ case SMESH::MED_MINOR_5: myStream << "SMESH.MED_MINOR_5"; break;
+ case SMESH::MED_MINOR_6: myStream << "SMESH.MED_MINOR_6"; break;
+ case SMESH::MED_MINOR_7: myStream << "SMESH.MED_MINOR_7"; break;
+ case SMESH::MED_MINOR_8: myStream << "SMESH.MED_MINOR_8"; break;
+ case SMESH::MED_MINOR_9: myStream << "SMESH.MED_MINOR_9"; break;
default: myStream << theVersion;
}
return *this;
DumpArray( *theList, *this );
return *this;
}
+ TPythonDump& TPythonDump::operator<<(const GEOM::ListOfGO& theList)
+ {
+ DumpArray( theList, *this );
+ return *this;
+ }
+ TPythonDump& TPythonDump::operator<<(const GEOM::ListOfGBO& theList)
+ {
+ DumpArray( theList, *this );
+ return *this;
+ }
TPythonDump& TPythonDump::operator<<(const SMESH::ListOfIDSources& theList)
{
DumpArray( theList, *this );
return *this;
}
+ TPythonDump& TPythonDump::operator<<(const SMESH::CoincidentFreeBorders& theCFB)
+ {
+ // dump CoincidentFreeBorders as a list of lists, each enclosed list
+ // contains node IDs of a group of coincident free borders where
+ // each consequent triple of IDs describe a free border: (n1, n2, nLast)
+ // For example [[1, 2, 10, 20, 21, 40], [11, 12, 15, 55, 54, 41]] describes
+ // two groups of coincident free borders, each group including two borders
+
+ myStream << "[";
+ for ( CORBA::ULong i = 0; i < theCFB.coincidentGroups.length(); ++i )
+ {
+ const SMESH::FreeBordersGroup& aGRP = theCFB.coincidentGroups[ i ];
+ if ( i ) myStream << ",";
+ myStream << "[";
+ for ( CORBA::ULong iP = 0; iP < aGRP.length(); ++iP )
+ {
+ const SMESH::FreeBorderPart& aPART = aGRP[ iP ];
+ if ( 0 <= aPART.border && aPART.border < (CORBA::Long)theCFB.borders.length() )
+ {
+ if ( iP ) myStream << ", ";
+ const SMESH::FreeBorder& aBRD = theCFB.borders[ aPART.border ];
+ myStream << aBRD.nodeIDs[ aPART.node1 ] << ",";
+ myStream << aBRD.nodeIDs[ aPART.node2 ] << ",";
+ myStream << aBRD.nodeIDs[ aPART.nodeLast ];
+ }
+ }
+ myStream << "]";
+ }
+ myStream << "]";
+
+ return *this;
+ }
+
const char* TPythonDump::NotPublishedObjectName()
{
return theNotPublishedObjectName;
return true;
}
+
+ void printException( const char* text )
+ {
+#ifdef _DEBUG_
+ cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << endl;
+#endif
+ }
}
//=======================================================================
// Map study entries to object names
Resource_DataMapOfAsciiStringAsciiString aMap;
Resource_DataMapOfAsciiStringAsciiString aMapNames;
- //TCollection_AsciiString s ("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_");
SALOMEDS::ChildIterator_wrap Itr = aStudy->NewChildIterator(aSO);
for (Itr->InitEx(true); Itr->More(); Itr->Next()) {
CORBA::String_var anID = aValue->GetID();
CORBA::String_var aName = aValue->GetName();
TCollection_AsciiString aGUIName ( (char*) aName.in() );
- TCollection_AsciiString anEnrty ( (char*) anID.in() );
+ TCollection_AsciiString anEntry ( (char*) anID.in() );
if (aGUIName.Length() > 0) {
- aMapNames.Bind( anEnrty, aGUIName );
- aMap.Bind( anEnrty, aGUIName );
+ aMapNames.Bind( anEntry, aGUIName );
+ aMap.Bind( anEntry, aGUIName );
}
}
*/
//================================================================================
- bool fixPythonName(TCollection_AsciiString & aName )
+ bool fixPythonName(TCollection_AsciiString & aName)
{
- const TCollection_AsciiString allowedChars =
- "qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_";
bool isValidName = true;
int nbUnderscore = 0;
- int p=1; // replace not allowed chars by underscore
- while (p <= aName.Length() &&
- (p = aName.FirstLocationNotInSet(allowedChars, p, aName.Length())))
- {
- if ( p == 1 || p == aName.Length() || aName.Value(p-1) == '_')
- aName.Remove( p, 1 ); // remove double _ from the start and the end
- else
- aName.SetValue(p, '_'), nbUnderscore++;
- isValidName = false;
+ int p;
+ // replace not allowed chars by underscore
+ const char* name = aName.ToCString();
+ for ( p = 0; name[p]; ++p ) {
+ if ( !isalnum( name[p] ) && name[p] != '_' )
+ {
+ if ( p == 0 || p+1 == aName.Length() || name[p-1] == '_')
+ {
+ aName.Remove( p+1, 1 ); // remove __ and _ from the start and the end
+ --p;
+ name = aName.ToCString();
+ }
+ else
+ {
+ aName.SetValue( p+1, '_');
+ nbUnderscore++;
+ }
+ isValidName = false;
+ }
}
- if ( aName.IsIntegerValue() ) { // aName must not start with a digit
+ // aName must not start with a digit
+ if ( aName.IsIntegerValue() ) {
aName.Insert( 1, 'a' );
isValidName = false;
}
}
}
-//=============================================================================
+//================================================================================
/*!
- * DumpPython
+ * \brief Createa a Dump Python script
+ * \param [in] theStudy - the study to dump
+ * \param [in,out] theObjectNames - map of an entry to a study and python name
+ * \param [in] theNames - - map of an entry to a study name
+ * \param [in] isPublished - \c true if dump of object publication in study is needed
+ * \param [in] isMultiFile - \c true if dump of each module goes to a separate file
+ * \param [in] isHistoricalDump - \c true if removed object should be dumped
+ * \param [out] aValidScript - returns \c true if the returned script seems valid
+ * \param [in,out] theSavedTrace - the dump stored in the study. It's cleared to
+ * decrease memory usage.
+ * \return TCollection_AsciiString - the result dump script.
*/
-//=============================================================================
+//================================================================================
+
TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
(SALOMEDS::Study_ptr theStudy,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
bool isMultiFile,
bool isHistoricalDump,
bool& aValidScript,
- const TCollection_AsciiString& theSavedTrace)
+ TCollection_AsciiString& theSavedTrace)
{
- int aStudyID = theStudy->StudyId();
-
- TCollection_AsciiString helper; // to comfortably concatenate C strings
- TCollection_AsciiString aSmeshpy( SMESH_2smeshpy::SmeshpyName() );
- TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() );
- TCollection_AsciiString anOldGen( SMESH::TPythonDump::SMESHGenName() );
-
- TCollection_AsciiString aScript;
- if( isMultiFile )
- aScript += "def RebuildData(theStudy):";
-
- aScript += "\n\t";
+ SMESH_TRY;
+ const int aStudyID = theStudy->StudyId();
+
+ const TCollection_AsciiString aSmeshpy ( SMESH_2smeshpy::SmeshpyName() );
+ const TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() );
+ const TCollection_AsciiString anOldGen ( SMESH::TPythonDump::SMESHGenName() );
+ const TCollection_AsciiString helper; // to comfortably append C strings to TCollection_AsciiString
+ const TCollection_AsciiString tab( isMultiFile ? "\t" : "" ), nt = helper + "\n" + tab;
+
+ std::list< TCollection_AsciiString > lines; // lines of a script
+ std::list< TCollection_AsciiString >::iterator linesIt;
+
if ( isPublished )
- aScript += aSMESHGen + " = smeshBuilder.New(theStudy)\n\t";
- else
- aScript += aSMESHGen + " = smeshBuilder.New(None)\n\t";
- aScript += helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()\n\t";
- aScript += helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()\n\t";
-
- // Dump trace of restored study
- if (theSavedTrace.Length() > 0) {
- // For the convertion of IDL API calls -> smeshBuilder.py API, "smesh" standing for SMESH_Gen
+ lines.push_back( aSMESHGen + " = smeshBuilder.New(theStudy)" );
+ else
+ lines.push_back( aSMESHGen + " = smeshBuilder.New(None)" );
+ lines.push_back( helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()" );
+ lines.push_back( helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()" );
+
+ // Treat dump trace of restored study
+ if (theSavedTrace.Length() > 0)
+ {
+ linesIt = --lines.end();
+ // Split theSavedTrace into lines
+ int from = 1, end = theSavedTrace.Length(), to;
+ while ( from < end && ( to = theSavedTrace.Location( "\n", from, end )))
+ {
+ if ( theSavedTrace.ToCString()[from-1] == '\t' )
+ ++from;
+ if ( to != from )
+ lines.push_back( theSavedTrace.SubString( from, to - 1 ));
+ from = to + 1;
+ }
+ // For the conversion of IDL API calls -> smeshBuilder.py API, "smesh" standing for SMESH_Gen
// was replaces with "smeshgen" (==TPythonDump::SMESHGenName()).
// Change "smesh" -> "smeshgen" in the trace saved before passage to smeshBuilder.py API
bool isNewVersion =
theSavedTrace.Location( anOldGen + ".", 1, theSavedTrace.Length() );
- if ( !isNewVersion ) {
- TCollection_AsciiString aSavedTrace( theSavedTrace );
- TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
- int beg, end = aSavedTrace.Length(), from = 1;
- while ( from < end && ( beg = aSavedTrace.Location( aSmeshCall, from, end ))) {
- char charBefore = ( beg == 1 ) ? ' ' : aSavedTrace.Value( beg - 1 );
- if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word
- aSavedTrace.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen"
- end += gen.Length();
+ theSavedTrace.Clear();
+ if ( !isNewVersion )
+ {
+ const TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
+ int beg, end, from;
+ for ( ++linesIt; linesIt != lines.end(); ++linesIt )
+ {
+ TCollection_AsciiString& aSavedLine = *linesIt;
+ end = aSavedLine.Length(), from = 1;
+ while ( from < end && ( beg = aSavedLine.Location( aSmeshCall, from, end )))
+ {
+ char charBefore = ( beg == 1 ) ? ' ' : aSavedLine.Value( beg - 1 );
+ if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word
+ aSavedLine.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen"
+ end += gen.Length();
+ }
+ from = beg + aSmeshCall.Length();
}
- from = beg + aSmeshCall.Length();
}
- aScript += helper + "\n" + aSavedTrace;
}
- else
- // append a saved trace to the script
- aScript += helper + "\n" + theSavedTrace;
}
- // Dump trace of API methods calls
- TCollection_AsciiString aNewLines = GetNewPythonLines(aStudyID);
- if (aNewLines.Length() > 0) {
- aScript += helper + "\n" + aNewLines;
- }
-
- // import python files corresponding to plugins if they are used in aScript
+ // Add new dump trace of API methods calls to script lines
+ if (myPythonScripts.find( aStudyID ) != myPythonScripts.end())
{
- TCollection_AsciiString importStr;
- std::vector<std::string> pluginNames = getPluginNames();
- for ( size_t i = 0; i < pluginNames.size(); ++i )
- {
- // Convert access to plugin members:
- // e.g. StdMeshers.QUAD_REDUCED -> StdMeshersBuilder.QUAD_REDUCED
- TCollection_AsciiString pluginAccess = (pluginNames[i] + ".").c_str() ;
- int iFrom = 1, iPos;
- while (( iPos = aScript.Location( pluginAccess, iFrom, aScript.Length() )))
- {
- aScript.Insert( iPos + pluginNames[i].size(), "Builder" );
- iFrom = iPos + pluginNames[i].size() + 8;
- }
- // if any plugin member is used, import the plugin
- if ( iFrom > 1 )
- importStr += ( helper + "\n\t" + "from salome." + (char*) pluginNames[i].c_str() +
- " import " + (char*) pluginNames[i].c_str() +"Builder" );
- }
- if ( !importStr.IsEmpty() )
- aScript.Insert( 1, importStr + "\n\t" );
+ Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[ aStudyID ];
+ Standard_Integer istr, aLen = aPythonScript->Length();
+ for (istr = 1; istr <= aLen; istr++)
+ lines.push_back( aPythonScript->Value( istr ));
}
// Convert IDL API calls into smeshBuilder.py API.
Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod;
std::set< TCollection_AsciiString > aRemovedObjIDs;
if ( !getenv("NO_2smeshpy_conversion"))
- aScript = SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod,
- theObjectNames, aRemovedObjIDs,
- theStudy, isHistoricalDump );
+ SMESH_2smeshpy::ConvertScript( lines, anEntry2AccessorMethod,
+ theObjectNames, aRemovedObjIDs,
+ theStudy, isHistoricalDump );
- // Replace characters used instead of quote marks to quote notebook variables
+ bool importGeom = false;
+ GEOM::GEOM_Gen_ptr geom = GetGeomEngine();
{
- int pos = 1;
- while (( pos = aScript.Location( 1, SMESH::TVar::Quote(), pos, aScript.Length() )))
- aScript.SetValue( pos, '"' );
+ // Add names of GEOM objects to theObjectNames to exclude same names of SMESH objects
+ GEOM::string_array_var aGeomNames = geom->GetAllDumpNames();
+ int ign = 0, nbgn = aGeomNames->length();
+ for (; ign < nbgn; ign++) {
+ TCollection_AsciiString aName = aGeomNames[ign].in();
+ theObjectNames.Bind(aName, "1");
+ }
}
- // Find entries to be replaced by names
- Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aScript);
- Standard_Integer aLen = aSeq->Length();
+ TCollection_AsciiString anUpdatedScript;
- if (aLen == 0 && isMultiFile)
- return aScript;
-
- // Replace entries by the names
- GEOM::GEOM_Gen_ptr geom = GetGeomEngine();
- TColStd_SequenceOfAsciiString seqRemoved;
Resource_DataMapOfAsciiStringAsciiString mapRemoved;
- Standard_Integer objectCounter = 0, aStart = 1, aScriptLength = aScript.Length();
- TCollection_AsciiString anUpdatedScript, anEntry, aName, aBaseName("smeshObj_");
+ Resource_DataMapOfAsciiStringAsciiString mapEntries; // names and entries present in anUpdatedScript
+ Standard_Integer objectCounter = 0;
+ TCollection_AsciiString anEntry, aName, aGUIName, aBaseName("smeshObj_");
- // Collect names of GEOM objects to exclude same names of SMESH objects
- GEOM::string_array_var aGeomNames = geom->GetAllDumpNames();
- int ign = 0, nbgn = aGeomNames->length();
- for (; ign < nbgn; ign++) {
- aName = aGeomNames[ign];
- theObjectNames.Bind(aName, "1");
- }
-
- bool importGeom = false;
- 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));
- // is a GEOM object?
- aName = geom->GetDumpName( anEntry.ToCString() );
- if (aName.IsEmpty()) {
- // is a SMESH object
- if (theObjectNames.IsBound(anEntry)) {
- // The Object is in Study
- aName = theObjectNames.Find(anEntry);
- // check validity of aName
- bool isValidName = fixPythonName( aName );
- if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) {
- // diff objects have same name - make a new name by appending a digit
- TCollection_AsciiString aName2;
- Standard_Integer i = 0;
+ // Treat every script line and add it to anUpdatedScript
+ for ( linesIt = lines.begin(); linesIt != lines.end(); ++linesIt )
+ {
+ TCollection_AsciiString& aLine = *linesIt;
+ anUpdatedScript += tab;
+ {
+ //Replace characters used instead of quote marks to quote notebook variables
+ int pos = 1;
+ while (( pos = aLine.Location( 1, SMESH::TVar::Quote(), pos, aLine.Length() )))
+ aLine.SetValue( pos, '"' );
+ }
+ // Find entries to be replaced by names
+ Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aLine);
+ const Standard_Integer aSeqLen = aSeq->Length();
+ Standard_Integer aStart = 1;
+ for (Standard_Integer i = 1; i <= aSeqLen; i += 2)
+ {
+ if ( aStart < aSeq->Value(i) )
+ anUpdatedScript += aLine.SubString( aStart, aSeq->Value(i) - 1 ); // line part before i-th entry
+ anEntry = aLine.SubString( aSeq->Value(i), aSeq->Value(i + 1) );
+ // is a GEOM object?
+ CORBA::String_var geomName = geom->GetDumpName( anEntry.ToCString() );
+ if ( !geomName.in() || !geomName.in()[0] ) {
+ // is a SMESH object
+ if ( theObjectNames.IsBound( anEntry )) {
+ // The Object is in Study
+ aName = theObjectNames.Find( anEntry );
+ // check validity of aName
+ bool isValidName = fixPythonName( aName );
+ if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) {
+ // diff objects have same name - make a new name by appending a digit
+ TCollection_AsciiString aName2;
+ Standard_Integer i = 0;
+ do {
+ aName2 = aName + "_" + ++i;
+ } while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2));
+ aName = aName2;
+ isValidName = false;
+ }
+ if ( !isValidName )
+ theObjectNames(anEntry) = aName;
+
+ if ( aLine.Value(1) != '#' )
+ mapEntries.Bind(anEntry, aName);
+ }
+ else
+ {
+ // Removed Object
do {
- aName2 = aName + "_" + ++i;
- } while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2));
- aName = aName2;
- isValidName = false;
+ aName = aBaseName + (++objectCounter);
+ } while (theObjectNames.IsBound(aName));
+
+ if ( !aRemovedObjIDs.count( anEntry ) && aLine.Value(1) != '#')
+ mapRemoved.Bind(anEntry, aName);
+
+ theObjectNames.Bind(anEntry, aName);
}
- if ( !isValidName )
- theObjectNames(anEntry) = aName;
-
- } else {
- // Removed Object
- do {
- aName = aBaseName + (++objectCounter);
- } while (theObjectNames.IsBound(aName));
- if ( !aRemovedObjIDs.count( anEntry ))
- seqRemoved.Append(aName);
- mapRemoved.Bind(anEntry, "1");
- theObjectNames.Bind(anEntry, aName);
+ theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
}
- theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
- }
- else
- {
- importGeom = true;
- }
- anUpdatedScript += aName;
- aStart = aSeq->Value(i + 1) + 1;
+ else
+ {
+ aName = geomName.in();
+ importGeom = true;
+ }
+ anUpdatedScript += aName;
+ aStart = aSeq->Value(i + 1) + 1;
+
+ } // loop on entries within aLine
+
+ if ( aSeqLen == 0 )
+ anUpdatedScript += aLine;
+ else if ( aSeq->Value( aSeqLen ) < aLine.Length() )
+ anUpdatedScript += aLine.SubString( aSeq->Value(aSeqLen) + 1, aLine.Length() );
+
+ anUpdatedScript += '\n';
}
- // set initial part of aSript
+ // Make an initial part of aSript
+
TCollection_AsciiString initPart = "import ";
if ( isMultiFile )
- initPart += helper + "salome, ";
+ initPart += "salome, ";
initPart += " SMESH, SALOMEDS\n";
initPart += "from salome.smesh import smeshBuilder\n";
if ( importGeom && isMultiFile )
{
initPart += ("\n## import GEOM dump file ## \n"
- "import string, os, sys, re\n"
- "sys.path.insert( 0, os.path.dirname(__file__) )\n"
- "exec(\"from \"+re.sub(\"SMESH$\",\"GEOM\",__name__)+\" import *\")\n");
+ "import string, os, sys, re, inspect\n"
+ "thisFile = inspect.getfile( inspect.currentframe() )\n"
+ "thisModule = os.path.splitext( os.path.basename( thisFile ))[0]\n"
+ "sys.path.insert( 0, os.path.dirname( thisFile ))\n"
+ "exec(\"from \"+re.sub(\"SMESH$\",\"GEOM\",thisModule)+\" import *\")\n\n");
}
- anUpdatedScript.Insert ( 1, initPart );
-
- // add final part of aScript
- if (aLen && aSeq->Value(aLen) < aScriptLength)
- anUpdatedScript += aScript.SubString(aSeq->Value(aLen) + 1, aScriptLength);
-
- // Remove removed objects
- if ( seqRemoved.Length() > 0 ) {
- anUpdatedScript += "\n\t## some objects were removed";
- anUpdatedScript += "\n\taStudyBuilder = theStudy.NewBuilder()";
+ // import python files corresponding to plugins if they are used in anUpdatedScript
+ {
+ TCollection_AsciiString importStr;
+ std::vector<std::string> pluginNames = getPluginNames();
+ for ( size_t i = 0; i < pluginNames.size(); ++i )
+ {
+ // Convert access to plugin members:
+ // e.g. StdMeshers.QUAD_REDUCED -> StdMeshersBuilder.QUAD_REDUCED
+ TCollection_AsciiString pluginAccess = (pluginNames[i] + ".").c_str() ;
+ int iFrom = 1, iPos;
+ while (( iPos = anUpdatedScript.Location( pluginAccess, iFrom, anUpdatedScript.Length() )))
+ {
+ anUpdatedScript.Insert( iPos + pluginNames[i].size(), "Builder" );
+ iFrom = iPos + pluginNames[i].size() + 8;
+ }
+ // if any plugin member is used, import the plugin
+ if ( iFrom > 1 )
+ importStr += ( helper + "\n" "from salome." + pluginNames[i].c_str() +
+ " import " + pluginNames[i].c_str() +"Builder" );
+ }
+ if ( !importStr.IsEmpty() )
+ initPart += importStr + "\n";
}
- for (int ir = 1; ir <= seqRemoved.Length(); ir++) {
- anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
- anUpdatedScript += seqRemoved.Value(ir);
- // for object wrapped by class of smeshBuilder.py
- anEntry = theObjectNames( seqRemoved.Value(ir) );
- if ( anEntry2AccessorMethod.IsBound( anEntry ) )
- anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
- anUpdatedScript += "))\n\tif SO is not None: aStudyBuilder.RemoveObjectWithChildren(SO)";
+
+ if ( isMultiFile )
+ initPart += "def RebuildData(theStudy):";
+ initPart += "\n";
+
+ anUpdatedScript.Prepend( initPart );
+
+ // Make a final part of aScript
+
+ // Dump object removal
+ TCollection_AsciiString removeObjPart;
+ if ( !mapRemoved.IsEmpty() ) {
+ removeObjPart += nt + "## some objects were removed";
+ removeObjPart += nt + "aStudyBuilder = theStudy.NewBuilder()";
+ Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapRemovedIt;
+ for ( mapRemovedIt.Initialize( mapRemoved ); mapRemovedIt.More(); mapRemovedIt.Next() ) {
+ aName = mapRemovedIt.Value(); // python name
+ anEntry = mapRemovedIt.Key();
+ removeObjPart += nt + "SO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
+ removeObjPart += aName;
+ // for object wrapped by class of smeshBuilder.py
+ if ( anEntry2AccessorMethod.IsBound( anEntry ) )
+ removeObjPart += helper + "." + anEntry2AccessorMethod( anEntry );
+ removeObjPart += helper + "))" + nt + "if SO: aStudyBuilder.RemoveObjectWithChildren(SO)";
+ }
}
// Set object names
-
- TCollection_AsciiString aGUIName, aSetNameScriptPart;
- Resource_DataMapOfAsciiStringAsciiString mapEntries;
- for (Standard_Integer i = 1; i <= aLen; i += 2)
+ TCollection_AsciiString setNamePart;
+ Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapEntriesIt;
+ for ( mapEntriesIt.Initialize( mapEntries ); mapEntriesIt.More(); mapEntriesIt.Next() )
{
- anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
- aName = geom->GetDumpName( anEntry.ToCString() );
- if (aName.IsEmpty() && // Not a GEOM object
- theNames.IsBound(anEntry) &&
- !aRemovedObjIDs.count(anEntry) && // A command creating anEntry was erased
- !mapEntries.IsBound(anEntry) && // Not yet processed
- !mapRemoved.IsBound(anEntry)) // Was not removed
+ anEntry = mapEntriesIt.Key();
+ aName = mapEntriesIt.Value(); // python name
+ if ( theNames.IsBound( anEntry ))
{
- aName = theObjectNames.Find(anEntry);
aGUIName = theNames.Find(anEntry);
- mapEntries.Bind(anEntry, aName);
- aSetNameScriptPart += helper + "\n\t" + aSMESHGen + ".SetName(" + aName;
+ aGUIName.RemoveAll('\''); // remove a quote from a name (issue 22360)
+ setNamePart += nt + aSMESHGen + ".SetName(" + aName;
if ( anEntry2AccessorMethod.IsBound( anEntry ) )
- aSetNameScriptPart += helper + "." + anEntry2AccessorMethod( anEntry );
- aSetNameScriptPart += helper + ", '" + aGUIName + "')";
+ setNamePart += helper + "." + anEntry2AccessorMethod( anEntry );
+ setNamePart += helper + ", '" + aGUIName + "')";
}
}
- if ( !aSetNameScriptPart.IsEmpty() )
+ if ( !setNamePart.IsEmpty() )
{
- anUpdatedScript += "\n\t## set object names";
- anUpdatedScript += aSetNameScriptPart;
+ setNamePart.Insert( 1, nt + "## Set names of Mesh objects" );
}
- // -----------------------------------------------------------------
- // store visual properties of displayed objects
- // -----------------------------------------------------------------
+ // Store visual properties of displayed objects
+ TCollection_AsciiString visualPropertiesPart;
if (isPublished)
{
//Output the script that sets up the visual parameters.
CORBA::String_var compDataType = ComponentDataType();
- char* script = theStudy->GetDefaultScript( compDataType.in(), "\t");
- if (script && strlen(script) > 0) {
- anUpdatedScript += "\n\n\t### Store presentation parameters of displayed objects\n";
- anUpdatedScript += script;
- CORBA::string_free(script);
+ CORBA::String_var script = theStudy->GetDefaultScript( compDataType.in(), tab.ToCString() );
+ if ( script.in() && script.in()[0] ) {
+ visualPropertiesPart += nt + "### Store presentation parameters of displayed objects\n";
+ visualPropertiesPart += script.in();
}
}
- if( isMultiFile )
- anUpdatedScript += "\n\tpass";
+ anUpdatedScript += removeObjPart + '\n' + setNamePart + '\n' + visualPropertiesPart;
+
+ if ( isMultiFile )
+ {
+ anUpdatedScript +=
+ "\n\tpass"
+ "\n"
+ "\nif __name__ == '__main__':"
+ "\n\tSMESH_RebuildData = RebuildData"
+ "\n\texec('import '+re.sub('SMESH$','GEOM',thisModule)+' as GEOM_dump')"
+ "\n\tGEOM_dump.RebuildData( salome.myStudy )"
+ "\n\texec('from '+re.sub('SMESH$','GEOM',thisModule)+' import * ')"
+ "\n\tSMESH_RebuildData( salome.myStudy )";
+ }
anUpdatedScript += "\n";
- if( !isMultiFile ) // remove unnecessary tabulation
- RemoveTabulation( anUpdatedScript );
+ // no need now as we use 'tab' and 'nt' variables depending on isMultiFile
+ // if( !isMultiFile ) // remove unnecessary tabulation
+ // RemoveTabulation( anUpdatedScript );
// -----------------------------------------------------------------
// put string literals describing patterns into separate functions
TCollection_AsciiString aLongString, aFunctionType;
int where = 1;
- set< string > functionNameSet;
+ std::set< std::string > functionNameSet;
while ( SMESH::TPythonDump::CutoutLongString( anUpdatedScript, where, aLongString, aFunctionType ))
{
// make a python string literal
{
// find the function name
int functBeg = posAlready;
- char* script = (char*) anUpdatedScript.ToCString() + posAlready - 1; // look at ":" after "def fuction()"
+ char* script = (char*) anUpdatedScript.ToCString() + posAlready - 1; // look at ":" after "def function()"
while ( *script != ' ' ) {
script--;
functBeg--;
aValidScript = true;
return anUpdatedScript;
+
+ SMESH_CATCH( SMESH::printException );
+
+ aValidScript = false;
+ return "";
}
//=============================================================================
Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID];
Standard_Integer istr, aLen = aPythonScript->Length();
for (istr = 1; istr <= aLen; istr++) {
- aScript += "\n\t";
+ aScript += "\n";
aScript += aPythonScript->Value(istr);
}
aScript += "\n";