-#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()));
}
-bool HYDROData_Object::IsVisible( const int theViewId ) const
+QStringList HYDROData_Object::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
{
- ViewId2VisualStateMap aMap;
- GetViewId2VisualStateMap( aMap );
- if( aMap.find( theViewId ) != aMap.end() )
- {
- const VisualState& aVisualState = aMap[ theViewId ];
- return aVisualState.Visibility;
- }
- return false;
+ QStringList anEmptyList;
+ return anEmptyList;
}
-void HYDROData_Object::SetVisible( const int theViewId,
- const bool theVal )
+void HYDROData_Object::Update( const bool theIsForce )
{
- if( theViewId == 0 )
- return;
-
- ViewId2VisualStateMap aMap;
- GetViewId2VisualStateMap( aMap );
-
- VisualState& aVisualState = aMap[ theViewId ];
- aVisualState.Visibility = theVal;
+}
- SetViewId2VisualStateMap( aMap );
+QVariant HYDROData_Object::GetDataVariant()
+{
+ return QVariant();
}
bool HYDROData_Object::IsRemoved() const
}
}
-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 NULL;
}
-void HYDROData_Object::GetViewId2VisualStateMap( ViewId2VisualStateMap& theMap ) const
+int HYDROData_Object::NbReferenceObjects( const int theTag ) const
{
- theMap.clear();
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false );
+ return aRefs.IsNull() ? 0 : aRefs->Extent();
+}
- TDF_Label aViewIdLab = myLab.FindChild( DataTag_ViewId );
- TDF_Label aVisibilityLab = myLab.FindChild( DataTag_Visibility );
- TDF_Label aTransparencyLab = myLab.FindChild( DataTag_Transparency );
- TDF_Label aZValueLab = myLab.FindChild( DataTag_ZValue );
+void HYDROData_Object::AddReferenceObject( const Handle_HYDROData_Object& theObj,
+ const int theTag )
+{
+ if ( theObj.IsNull() )
+ return;
- Handle(TDataStd_IntegerArray) aViewIdArray;
- Handle(TDataStd_BooleanArray) aVisibilityArray;
- Handle(TDataStd_RealArray) aTransparencyArray;
- Handle(TDataStd_RealArray) aZValueArray;
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, true );
+ aRefs->Append( theObj->Label() );
+}
- if( !aViewIdLab.FindAttribute( TDataStd_IntegerArray::GetID(), aViewIdArray ) ||
- !aVisibilityLab.FindAttribute( TDataStd_BooleanArray::GetID(), aVisibilityArray ) ||
- !aTransparencyLab.FindAttribute( TDataStd_RealArray::GetID(), aTransparencyArray ) ||
- !aZValueLab.FindAttribute( TDataStd_RealArray::GetID(), aZValueArray ) )
+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 );
- int aSize = qMin( qMin( aViewIdArray->Length(), aVisibilityArray->Length() ),
- qMin( aTransparencyArray->Length(), aZValueArray->Length() ) );
- for( int anIndex = 0; anIndex < aSize; anIndex++ )
+ if ( theIndex >= aRefs->Extent() )
+ {
+ aRefs->Append( theObj->Label() );
+ }
+ else if ( theIndex < 0 )
+ {
+ aRefs->Prepend( theObj->Label() );
+ }
+ else
{
- int aViewId = aViewIdArray->Value( anIndex );
- VisualState aVisualState;
- aVisualState.Visibility = aVisibilityArray->Value( anIndex );
- aVisualState.Transparency = aTransparencyArray->Value( anIndex );
- aVisualState.ZValue = aZValueArray->Value( anIndex );
- theMap[ aViewId ] = aVisualState;
+ 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::SetViewId2VisualStateMap( const ViewId2VisualStateMap& theMap )
+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
{
- TDF_Label aViewIdLab = myLab.FindChild( DataTag_ViewId );
- TDF_Label aVisibilityLab = myLab.FindChild( DataTag_Visibility );
- TDF_Label aTransparencyLab = myLab.FindChild( DataTag_Transparency );
- TDF_Label aZValueLab = myLab.FindChild( DataTag_ZValue );
+ HYDROData_SequenceOfObjects aRes;
- aViewIdLab.ForgetAllAttributes();
- aVisibilityLab.ForgetAllAttributes();
- aTransparencyLab.ForgetAllAttributes();
- aZValueLab.ForgetAllAttributes();
+ Handle(TDataStd_ReferenceList) aRefs = getReferenceList( theTag, false );
+ if ( aRefs.IsNull() )
+ return aRes;
- int aSize = theMap.size();
+ TDF_ListIteratorOfLabelList anIter( aRefs->List() );
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ const TDF_Label& aRefLabel = anIter.Value();
- Handle(TDataStd_IntegerArray) aViewIdArray =
- TDataStd_IntegerArray::Set( aViewIdLab, 0, aSize-1 );
- Handle(TDataStd_BooleanArray) aVisibilityArray =
- TDataStd_BooleanArray::Set( aVisibilityLab, 0, aSize-1 );
- Handle(TDataStd_RealArray) aTransparencyArray =
- TDataStd_RealArray::Set( aTransparencyLab, 0, aSize-1 );
- Handle(TDataStd_RealArray) aZValueArray =
- TDataStd_RealArray::Set( aZValueLab, 0, aSize-1 );
+ 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;
- ViewId2VisualStateMapIterator anIter( theMap );
- while( anIter.hasNext() )
+ 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 ) )
{
- int aViewId = anIter.next().key();
- const VisualState& aVisualState = anIter.value();
- aViewIdArray->SetValue( anIndex, aViewId );
- aVisibilityArray->SetValue( anIndex, aVisualState.Visibility );
- aTransparencyArray->SetValue( anIndex, aVisualState.Transparency );
- aZValueArray->SetValue( anIndex, aVisualState.ZValue );
- anIndex++;
+ 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 );
+ }
+}
+
+
