X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Entity.cxx;h=370c7167137752c146f860961c360ae553bc4d78;hb=e7e76450be3fadf6ad263f78e10ceb8cd1f70deb;hp=fe5be13a4d3088d33280f2cae71fbe9c12e696ea;hpb=439579ec24edd8b147cab07f688d446d59029a1e;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_Entity.cxx b/src/HYDROData/HYDROData_Entity.cxx index fe5be13a..370c7167 100644 --- a/src/HYDROData/HYDROData_Entity.cxx +++ b/src/HYDROData/HYDROData_Entity.cxx @@ -16,35 +16,51 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -#include "HYDROData_Entity.h" - -#include "HYDROData_Iterator.h" -#include "HYDROData_Tool.h" - +#include +#include +#include +#include +#include #include #include #include -#include -#include +#include #include -#include +#include #include - +#include #include #include - +#include +#include +#include #include -#include +#include #include #include -static const Standard_GUID GUID_MUST_BE_UPDATED("80f2bb81-3873-4631-8ddd-940d2119f000"); +#define _DEVDEBUG_ +#include "HYDRO_trace.hxx" + +HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects() + : NCollection_Sequence() +{ +} + +HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects( const HYDROData_SequenceOfObjects& theSequence ) + : NCollection_Sequence( theSequence ) +{ +} + +HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects( const NCollection_Sequence& theSequence ) + : NCollection_Sequence( theSequence ) +{ +} -IMPLEMENT_STANDARD_HANDLE(HYDROData_Entity,MMgt_TShared) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Entity,MMgt_TShared) // is equal function for unique object mapping -bool IsEqual(const Handle_HYDROData_Entity& theObj1, const Handle_HYDROData_Entity& theObj2) +bool IsEqual(const Handle(HYDROData_Entity)& theObj1, const Handle(HYDROData_Entity)& theObj2) { if ( !theObj1.IsNull() && !theObj2.IsNull() ) return theObj1->Label() == theObj2->Label(); @@ -61,20 +77,136 @@ QString HYDROData_Entity::GetName() const return QString(); } +QString HYDROData_Entity::GetType() const +{ + return Type( GetKind() ); +} + +QString HYDROData_Entity::Type( ObjectKind theKind ) +{ + switch( theKind ) + { + case KIND_UNKNOWN: + return "Unknown"; + case KIND_IMAGE: + return "Image"; + case KIND_POLYLINE: + return "Polyline"; + case KIND_BATHYMETRY: + return "Bathymetry"; + case KIND_ALTITUDE: + return "Altitude"; + case KIND_IMMERSIBLE_ZONE: + return "Immersible_zone"; + case KIND_RIVER: + return "River"; + case KIND_STREAM: + return "Stream"; + case KIND_CONFLUENCE: + return "Confluence"; + case KIND_CHANNEL: + return "Channel"; + case KIND_OBSTACLE: + return "Obstacle"; + case KIND_DIGUE: + return "Digue"; + case KIND_PROFILE: + return "Profile"; + case KIND_PROFILEUZ: + return "Profile_UZ"; + case KIND_POLYLINEXY: + return "Polyline_XY"; + case KIND_CALCULATION: + return "Calculation_case"; + case KIND_ZONE: + return "Zone"; + case KIND_REGION: + return "Region"; + case KIND_VISUAL_STATE: + return "Visual_state"; + case KIND_ARTIFICIAL_OBJECT: + return "Artificial_object"; + case KIND_NATURAL_OBJECT: + return "Natural_object"; + case KIND_DUMMY_3D: + return "Dummy_3d"; + case KIND_SHAPES_GROUP: + return "Shapes_group"; + case KIND_SPLIT_GROUP: + return "Split_group"; + case KIND_STREAM_ALTITUDE: + return "Stream_altitude"; + case KIND_OBSTACLE_ALTITUDE: + return "Obstacle_altitude"; + case KIND_STRICKLER_TABLE: + return "Strickler_table"; + case KIND_LAND_COVER_OBSOLETE: + return "Land_cover"; + case KIND_CHANNEL_ALTITUDE: + return "Channel_altitude"; + case KIND_LAND_COVER_MAP: + return "Land_cover_map"; + case KIND_DTM: + return "DTM"; + case KIND_LISM: + return "LISM"; + case KIND_BC_POLYGON: + return "Boundary_Polygon"; + } + return ""; +} + QString HYDROData_Entity::GetObjPyName() const { QString aName = GetName(); aName.replace(QRegExp("[\\W]"), "_"); + if( aName[0].isDigit() ) + aName = GetType() + "_" + aName; + return aName; } -void HYDROData_Entity::SetName(const QString& theName) +QString HYDROData_Entity::GetDefaultName() const { - TDataStd_Name::Set(myLab, TCollection_ExtendedString(theName.toLatin1().constData())); + QString aName; + + TDF_Label aLabel = myLab.FindChild(DataTag_DefaultName, false); + if (!aLabel.IsNull()) + { + Handle(TDataStd_AsciiString) anAsciiStr; + if (aLabel.FindAttribute(TDataStd_AsciiString::GetID(), anAsciiStr)) + aName = QString(anAsciiStr->Get().ToCString()); + } + else + aName = GetName(); + + return aName; + } -QStringList HYDROData_Entity::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +void HYDROData_Entity::SetName(const QString& theName, bool isDefault) +{ + Handle(TDataStd_Name) A = TDataStd_Name::Set(myLab, TCollection_ExtendedString(theName.toLatin1().constData())); + A->SetID(TDataStd_Name::GetID()); + if (isDefault) + { + TDF_Label aDefaultNameLabel = myLab.FindChild( DataTag_DefaultName, true ); + if ( aDefaultNameLabel.IsNull() ) + return; + Handle(TDataStd_AsciiString) theDefaultName; + + if ( !aDefaultNameLabel.FindAttribute( TDataStd_AsciiString::GetID(), theDefaultName )) + { + TCollection_AsciiString aName = theName.toStdString().c_str(); + theDefaultName = TDataStd_AsciiString::Set(myLab.FindChild( DataTag_DefaultName), aName ); + theDefaultName->SetID( TDataStd_AsciiString::GetID() ); + } + } +} + +QStringList HYDROData_Entity::DumpToPython( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects ) const { QStringList anEmptyList; return anEmptyList; @@ -82,7 +214,7 @@ QStringList HYDROData_Entity::DumpToPython( MapOfTreatedObjects& theTreatedObjec void HYDROData_Entity::Update() { - SetToUpdate( false ); + ClearChanged(); } void HYDROData_Entity::UpdateLocalCS( double theDx, double theDy ) @@ -100,7 +232,7 @@ void HYDROData_Entity::Show() if ( !IsHas2dPrs() ) return; - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document(); if ( aDocument.IsNull() ) return; @@ -112,31 +244,63 @@ QVariant HYDROData_Entity::GetDataVariant() return QVariant(); } -void HYDROData_Entity::SetToUpdate( bool theFlag ) +void HYDROData_Entity::ClearChanged() { - if ( IsMustBeUpdated() == theFlag ) + Handle(TDataStd_Integer) A = TDataStd_Integer::Set( myLab.FindChild( DataTag_GeomChange ), 0 ); + A->SetID(TDataStd_Integer::GetID()); +} + +int HYDROData_Entity::GetGeomChangeFlag() const +{ + int aGeomChangeFlag = 0; + Handle(TDataStd_Integer) aGeomChangeAttr; + TDF_Label aGeomChangeLab = myLab.FindChild( DataTag_GeomChange ); + aGeomChangeLab.FindAttribute( TDataStd_Integer::GetID(), aGeomChangeAttr ); + if ( !aGeomChangeAttr.IsNull() ) + aGeomChangeFlag = aGeomChangeAttr->Get(); + return aGeomChangeFlag; +} + +void HYDROData_Entity::Changed( Geometry theChangedGeometry ) +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document(); + if( aDocument.IsNull() ) return; - if ( theFlag ) - { - TDataStd_UAttribute::Set( myLab, GUID_MUST_BE_UPDATED ); + int aGeomChangeFlag = 0; + Handle(TDataStd_Integer) aGeomChangeAttr; + TDF_Label aGeomChangeLab = myLab.FindChild( DataTag_GeomChange ); + aGeomChangeLab.FindAttribute( TDataStd_Integer::GetID(), aGeomChangeAttr ); + if ( !aGeomChangeAttr.IsNull() ) + aGeomChangeFlag = aGeomChangeAttr->Get(); - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); - if ( !aDocument.IsNull() ) + int aBitsToChange = ( myGeom & theChangedGeometry ); + if( aBitsToChange == 0 ) + return; + + aGeomChangeFlag = ( aGeomChangeFlag | aBitsToChange ); + Handle(TDataStd_Integer) anAttr = TDataStd_Integer::Set( aGeomChangeLab, aGeomChangeFlag ); + anAttr->SetID( TDataStd_Integer::GetID() ); + + HYDROData_Iterator anIter( aDocument ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Entity) anObject = anIter.Current(); + if( anObject.IsNull() ) + continue; + HYDROData_SequenceOfObjects aRefSeq = anObject->GetAllReferenceObjects(); + for ( int i = 1, n = aRefSeq.Length(); i <= n; ++i ) { - // Change the states of this and all depended objects - HYDROData_Tool::SetMustBeUpdatedObjects( aDocument ); + Handle(HYDROData_Entity) aRefObject = aRefSeq.Value( i ); + if( aRefObject->Label()==myLab ) + anObject->Changed( theChangedGeometry ); } } - else - { - myLab.ForgetAttribute( GUID_MUST_BE_UPDATED ); - } } -bool HYDROData_Entity::IsMustBeUpdated() const +bool HYDROData_Entity::IsMustBeUpdated( Geometry theGeom ) const { - return myLab.IsAttribute( GUID_MUST_BE_UPDATED ); + return ( ( GetGeomChangeFlag() & theGeom ) != 0 ); } bool HYDROData_Entity::CanBeUpdated() const @@ -159,7 +323,8 @@ bool HYDROData_Entity::CanRemove() return true; } -HYDROData_Entity::HYDROData_Entity() +HYDROData_Entity::HYDROData_Entity( Geometry theGeom ) + : myGeom( theGeom ) { } @@ -167,9 +332,10 @@ HYDROData_Entity::~HYDROData_Entity() { } -void HYDROData_Entity::CopyTo( const Handle(HYDROData_Entity)& theDestination ) const +void HYDROData_Entity::CopyTo( const Handle(HYDROData_Entity)& theDestination, + bool isGenerateNewName ) const { - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document(); if ( aDocument.IsNull() ) { return; } @@ -177,23 +343,26 @@ void HYDROData_Entity::CopyTo( const Handle(HYDROData_Entity)& theDestination ) TDF_CopyLabel aCopy(myLab, theDestination->Label()); aCopy.Perform(); - // generate a new unique name for the clone object: - // case 1: Image_1 -> Image_2 - // case 2: ImageObj -> ImageObj_1 - QString aName = theDestination->GetName(); - QString aPrefix = aName; - if( aName.contains( '_' ) ) { // case 1 - QString aSuffix = aName.section( '_', -1 ); - bool anIsInteger = false; - aSuffix.toInt( &anIsInteger ); - if( anIsInteger ) - aPrefix = aName.section( '_', 0, -2 ); - } else { // case 2 - aPrefix = aName; - } + if( isGenerateNewName ) + { + // generate a new unique name for the clone object: + // case 1: Image_1 -> Image_2 + // case 2: ImageObj -> ImageObj_1 + QString aName = theDestination->GetName(); + QString aPrefix = aName; + if( aName.contains( '_' ) ) { // case 1 + QString aSuffix = aName.section( '_', -1 ); + bool anIsInteger = false; + aSuffix.toInt( &anIsInteger ); + if( anIsInteger ) + aPrefix = aName.section( '_', 0, -2 ); + } else { // case 2 + aPrefix = aName; + } - aName = HYDROData_Tool::GenerateObjectName( aDocument, aPrefix ); - theDestination->SetName( aName ); + aName = HYDROData_Tool::GenerateObjectName( aDocument, aPrefix ); + theDestination->SetName( aName ); + } } Handle(HYDROData_Entity) HYDROData_Entity::GetFatherObject() const @@ -219,7 +388,7 @@ HYDROData_SequenceOfObjects HYDROData_Entity::GetAllReferenceObjects() const return HYDROData_SequenceOfObjects(); } -Standard_Boolean HYDROData_Entity::GetZLevel( Standard_Integer& theLevel ) const +bool HYDROData_Entity::GetZLevel( Standard_Integer& theLevel ) const { theLevel = -1; @@ -230,16 +399,17 @@ Standard_Boolean HYDROData_Entity::GetZLevel( Standard_Integer& theLevel ) const if ( aLabel.FindAttribute( TDataStd_Integer::GetID(), anIntVal ) ) { theLevel = anIntVal->Get(); - return Standard_True; + return true; } } - return Standard_False; + return false; } void HYDROData_Entity::SetZLevel( const Standard_Integer& theLevel ) { - TDataStd_Integer::Set( myLab.FindChild( DataTag_ZLevel ), theLevel ); + Handle(TDataStd_Integer) A = TDataStd_Integer::Set( myLab.FindChild( DataTag_ZLevel ), theLevel ); + A->SetID(TDataStd_Integer::GetID()); } void HYDROData_Entity::RemoveZLevel() @@ -251,7 +421,7 @@ void HYDROData_Entity::RemoveZLevel() void HYDROData_Entity::SetLabel( const TDF_Label& theLabel ) { - myLab = theLabel; + myLab = theLabel; } void HYDROData_Entity::SaveByteArray( const int theTag, @@ -268,16 +438,21 @@ void HYDROData_Entity::SaveByteArray( const int theTag, Handle(TDataStd_ByteArray) aData; if (!aLab.FindAttribute(TDataStd_ByteArray::GetID(), aData)) { aData = TDataStd_ByteArray::Set(aLab, 1, theLen); + aData->SetID( TDataStd_ByteArray::GetID() ); } + Standard_Byte* Byte0 = &(aData->InternalArray()->ChangeArray1().ChangeFirst()); + memcpy(Byte0, theData, theLen * sizeof (char)); // copy bytes one by one if (aData->Length() != theLen) { Handle(TColStd_HArray1OfByte) aNewData = new TColStd_HArray1OfByte(1, theLen); for(int a = 0; a < theLen; a++) aNewData->SetValue(a + 1, theData[a]); aData->ChangeArray(aNewData); - } else { - for(int a = 0; a < theLen; a++) - aData->SetValue(a + 1, theData[a]); + } + else + { + // for(int a = 0; a < theLen; a++) + // aData->SetValue(a + 1, theData[a]); } } @@ -299,7 +474,7 @@ int HYDROData_Entity::NbReferenceObjects( const int theTag ) const return aRefs.IsNull() ? 0 : aRefs->Extent(); } -bool HYDROData_Entity::HasReference( const Handle_HYDROData_Entity& theObj, +bool HYDROData_Entity::HasReference( const Handle(HYDROData_Entity)& theObj, const int theTag ) const { if ( theObj.IsNull() ) @@ -320,7 +495,7 @@ bool HYDROData_Entity::HasReference( const Handle_HYDROData_Entity& theObj, return false; } -void HYDROData_Entity::AddReferenceObject( const Handle_HYDROData_Entity& theObj, +void HYDROData_Entity::AddReferenceObject( const Handle(HYDROData_Entity)& theObj, const int theTag ) { if ( theObj.IsNull() ) @@ -328,9 +503,10 @@ void HYDROData_Entity::AddReferenceObject( const Handle_HYDROData_Entity& theObj Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, true ); aRefs->Append( theObj->Label() ); + aRefs->SetID(TDataStd_ReferenceList::GetID()); } -void HYDROData_Entity::SetReferenceObject( const Handle_HYDROData_Entity& theObj, +void HYDROData_Entity::SetReferenceObject( const Handle(HYDROData_Entity)& theObj, const int theTag, const int theIndex ) { @@ -364,7 +540,7 @@ void HYDROData_Entity::SetReferenceObject( const Handle_HYDROData_Entity& theObj } } -void HYDROData_Entity::InsertReferenceObject( const Handle_HYDROData_Entity& theObj, +void HYDROData_Entity::InsertReferenceObject( const Handle(HYDROData_Entity)& theObj, const int theTag, const int theBeforeIndex ) { @@ -406,6 +582,7 @@ void HYDROData_Entity::SetReferenceObjects( const HYDROData_SequenceOfObjects& t Handle(HYDROData_Entity) HYDROData_Entity::GetReferenceObject( const int theTag, const int theIndex ) const { + //DEBTRACE("GetReferenceObject " << theTag << " " << theIndex); Handle(HYDROData_Entity) aRes; Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false ); @@ -495,12 +672,15 @@ void HYDROData_Entity::ClearReferenceObjects( const int theTag ) Handle(TDataStd_ReferenceList) HYDROData_Entity::getReferenceList( const int theTag, const bool theIsCreate ) const { + //DEBTRACE("getReferenceList " << theTag << " " << theIsCreate); TDF_Label aLabel = theTag == 0 ? myLab : myLab.FindChild( theTag ); Handle(TDataStd_ReferenceList) aRefs; if ( !aLabel.FindAttribute( TDataStd_ReferenceList::GetID(), aRefs ) && theIsCreate ) + { aRefs = TDataStd_ReferenceList::Set( aLabel ); - + aRefs->SetID(TDataStd_ReferenceList::GetID()); + } return aRefs; } @@ -511,7 +691,10 @@ void HYDROData_Entity::SetColor( const QColor& theColor, Handle(TDataStd_IntegerArray) aColorArray; if ( !aLabel.FindAttribute( TDataStd_IntegerArray::GetID(), aColorArray ) ) + { aColorArray = TDataStd_IntegerArray::Set( aLabel, 1, 4 ); + aColorArray->SetID(TDataStd_IntegerArray::GetID()); + } aColorArray->SetValue( 1, theColor.red() ); aColorArray->SetValue( 2, theColor.green() ); @@ -538,20 +721,39 @@ QColor HYDROData_Entity::GetColor( const QColor& theDefColor, return aResColor; } +bool HYDROData_Entity::GetColor( QColor& theOutColor, + const int theTag ) const +{ + TDF_Label aLabel = theTag == 0 ? myLab : myLab.FindChild( theTag ); + + Handle(TDataStd_IntegerArray) aColorArray; + if ( aLabel.FindAttribute( TDataStd_IntegerArray::GetID(), aColorArray ) ) + { + theOutColor.setRed( aColorArray->Value( 1 ) ); + theOutColor.setGreen( aColorArray->Value( 2 ) ); + theOutColor.setBlue( aColorArray->Value( 3 ) ); + theOutColor.setAlpha( aColorArray->Value( 4 ) ); + return true; + } + + return false; +} + + QStringList HYDROData_Entity::dumpObjectCreation( MapOfTreatedObjects& theTreatedObjects ) const { QStringList aResList; - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document(); if ( aDocument.IsNull() ) return aResList; QString aDocName = aDocument->GetDocPyName(); QString aName = GetObjPyName(); - aResList << QString( "%1 = %2.CreateObject( %3 );" ) + aResList << QString( "%1 = %2.CreateObject( %3 )" ) .arg( aName ).arg( aDocName ).arg( getPyTypeID() ); - aResList << QString( "%1.SetName( \"%2\" );" ) + aResList << QString( "%1.SetName( \"%2\" )" ) .arg( aName ).arg( GetName() ); aResList << QString( "" ); @@ -561,7 +763,7 @@ QStringList HYDROData_Entity::dumpObjectCreation( MapOfTreatedObjects& theTreate Standard_Integer anObjZLevel = -1; if ( GetZLevel( anObjZLevel ) ) { - aResList << QString( "%1.SetZLevel( %2 );" ) + aResList << QString( "%1.SetZLevel( %2 )" ) .arg( aName ).arg( anObjZLevel ); aResList << QString( "" ); } @@ -572,6 +774,7 @@ QStringList HYDROData_Entity::dumpObjectCreation( MapOfTreatedObjects& theTreate QString HYDROData_Entity::getPyTypeID() const { + //DEBTRACE("HYDROData_Entity::getPyTypeID " << GetKind()); switch( GetKind() ) { case KIND_IMAGE: return "KIND_IMAGE"; @@ -596,29 +799,36 @@ QString HYDROData_Entity::getPyTypeID() const case KIND_NATURAL_OBJECT: return "KIND_NATURAL_OBJECT"; case KIND_DUMMY_3D: return "KIND_DUMMY_3D"; case KIND_SHAPES_GROUP: return "KIND_SHAPES_GROUP"; - case KIND_SPLITTED_GROUP: return "KIND_SPLITTED_GROUP"; + case KIND_SPLIT_GROUP: return "KIND_SPLIT_GROUP"; case KIND_STREAM_ALTITUDE: return "KIND_STREAM_ALTITUDE"; case KIND_OBSTACLE_ALTITUDE: return "KIND_OBSTACLE_ALTITUDE"; + case KIND_STRICKLER_TABLE: return "KIND_STRICKLER_TABLE"; + case KIND_LAND_COVER_OBSOLETE: return ""; + case KIND_CHANNEL_ALTITUDE: return "KIND_CHANNEL_ALTITUDE"; + case KIND_LAND_COVER_MAP: return "KIND_LAND_COVER_MAP"; + case KIND_BC_POLYGON: return "KIND_BC_POLYGON"; default: return "KIND_UNKNOWN"; ///! Unrecognized object } } -void HYDROData_Entity::setPythonReferenceObject( MapOfTreatedObjects& theTreatedObjects, +void HYDROData_Entity::setPythonReferenceObject( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects, QStringList& theScript, const Handle(HYDROData_Entity)& theRefObject, const QString& theMethod ) const { - if ( !checkObjectPythonDefinition( theTreatedObjects, theScript, theRefObject ) ) + if ( !checkObjectPythonDefinition( thePyScriptPath, theTreatedObjects, theScript, theRefObject ) ) return; QString aRefObjName = theRefObject->GetObjPyName(); QString anObjName = GetObjPyName(); - theScript << QString( "%1.%2( %3 );" ) + theScript << QString( "%1.%2( %3 )" ) .arg( anObjName ).arg( theMethod ).arg( aRefObjName ); } -bool HYDROData_Entity::checkObjectPythonDefinition( MapOfTreatedObjects& theTreatedObjects, +bool HYDROData_Entity::checkObjectPythonDefinition( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects, QStringList& theScript, const Handle(HYDROData_Entity)& theRefObject ) const { @@ -633,7 +843,7 @@ bool HYDROData_Entity::checkObjectPythonDefinition( MapOfTreatedObjects& return true; // The definition of reference object must be dumped before this - QStringList aRefObjDump = theRefObject->DumpToPython( theTreatedObjects ); + QStringList aRefObjDump = theRefObject->DumpToPython( thePyScriptPath, theTreatedObjects ); if ( aRefObjDump.isEmpty() ) return false; @@ -657,20 +867,113 @@ void HYDROData_Entity::setPythonObjectColor( QStringList& theScript, return; //Do not set the color for object if it like default QString anObjName = GetObjPyName(); - theScript << QString( "%1.%2( QColor( %3, %4, %5, %6 ) );" ) + theScript << QString( "%1.%2( QColor( %3, %4, %5, %6 ) )" ) .arg( anObjName ).arg( theMethod ) .arg( theColor.red() ).arg( theColor.green() ) .arg( theColor.blue() ).arg( theColor.alpha() ); } -void HYDROData_Entity::findPythonReferenceObject( MapOfTreatedObjects& theTreatedObjects, - QStringList& theScript ) const +void HYDROData_Entity::findPythonReferenceObject( QStringList& theScript, + QString defName) const { - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document(); if ( aDocument.IsNull() ) return; - - theScript << QString( "%1 = %2.FindObjectByName( \"%3\" );" ).arg( GetObjPyName() ) - .arg( aDocument->GetDocPyName() ) - .arg( GetName() ); + + if (defName.isEmpty()) + theScript << QString( "%1 = %2.FindObjectByName( \"%3\" )" ).arg( GetObjPyName() ) + .arg( aDocument->GetDocPyName() ) + .arg( GetDefaultName() ); + else + theScript << QString( "%1 = %2.FindObjectByName( \"%3\" )" ).arg( GetObjPyName() ) + .arg( aDocument->GetDocPyName() ) + .arg( defName ); +} + +void HYDROData_Entity::SetNameInDumpPython(QStringList& theScript, + QString theName) const +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document(); + if ( aDocument.IsNull() ) + return; + + if (theName.isEmpty()) + theScript << QString( "%1.SetName( \"%2\" )" ).arg( GetObjPyName() ) + .arg( GetName() ); + else + theScript << QString( "%1.SetName( \"%2\" )" ).arg( GetObjPyName() ) + .arg( theName ); } + +void HYDROData_Entity::SetShape( int theTag, const TopoDS_Shape& theShape ) +{ + TNaming_Builder aBuilder( myLab.FindChild( theTag ) ); + aBuilder.Generated( theShape ); + aBuilder.NamedShape()->SetID(TNaming_NamedShape::GetID()); +} + +TopoDS_Shape HYDROData_Entity::GetShape( int theTag ) const +{ + TDF_Label aShapeLabel = myLab.FindChild( theTag, false ); + if ( !aShapeLabel.IsNull() ) + { + Handle(TNaming_NamedShape) aNamedShape; + if ( aShapeLabel.FindAttribute( TNaming_NamedShape::GetID(), aNamedShape ) ) + return aNamedShape->Get(); + } + return TopoDS_Shape(); +} + +void HYDROData_Entity::SetDouble( int theTag, double theValue ) +{ + Handle(TDataStd_Real) anAttr; + TDF_Label aLabel = myLab.FindChild( theTag ); + if( !aLabel.FindAttribute( TDataStd_Real::GetID(), anAttr ) ) + { + anAttr = new TDataStd_Real(); + anAttr->SetID(TDataStd_Real::GetID()); + aLabel.AddAttribute( anAttr ); + } + anAttr->Set( theValue ); +} + +double HYDROData_Entity::GetDouble( int theTag, double theDefValue ) const +{ + Handle(TDataStd_Real) anAttr; + TDF_Label aLabel = myLab.FindChild( theTag ); + if( !aLabel.FindAttribute( TDataStd_Real::GetID(), anAttr ) ) + return theDefValue; + + return anAttr->Get(); +} + +void HYDROData_Entity::SetInteger( int theTag, int theValue ) +{ + Handle(TDataStd_Integer) anAttr; + TDF_Label aLabel = myLab.FindChild( theTag ); + if( !aLabel.FindAttribute( TDataStd_Integer::GetID(), anAttr ) ) + { + anAttr = new TDataStd_Integer(); + anAttr->SetID(TDataStd_Integer::GetID()); + aLabel.AddAttribute(anAttr); + } + anAttr->Set( theValue ); +} + +int HYDROData_Entity::GetInteger( int theTag, int theDefValue ) const +{ + Handle(TDataStd_Integer) anAttr; + TDF_Label aLabel = myLab.FindChild( theTag ); + if( !aLabel.FindAttribute( TDataStd_Integer::GetID(), anAttr ) ) + return theDefValue; + + return anAttr->Get(); +} + +bool HYDROData_Entity::CompareLabels(const Handle(HYDROData_Entity)& theOtherObj) +{ + if ( !theOtherObj.IsNull() ) + return this->Label() == theOtherObj->Label(); + return false; +} +