-#include <HYDROData_Object.h>
+
+#include "HYDROData_Object.h"
+
+#include "HYDROData_Iterator.h"
#include <TDataStd_Name.hxx>
#include <TDataStd_ByteArray.hxx>
#include <TDataStd_IntegerArray.hxx>
#include <TDataStd_BooleanArray.hxx>
#include <TDataStd_RealArray.hxx>
+#include <TDataStd_ReferenceList.hxx>
+
#include <TDF_CopyLabel.hxx>
+#include <TDF_ListIteratorOfLabelList.hxx>
+
+#include <QColor>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
IMPLEMENT_STANDARD_HANDLE(HYDROData_Object,MMgt_TShared)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Object,MMgt_TShared)
TDataStd_Name::Set(myLab, TCollection_ExtendedString(theName.toLatin1().constData()));
}
+QStringList HYDROData_Object::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
+{
+ QStringList anEmptyList;
+ return anEmptyList;
+}
+
+void HYDROData_Object::Update( const bool theIsForce )
+{
+}
+
+QVariant HYDROData_Object::GetDataVariant()
+{
+ return QVariant();
+}
+
bool HYDROData_Object::IsRemoved() const
{
return !myLab.HasAttribute();
}
}
-const char* HYDROData_Object::ByteArray(const int theTag, int& theLen)
+const char* HYDROData_Object::ByteArray(const int theTag, int& theLen) const
{
TDF_Label aLab = theTag == 0 ? myLab : myLab.FindChild(theTag);
Handle(TDataStd_ByteArray) aData;
return (const char*)(&(aData->InternalArray()->ChangeArray1().ChangeValue(1)));
return NULL;
}
+
+int HYDROData_Object::NbReferenceObjects( const int theTag ) const
+{
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false );
+ return aRefs.IsNull() ? 0 : aRefs->Extent();
+}
+
+void HYDROData_Object::AddReferenceObject( const Handle_HYDROData_Object& theObj,
+ const int theTag )
+{
+ if ( theObj.IsNull() )
+ return;
+
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, true );
+ aRefs->Append( theObj->Label() );
+}
+
+void HYDROData_Object::SetReferenceObject( const Handle_HYDROData_Object& theObj,
+ const int theTag,
+ const int theIndex )
+{
+ if ( theObj.IsNull() )
+ {
+ RemoveReferenceObject( theTag, theIndex );
+ return;
+ }
+
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, true );
+
+ if ( theIndex >= aRefs->Extent() )
+ {
+ aRefs->Append( theObj->Label() );
+ }
+ else if ( theIndex < 0 )
+ {
+ aRefs->Prepend( theObj->Label() );
+ }
+ else
+ {
+ RemoveReferenceObject( theTag, theIndex );
+
+ Handle(HYDROData_Object) aBeforeObj = GetReferenceObject( theTag, theIndex );
+
+ aRefs = getReferenceList( theTag, true ); // because reference list can be removed
+ if ( !aBeforeObj.IsNull() )
+ aRefs->InsertBefore( theObj->Label(), aBeforeObj->Label() );
+ else
+ aRefs->Append( theObj->Label() );
+ }
+}
+
+void HYDROData_Object::SetReferenceObjects( const HYDROData_SequenceOfObjects& theObjects,
+ const int theTag )
+{
+ ClearReferenceObjects( theTag );
+ if ( theObjects.IsEmpty() )
+ return;
+
+ HYDROData_SequenceOfObjects::Iterator anIter( theObjects );
+ for ( ; anIter.More(); anIter.Next() )
+ AddReferenceObject( anIter.Value(), theTag );
+}
+
+Handle(HYDROData_Object) HYDROData_Object::GetReferenceObject( const int theTag,
+ const int theIndex ) const
+{
+ Handle(HYDROData_Object) aRes;
+
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false );
+ if ( aRefs.IsNull() || theIndex < 0 || theIndex >= aRefs->Extent() )
+ return aRes;
+
+ TDF_ListIteratorOfLabelList anIter( aRefs->List() );
+ for ( int anIndex = 0; anIndex != theIndex && anIter.More(); anIter.Next(), ++anIndex );
+
+ const TDF_Label& aRefLabel = anIter.Value();
+ aRes = HYDROData_Iterator::Object( aRefLabel );
+
+ return aRes;
+}
+
+HYDROData_SequenceOfObjects HYDROData_Object::GetReferenceObjects( const int theTag ) const
+{
+ HYDROData_SequenceOfObjects aRes;
+
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false );
+ if ( aRefs.IsNull() )
+ return aRes;
+
+ TDF_ListIteratorOfLabelList anIter( aRefs->List() );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ const TDF_Label& aRefLabel = anIter.Value();
+
+ Handle(HYDROData_Object) aRefObject = HYDROData_Iterator::Object( aRefLabel );
+ if ( aRefObject.IsNull() )
+ continue;
+
+ aRes.Append( aRefObject );
+ }
+
+ return aRes;
+}
+
+void HYDROData_Object::RemoveReferenceObject( const int theTag,
+ const int theIndex )
+{
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false );
+ if ( aRefs.IsNull() )
+ return;
+
+ if ( aRefs->Extent() == 1 && theIndex == 0 )
+ {
+ // remove all if only one
+ ClearReferenceObjects( theTag );
+ return;
+ }
+
+ int anIndex = 0;
+ TDF_ListIteratorOfLabelList anIter( aRefs->List() );
+ for ( ; anIndex != theIndex && anIter.More(); anIter.Next(), ++anIndex );
+
+ if ( anIndex != theIndex )
+ return;
+
+ const TDF_Label& aRefLabel = anIter.Value();
+ aRefs->Remove( aRefLabel );
+}
+
+void HYDROData_Object::ClearReferenceObjects( const int theTag )
+{
+ TDF_Label aSetLabel = theTag == 0 ? myLab : myLab.FindChild( theTag );
+ aSetLabel.ForgetAttribute( TDataStd_ReferenceList::GetID() );
+}
+
+Handle(TDataStd_ReferenceList) HYDROData_Object::getReferenceList( const int theTag,
+ const bool theIsCreate ) const
+{
+ 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 );
+
+ return aRefs;
+}
+
+void HYDROData_Object::SetColor( const QColor& theColor,
+ const int theTag )
+{
+ TDF_Label aLabel = theTag == 0 ? myLab : myLab.FindChild( theTag );
+
+ Handle(TDataStd_IntegerArray) aColorArray;
+ if ( !aLabel.FindAttribute( TDataStd_IntegerArray::GetID(), aColorArray ) )
+ aColorArray = TDataStd_IntegerArray::Set( aLabel, 1, 4 );
+
+ aColorArray->SetValue( 1, theColor.red() );
+ aColorArray->SetValue( 2, theColor.green() );
+ aColorArray->SetValue( 3, theColor.blue() );
+ aColorArray->SetValue( 4, theColor.alpha() );
+}
+
+QColor HYDROData_Object::GetColor( const QColor& theDefColor,
+ const int theTag ) const
+{
+ QColor aResColor = theDefColor;
+
+ TDF_Label aLabel = theTag == 0 ? myLab : myLab.FindChild( theTag );
+
+ Handle(TDataStd_IntegerArray) aColorArray;
+ if ( aLabel.FindAttribute( TDataStd_IntegerArray::GetID(), aColorArray ) )
+ {
+ aResColor.setRed( aColorArray->Value( 1 ) );
+ aResColor.setGreen( aColorArray->Value( 2 ) );
+ aResColor.setBlue( aColorArray->Value( 3 ) );
+ aResColor.setAlpha( aColorArray->Value( 4 ) );
+ }
+
+ return aResColor;
+}
+
+void HYDROData_Object::setPythonReferenceObject( MapOfTreatedObjects& theTreatedObjects,
+ QStringList& theScript,
+ const Handle(HYDROData_Object)& theRefObject,
+ const QString& theMethod ) const
+{
+ if ( theRefObject.IsNull() )
+ return;
+
+ QString aRefObjName = theRefObject->GetName();
+ if ( aRefObjName.isEmpty() )
+ return;
+
+ bool anIsToSetObject = true;
+
+ // The definition of reference polyline 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;
+
+ theScript << QString( "" );
+ theScript << aTmpList;
+
+ theTreatedObjects.insert( aRefObjName, theRefObject );
+ }
+ }
+
+ if ( anIsToSetObject )
+ {
+ theScript << QString( "%1.%2( %3 );" )
+ .arg( GetName() ).arg( theMethod ).arg( aRefObjName );
+ }
+}
+
+
