X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Entity.cxx;h=bd47a0901b01a77cefa535af91340f540d39da8c;hb=53ffa9fa57d352fcb5abc0e8a6bb79ea74e52621;hp=be8a51ed92dbaaf64064eed62fcba814f57f13c3;hpb=84f8b4a57d3cdad820bc1333a5066699cd1c8ae3;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_Entity.cxx b/src/HYDROData/HYDROData_Entity.cxx index be8a51ed..bd47a090 100644 --- a/src/HYDROData/HYDROData_Entity.cxx +++ b/src/HYDROData/HYDROData_Entity.cxx @@ -1,13 +1,32 @@ +// Copyright (C) 2014-2015 EDF-R&D +// 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, 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 +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// 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 @@ -19,6 +38,8 @@ #include #include +static const Standard_GUID GUID_MUST_BE_UPDATED("80f2bb81-3873-4631-8ddd-940d2119f000"); + IMPLEMENT_STANDARD_HANDLE(HYDROData_Entity,MMgt_TShared) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Entity,MMgt_TShared) @@ -26,7 +47,7 @@ IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Entity,MMgt_TShared) bool IsEqual(const Handle_HYDROData_Entity& theObj1, const Handle_HYDROData_Entity& theObj2) { if ( !theObj1.IsNull() && !theObj2.IsNull() ) - return theObj1->ID() == theObj2->ID(); + return theObj1->Label() == theObj2->Label(); return false; } @@ -40,6 +61,14 @@ QString HYDROData_Entity::GetName() const return QString(); } +QString HYDROData_Entity::GetObjPyName() const +{ + QString aName = GetName(); + aName.replace(QRegExp("[\\W]"), "_"); + + return aName; +} + void HYDROData_Entity::SetName(const QString& theName) { TDataStd_Name::Set(myLab, TCollection_ExtendedString(theName.toLatin1().constData())); @@ -51,8 +80,31 @@ QStringList HYDROData_Entity::DumpToPython( MapOfTreatedObjects& theTreatedObjec return anEmptyList; } -void HYDROData_Entity::Update( const bool theIsForce ) +void HYDROData_Entity::Update() +{ + SetToUpdate( false ); +} + +void HYDROData_Entity::UpdateLocalCS( double theDx, double theDy ) { + //On the base level no actions are necessary +} + +bool HYDROData_Entity::IsHas2dPrs() const +{ + return false; +} + +void HYDROData_Entity::Show() +{ + if ( !IsHas2dPrs() ) + return; + + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( aDocument.IsNull() ) + return; + + aDocument->Show( this ); } QVariant HYDROData_Entity::GetDataVariant() @@ -60,6 +112,38 @@ QVariant HYDROData_Entity::GetDataVariant() return QVariant(); } +void HYDROData_Entity::SetToUpdate( bool theFlag ) +{ + if ( IsMustBeUpdated() == theFlag ) + return; + + if ( theFlag ) + { + TDataStd_UAttribute::Set( myLab, GUID_MUST_BE_UPDATED ); + + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( !aDocument.IsNull() ) + { + // Change the states of this and all depended objects + HYDROData_Tool::SetMustBeUpdatedObjects( aDocument ); + } + } + else + { + myLab.ForgetAttribute( GUID_MUST_BE_UPDATED ); + } +} + +bool HYDROData_Entity::IsMustBeUpdated() const +{ + return myLab.IsAttribute( GUID_MUST_BE_UPDATED ); +} + +bool HYDROData_Entity::CanBeUpdated() const +{ + return true; +} + bool HYDROData_Entity::IsRemoved() const { return !myLab.HasAttribute(); @@ -70,6 +154,11 @@ void HYDROData_Entity::Remove() return myLab.ForgetAllAttributes( true ); } +bool HYDROData_Entity::CanRemove() +{ + return true; +} + HYDROData_Entity::HYDROData_Entity() { } @@ -78,19 +167,96 @@ HYDROData_Entity::~HYDROData_Entity() { } -void HYDROData_Entity::CopyTo(Handle_HYDROData_Entity theDestination) const +void HYDROData_Entity::CopyTo( const Handle(HYDROData_Entity)& theDestination ) const { + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( aDocument.IsNull() ) { + return; + } + 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; + } + + aName = HYDROData_Tool::GenerateObjectName( aDocument, aPrefix ); + theDestination->SetName( aName ); +} + +Handle(HYDROData_Entity) HYDROData_Entity::GetFatherObject() const +{ + Handle(HYDROData_Entity) aFather; + + if ( !myLab.IsNull() ) + { + TDF_Label aFatherLabel = myLab.Father(); + + while ( aFather.IsNull() && !aFatherLabel.IsNull() && !aFatherLabel.IsRoot() ) + { + aFather = HYDROData_Iterator::Object( aFatherLabel ); + aFatherLabel = aFatherLabel.Father(); + } + } + + return aFather; +} + +HYDROData_SequenceOfObjects HYDROData_Entity::GetAllReferenceObjects() const +{ + return HYDROData_SequenceOfObjects(); +} + +Standard_Boolean HYDROData_Entity::GetZLevel( Standard_Integer& theLevel ) const +{ + theLevel = -1; + + TDF_Label aLabel = myLab.FindChild( DataTag_ZLevel, false ); + if ( !aLabel.IsNull() ) + { + Handle(TDataStd_Integer) anIntVal; + if ( aLabel.FindAttribute( TDataStd_Integer::GetID(), anIntVal ) ) + { + theLevel = anIntVal->Get(); + return Standard_True; + } + } + + return Standard_False; +} + +void HYDROData_Entity::SetZLevel( const Standard_Integer& theLevel ) +{ + TDataStd_Integer::Set( myLab.FindChild( DataTag_ZLevel ), theLevel ); +} + +void HYDROData_Entity::RemoveZLevel() +{ + TDF_Label aLabel = myLab.FindChild( DataTag_ZLevel, false ); + if ( !aLabel.IsNull() ) + aLabel.ForgetAllAttributes(); } -void HYDROData_Entity::SetLabel(TDF_Label theLabel) +void HYDROData_Entity::SetLabel( const TDF_Label& theLabel ) { myLab = theLabel; } -void HYDROData_Entity::SaveByteArray(const int theTag, - const char* theData, const int theLen) +void HYDROData_Entity::SaveByteArray( const int theTag, + const char* theData, + const int theLen ) { TDF_Label aLab = theTag == 0 ? myLab : myLab.FindChild(theTag); // array is empty, remove the attribute @@ -133,6 +299,27 @@ int HYDROData_Entity::NbReferenceObjects( const int theTag ) const return aRefs.IsNull() ? 0 : aRefs->Extent(); } +bool HYDROData_Entity::HasReference( const Handle_HYDROData_Entity& theObj, + const int theTag ) const +{ + if ( theObj.IsNull() ) + return false; + + Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false ); + if ( aRefs.IsNull() || aRefs->IsEmpty() ) + return false; + + TDF_ListIteratorOfLabelList aListIt( aRefs->List() ); + for ( ; aListIt.More(); aListIt.Next() ) + { + const TDF_Label& aRefLabel = aListIt.Value(); + if ( theObj->Label() == aRefLabel ) + return true; + } + + return false; +} + void HYDROData_Entity::AddReferenceObject( const Handle_HYDROData_Entity& theObj, const int theTag ) { @@ -351,42 +538,141 @@ QColor HYDROData_Entity::GetColor( const QColor& theDefColor, return aResColor; } +QStringList HYDROData_Entity::dumpObjectCreation( MapOfTreatedObjects& theTreatedObjects ) const +{ + QStringList aResList; + + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( aDocument.IsNull() ) + return aResList; + + QString aDocName = aDocument->GetDocPyName(); + QString aName = GetObjPyName(); + + aResList << QString( "%1 = %2.CreateObject( %3 );" ) + .arg( aName ).arg( aDocName ).arg( getPyTypeID() ); + aResList << QString( "%1.SetName( \"%2\" );" ) + .arg( aName ).arg( GetName() ); + aResList << QString( "" ); + + if ( IsHas2dPrs() ) + { + // Dump object z-level in viewer + Standard_Integer anObjZLevel = -1; + if ( GetZLevel( anObjZLevel ) ) + { + aResList << QString( "%1.SetZLevel( %2 );" ) + .arg( aName ).arg( anObjZLevel ); + aResList << QString( "" ); + } + } + + return aResList; +} + +QString HYDROData_Entity::getPyTypeID() const +{ + switch( GetKind() ) + { + case KIND_IMAGE: return "KIND_IMAGE"; + case KIND_POLYLINE: return "KIND_POLYLINE"; + case KIND_BATHYMETRY: return "KIND_BATHYMETRY"; + case KIND_ALTITUDE: return "KIND_ALTITUDE"; + case KIND_IMMERSIBLE_ZONE: return "KIND_IMMERSIBLE_ZONE"; + case KIND_RIVER: return "KIND_RIVER"; + case KIND_STREAM: return "KIND_STREAM"; + case KIND_CONFLUENCE: return "KIND_CONFLUENCE"; + case KIND_CHANNEL: return "KIND_CHANNEL"; + case KIND_OBSTACLE: return "KIND_OBSTACLE"; + case KIND_DIGUE: return "KIND_DIGUE"; + case KIND_PROFILE: return "KIND_PROFILE"; + case KIND_PROFILEUZ: return "KIND_PROFILEUZ"; + case KIND_POLYLINEXY: return "KIND_POLYLINEXY"; + case KIND_CALCULATION: return "KIND_CALCULATION"; + case KIND_ZONE: return "KIND_ZONE"; + case KIND_REGION: return "KIND_REGION"; + case KIND_VISUAL_STATE: return "KIND_VISUAL_STATE"; + case KIND_ARTIFICIAL_OBJECT: return "KIND_ARTIFICIAL_OBJECT"; + 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_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: return "KIND_LAND_COVER"; + default: return "KIND_UNKNOWN"; ///! Unrecognized object + } +} + void HYDROData_Entity::setPythonReferenceObject( MapOfTreatedObjects& theTreatedObjects, QStringList& theScript, const Handle(HYDROData_Entity)& theRefObject, const QString& theMethod ) const { - if ( theRefObject.IsNull() ) + if ( !checkObjectPythonDefinition( theTreatedObjects, theScript, theRefObject ) ) return; + QString aRefObjName = theRefObject->GetObjPyName(); + + QString anObjName = GetObjPyName(); + theScript << QString( "%1.%2( %3 );" ) + .arg( anObjName ).arg( theMethod ).arg( aRefObjName ); +} + +bool HYDROData_Entity::checkObjectPythonDefinition( MapOfTreatedObjects& theTreatedObjects, + QStringList& theScript, + const Handle(HYDROData_Entity)& theRefObject ) const +{ + if ( theRefObject.IsNull() ) + return false; + QString aRefObjName = theRefObject->GetName(); if ( aRefObjName.isEmpty() ) - return; + return false; - bool anIsToSetObject = true; + if ( theTreatedObjects.contains( aRefObjName ) ) + return true; // The definition of reference object must be dumped before this - if ( !theTreatedObjects.contains( aRefObjName ) ) - { - // Write definition of reference polyline - QStringList aRefObjDump = theRefObject->DumpToPython( theTreatedObjects ); - if ( ( anIsToSetObject = !aRefObjDump.isEmpty() ) ) - { - QStringList aTmpList = theScript; - theScript = aRefObjDump; + QStringList aRefObjDump = theRefObject->DumpToPython( theTreatedObjects ); + if ( aRefObjDump.isEmpty() ) + return false; - theScript << QString( "" ); - theScript << aTmpList; + QStringList aTmpList = theScript; + theScript = aRefObjDump; - theTreatedObjects.insert( aRefObjName, theRefObject ); - } - } + theScript << QString( "" ); + theScript << aTmpList; - if ( anIsToSetObject ) - { - theScript << QString( "%1.%2( %3 );" ) - .arg( GetName() ).arg( theMethod ).arg( aRefObjName ); - } + theTreatedObjects.insert( aRefObjName, theRefObject ); + + return true; } +void HYDROData_Entity::setPythonObjectColor( QStringList& theScript, + const QColor& theColor, + const QColor& theDefaultColor, + const QString& theMethod ) const +{ + if ( theColor == theDefaultColor ) + return; //Do not set the color for object if it like default + + QString anObjName = GetObjPyName(); + 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 +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( aDocument.IsNull() ) + return; + + theScript << QString( "%1 = %2.FindObjectByName( \"%3\" );" ).arg( GetObjPyName() ) + .arg( aDocument->GetDocPyName() ) + .arg( GetName() ); +}