X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Object.cxx;h=2ee9bd7ec4788fab611f7367eaebf3bf9173df72;hb=f108c7fd8c3b2dbb8c263b14456a31f8dd1d0921;hp=fe71e385569bfe734eb73ea5afe2c925ca650543;hpb=94f079c9197f9655e023e5047feffea452b4a1fe;p=modules%2Fhydro.git

diff --git a/src/HYDROData/HYDROData_Object.cxx b/src/HYDROData/HYDROData_Object.cxx
index fe71e385..2ee9bd7e 100644
--- a/src/HYDROData/HYDROData_Object.cxx
+++ b/src/HYDROData/HYDROData_Object.cxx
@@ -1,11 +1,23 @@
-#include <HYDROData_Object.h>
+
+#include "HYDROData_Object.h"
+
+#include "HYDROData_Iterator.h"
 
 #include <TDataStd_Name.hxx>
 #include <TDataStd_ByteArray.hxx>
 #include <TDataStd_UAttribute.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>
 
-static const Standard_GUID GUID_VISIBILITY("d6a715c5-9c86-4adc-8a6c-13188f3ad94b");
+#include <QColor>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
 
 IMPLEMENT_STANDARD_HANDLE(HYDROData_Object,MMgt_TShared)
 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Object,MMgt_TShared)
@@ -31,18 +43,19 @@ void HYDROData_Object::SetName(const QString& theName)
   TDataStd_Name::Set(myLab, TCollection_ExtendedString(theName.toLatin1().constData()));
 }
 
-bool HYDROData_Object::GetVisibility() const
+QStringList HYDROData_Object::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
 {
-  return myLab.IsAttribute(GUID_VISIBILITY);
+  QStringList anEmptyList;
+  return anEmptyList;
 }
 
-void HYDROData_Object::SetVisibility(bool theState)
+void HYDROData_Object::Update( const bool theIsForce )
 {
-  if (theState) {
-    TDataStd_UAttribute::Set(myLab, GUID_VISIBILITY);
-  } else {
-    myLab.ForgetAttribute(GUID_VISIBILITY);
-  }
+}
+
+QVariant HYDROData_Object::GetDataVariant()
+{
+  return QVariant();
 }
 
 bool HYDROData_Object::IsRemoved() const
@@ -100,7 +113,7 @@ void HYDROData_Object::SaveByteArray(const int theTag,
   }
 }
 
-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;
@@ -111,3 +124,223 @@ const char* HYDROData_Object::ByteArray(const int theTag, int& theLen)
     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 );
+  }
+}
+
+