0031452: Impossible to get Backup of the attribute and status that attribute was...

Added methods returning flag that document or attributes on the specified labels have modifications from last commit.
Methods checks all child labels of specified label.
Added method to check that TObj_Object has modifications from last commit

diff --git a/src/TDF/TDF_Data.cxx b/src/TDF/TDF_Data.cxx
index 44ba6da880b034097fcf414aebafbde4c6e99854..b4e2b943021eb8cbcd1e3a816dcc5d500d1efc75 100644 (file)
--- a/src/TDF/TDF_Data.cxx
+++ b/src/TDF/TDF_Data.cxx
@@ -469,3 +469,32 @@ void TDF_Data::DumpJson (Standard_OStream& theOStream, Standard_Integer /*theDep
   }
   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myAllowModification)
 }
+
+//=======================================================================
+//function : HasModifications
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean TDF_Data::HasModifications(const TDF_Label& theLabel) const
+{
+  if( theLabel.IsNull())
+    return Standard_False;
+  //check that attributes were modified
+  Standard_Integer aRootTransaction = Root().Data()->Transaction();
+  TDF_AttributeIterator itAttr(theLabel, Standard_False);
+  for ( ; itAttr.More(); itAttr.Next()) 
+  {
+     Handle(TDF_Attribute) aCurrentAtt = itAttr.Value();
+     if(aCurrentAtt->Transaction() == aRootTransaction)
+       return Standard_True;
+  }
+
+  //check that child labels has modified attributes
+  TDF_ChildIterator itChild(theLabel);
+  for ( ; itChild.More(); itChild.Next()) 
+  {
+    if(HasModifications(itChild.Value()))
+      return Standard_True;
+  }
+  return Standard_False;
+}
\ No newline at end of file

diff --git a/src/TDF/TDF_Data.hxx b/src/TDF/TDF_Data.hxx
index 73a2341d3b6b4c9eaa9609bb12aa96cf30302807..8df22226d0065d0501ea89b70e9bd9605403bee8 100644 (file)
--- a/src/TDF/TDF_Data.hxx
+++ b/src/TDF/TDF_Data.hxx
@@ -137,6 +137,10 @@ Standard_OStream& operator<< (Standard_OStream& anOS) const
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
+  //! Returns true if data has modified attributes on the specified label theLabel and on the 
+  //! their child labels
+  Standard_EXPORT Standard_Boolean HasModifications(const TDF_Label& theLabel) const;
+
 friend class TDF_Transaction;
 friend class TDF_LabelNode;
 
@@ -190,6 +194,8 @@ private:
   //! current one.
   Standard_EXPORT Standard_Integer CommitTransaction (const TDF_Label& aLabel, const Handle(TDF_Delta)& aDelta, const Standard_Boolean withDelta);
 
+ 
+
   TDF_LabelNodePtr myRoot;
   Standard_Integer myTransaction;
   Standard_Integer myNbTouchedAtt;

diff --git a/src/TDocStd/TDocStd_Document.cxx b/src/TDocStd/TDocStd_Document.cxx
index 1319abbd0fdf5ebb7d34b3c09fdb5d5b04b24caa..8e23d38f6e5dc5a1c88b8ed955e07c6a02459694 100644 (file)
--- a/src/TDocStd/TDocStd_Document.cxx
+++ b/src/TDocStd/TDocStd_Document.cxx
@@ -941,3 +941,12 @@ void TDocStd_Document::DumpJson (Standard_OStream& theOStream, Standard_Integer
   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myOnlyTransactionModification)
   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, mySaveEmptyLabels)
 }
+
+//=======================================================================
+//function : DumpJson
+//purpose  : 
+//=======================================================================
+Standard_Boolean TDocStd_Document::HasModifications() const
+{
+  return myData->HasModifications(Main());
+}
\ No newline at end of file

diff --git a/src/TDocStd/TDocStd_Document.hxx b/src/TDocStd/TDocStd_Document.hxx
index 0d07b103d1df4f183215802c1d7ed073f342266e..86ca8795367b2c0546b18dbf2c66cb940c46b3e4 100644 (file)
--- a/src/TDocStd/TDocStd_Document.hxx
+++ b/src/TDocStd/TDocStd_Document.hxx
@@ -248,7 +248,8 @@ public:
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
-
+  //! Returns true if document has modified attributes since last transaction
+  Standard_EXPORT Standard_Boolean TDocStd_Document::HasModifications() const;
 
 
   DEFINE_STANDARD_RTTIEXT(TDocStd_Document,CDM_Document)

diff --git a/src/TObj/TObj_Object.cxx b/src/TObj/TObj_Object.cxx
index fb75fc194572947bc79590dd4124c5f2d5775190..baea95c2b12617e18af47cf31e0e31ff9ae6020b 100644 (file)
--- a/src/TObj/TObj_Object.cxx
+++ b/src/TObj/TObj_Object.cxx
@@ -54,7 +54,7 @@
 #include <TDF_TagSource.hxx>
 
 
-IMPLEMENT_STANDARD_RTTIEXT(TObj_Object,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(TObj_Object, Standard_Transient)
 
 //=======================================================================
 //function : Constructor
@@ -62,8 +62,8 @@ IMPLEMENT_STANDARD_RTTIEXT(TObj_Object,Standard_Transient)
 //=======================================================================
 
 TObj_Object::TObj_Object(const TDF_Label& theLabel,
-                                 const Standard_Boolean theSetName)
-     : myLabel(theLabel)
+  const Standard_Boolean theSetName)
+  : myLabel(theLabel)
 {
   Handle(TObj_Object) aMe = this;
   TObj_TObject::Set(myLabel, aMe);
@@ -80,23 +80,23 @@ Handle(TObj_Model) TObj_Object::GetModel() const
 {
   Handle(TObj_Model) aModel;
   // if object label is null object is not alive
-  if ( myLabel.IsNull() )
+  if (myLabel.IsNull())
     return aModel;
 
   //TDF_Label aLabel = TDocStd_Document::Get(myLabel)->Main();
   Handle(TDF_Data) aData = myLabel.Data();
   if (aData.IsNull())
     return aModel;
-  
+
   // try get the document from owner attribute manually
   TDF_Label aLabel = aData->Root();
   Handle(TDocStd_Owner) anOwnerAttr;
   Handle(TDocStd_Document) aTDoc;
-  if ( !aLabel.IsNull() && aLabel.FindAttribute( TDocStd_Owner::GetID(), anOwnerAttr ) )
+  if (!aLabel.IsNull() && aLabel.FindAttribute(TDocStd_Owner::GetID(), anOwnerAttr))
     aTDoc = anOwnerAttr->GetDocument();
   if (aTDoc.IsNull())
     return aModel;
-  
+
   // use main label of the document to find TObj model attribute
   aLabel = aTDoc->Main();
   Handle(TObj_TModel) aModelAttr;
@@ -114,21 +114,21 @@ Handle(TObj_Model) TObj_Object::GetModel() const
 //           theType narrows a variety of iterated objects
 //=======================================================================
 
-static void addObjToOrderSequence( const Handle(TObj_Object)& theObj,
-                                   const Standard_Integer         theOrder,
-                                   Handle(TObj_HSequenceOfObject)& theHSeqOfObj,
-                                   const Standard_Integer theHSeqLength,
-                                   Standard_Integer& theLastIndex,
-                                   Standard_Integer& theLastOrder )
+static void addObjToOrderSequence(const Handle(TObj_Object)& theObj,
+  const Standard_Integer         theOrder,
+  Handle(TObj_HSequenceOfObject)& theHSeqOfObj,
+  const Standard_Integer theHSeqLength,
+  Standard_Integer& theLastIndex,
+  Standard_Integer& theLastOrder)
 {
-  if ( theOrder > theLastOrder )
+  if (theOrder > theLastOrder)
   {
-    while ( theOrder > theLastOrder )
+    while (theOrder > theLastOrder)
     {
       // get next object and compare with them
-      if ( ++theLastIndex > theHSeqLength )
+      if (++theLastIndex > theHSeqLength)
       {
-        theHSeqOfObj->Append( theObj );
+        theHSeqOfObj->Append(theObj);
         theLastIndex = theHSeqLength + 1;
         theLastOrder = theOrder;
         return;
@@ -137,16 +137,16 @@ static void addObjToOrderSequence( const Handle(TObj_Object)& theObj,
       theLastOrder = aNext->GetOrder();
     }
     // add before current position
-    theHSeqOfObj->InsertBefore( theLastIndex, theObj );
+    theHSeqOfObj->InsertBefore(theLastIndex, theObj);
     theLastOrder = theOrder;
   }
   else
   {
-    while ( theOrder < theLastOrder )
+    while (theOrder < theLastOrder)
     {
-      if ( --theLastIndex < 1 )
+      if (--theLastIndex < 1)
       {
-        theHSeqOfObj->InsertBefore( 1, theObj );
+        theHSeqOfObj->InsertBefore(1, theObj);
         theLastIndex = 1;
         theLastOrder = theOrder;
         return;
@@ -156,7 +156,7 @@ static void addObjToOrderSequence( const Handle(TObj_Object)& theObj,
       theLastOrder = aNext->GetOrder();
     }
     // add object after current position
-    theHSeqOfObj->InsertAfter( theLastIndex, theObj );
+    theHSeqOfObj->InsertAfter(theLastIndex, theObj);
     theLastIndex++;
     theLastOrder = theOrder;
     return;
@@ -164,33 +164,33 @@ static void addObjToOrderSequence( const Handle(TObj_Object)& theObj,
 }
 
 Handle(TObj_ObjectIterator) TObj_Object::GetChildren
-                         (const Handle(Standard_Type)& theType) const
+(const Handle(Standard_Type)& theType) const
 {
   Handle(TObj_ObjectIterator) anItr =
     new TObj_OcafObjectIterator(GetChildLabel(), theType, Standard_True);
-  if ( !TestFlags( ObjectState_Ordered ) )
+  if (!TestFlags(ObjectState_Ordered))
     return anItr;
   // return object according to their order
   Standard_Integer aLastIndex = 0;
   Standard_Integer aLastOrder = 0;
   Handle(TObj_HSequenceOfObject) aHSeqOfObj = new TObj_HSequenceOfObject();
-  for ( ; anItr->More(); anItr->Next() )
+  for (; anItr->More(); anItr->Next())
   {
     Handle(TObj_Object) anObj = anItr->Value();
-    if ( anObj.IsNull() )
+    if (anObj.IsNull())
       continue;
     Standard_Integer anOrder = anObj->GetOrder();
-    if ( !aLastIndex )
+    if (!aLastIndex)
     {
-      aHSeqOfObj->Append( anObj );
+      aHSeqOfObj->Append(anObj);
       aLastIndex = 1;
       aLastOrder = anOrder;
     }
     else
-      addObjToOrderSequence( anObj, anOrder, aHSeqOfObj, aHSeqOfObj->Length(),
-                             aLastIndex, aLastOrder );
+      addObjToOrderSequence(anObj, anOrder, aHSeqOfObj, aHSeqOfObj->Length(),
+        aLastIndex, aLastOrder);
   }
-  return new TObj_SequenceIterator( aHSeqOfObj );
+  return new TObj_SequenceIterator(aHSeqOfObj);
 }
 
 //=======================================================================
@@ -201,13 +201,13 @@ Handle(TObj_ObjectIterator) TObj_Object::GetChildren
 
 #ifdef DFBROWSE
 static TDF_Label getLabelByRank(const TDF_Label& theL,
-                                const Standard_Integer theRank,
-                                const Standard_CString theName)
+  const Standard_Integer theRank,
+  const Standard_CString theName)
 {
-  TDF_Label L = theL.FindChild(theRank,Standard_False);
-  if ( L.IsNull() )
+  TDF_Label L = theL.FindChild(theRank, Standard_False);
+  if (L.IsNull())
   {
-    L = theL.FindChild(theRank,Standard_True);
+    L = theL.FindChild(theRank, Standard_True);
     TDataStd_Name::Set(L, theName);
   }
   return L;
@@ -222,9 +222,9 @@ static TDF_Label getLabelByRank(const TDF_Label& theL,
 TDF_Label TObj_Object::GetChildLabel() const
 {
 #ifdef DFBROWSE
-  return getLabelByRank(GetLabel(),4,"Children");
+  return getLabelByRank(GetLabel(), 4, "Children");
 #else
-  return GetLabel().FindChild ( 4, Standard_True );
+  return GetLabel().FindChild (4, Standard_True);
 #endif
 }
 
@@ -236,8 +236,8 @@ TDF_Label TObj_Object::GetChildLabel() const
 TDF_Label TObj_Object::getChildLabel(const Standard_Integer theRank) const
 {
   TDF_Label aLabel = GetChildLabel();
-  if ( theRank > 0 )
-    aLabel = aLabel.FindChild( theRank, Standard_True );
+  if (theRank > 0)
+    aLabel = aLabel.FindChild(theRank, Standard_True);
   return aLabel;
 }
 
@@ -260,24 +260,24 @@ Standard_Boolean TObj_Object::SetName(const Handle(TCollection_HExtendedString)&
 {
   // check if the name is exactly the same
   Handle(TCollection_HExtendedString) anOldName = GetName();
-  if( !anOldName.IsNull() && theName->String().IsEqual(anOldName->String()) )
+  if (!anOldName.IsNull() && theName->String().IsEqual(anOldName->String()))
     return Standard_True;
 
   // check if name is already registered and do nothing in that case
   const Handle(TObj_TNameContainer) aDictionary = GetDictionary();
   Handle(TObj_Model) aModel = GetModel();
-  if( aModel->IsRegisteredName( theName, aDictionary ) )
+  if (aModel->IsRegisteredName(theName, aDictionary))
     return Standard_False;
 
   // change name and update registry
   if (!anOldName.IsNull())
-    aModel->UnRegisterName( anOldName, aDictionary );
-  if ( theName.IsNull() ) 
-    GetLabel().ForgetAttribute ( TDataStd_Name::GetID() );
+    aModel->UnRegisterName(anOldName, aDictionary);
+  if (theName.IsNull())
+    GetLabel().ForgetAttribute (TDataStd_Name::GetID());
   else
   {
-    aModel->RegisterName( theName, GetLabel(), aDictionary );
-    TDataStd_Name::Set(GetLabel(),theName->String());
+    aModel->RegisterName(theName, GetLabel(), aDictionary);
+    TDataStd_Name::Set(GetLabel(), theName->String());
   }
   return Standard_True;
 }
@@ -289,7 +289,7 @@ Standard_Boolean TObj_Object::SetName(const Handle(TCollection_HExtendedString)&
 
 Standard_Boolean TObj_Object::SetName(const Handle(TCollection_HAsciiString)& theName) const
 {
-  return SetName( new TCollection_HExtendedString ( theName ) );
+  return SetName(new TCollection_HExtendedString (theName));
 }
 
 //=======================================================================
@@ -299,7 +299,7 @@ Standard_Boolean TObj_Object::SetName(const Handle(TCollection_HAsciiString)& th
 
 Standard_Boolean TObj_Object::SetName(const Standard_CString theName) const
 {
-  return SetName ( new TCollection_HAsciiString ( theName ) );
+  return SetName (new TCollection_HAsciiString (theName));
 }
 
 //=======================================================================
@@ -337,7 +337,7 @@ Standard_Boolean TObj_Object::GetName(TCollection_ExtendedString& theStr) const
 Standard_Boolean TObj_Object::GetName(TCollection_AsciiString& theName) const
 {
   Handle(TCollection_HExtendedString) aName = GetName();
-  if(aName.IsNull())
+  if (aName.IsNull())
     return Standard_False;
   theName = TCollection_AsciiString (aName->String());
   return theName.Length() != 0;
@@ -349,15 +349,15 @@ Standard_Boolean TObj_Object::GetName(TCollection_AsciiString& theName) const
 //=======================================================================
 
 Standard_Boolean TObj_Object::HasReference
-                         (const Handle(TObj_Object)& theObject) const
+(const Handle(TObj_Object)& theObject) const
 {
-  if ( theObject.IsNull() )
+  if (theObject.IsNull())
     return Standard_False;
   Handle(TObj_ObjectIterator) anItr = GetReferences(theObject->DynamicType());
-  if ( anItr.IsNull() || !anItr->More() )
+  if (anItr.IsNull() || !anItr->More())
     return Standard_False;
-  for ( ; anItr->More(); anItr->Next() )
-    if ( anItr->Value() == theObject )
+  for (; anItr->More(); anItr->Next())
+    if (anItr->Value() == theObject)
       return Standard_True;
   return Standard_False;
 }
@@ -368,7 +368,7 @@ Standard_Boolean TObj_Object::HasReference
 //=======================================================================
 
 Handle(TObj_ObjectIterator) TObj_Object::GetReferences
-                         (const Handle(Standard_Type)& theType) const
+(const Handle(Standard_Type)& theType) const
 {
   return new TObj_ReferenceIterator(GetReferenceLabel(), theType);
 }
@@ -395,7 +395,7 @@ void TObj_Object::AddBackReference (const Handle(TObj_Object)& theObject)
   if (myHSeqBackRef.IsNull())
     myHSeqBackRef = new TObj_HSequenceOfObject;
 
-  myHSeqBackRef->Append( theObject );
+  myHSeqBackRef->Append(theObject);
 }
 
 //=======================================================================
@@ -404,7 +404,7 @@ void TObj_Object::AddBackReference (const Handle(TObj_Object)& theObject)
 //=======================================================================
 
 void TObj_Object::RemoveBackReference (const Handle(TObj_Object)& theObject,
-                                           const Standard_Boolean theSingleOnly)
+  const Standard_Boolean theSingleOnly)
 {
   if (myHSeqBackRef.IsNull()) // to avoid exception.
     return;
@@ -427,9 +427,9 @@ void TObj_Object::RemoveBackReference (const Handle(TObj_Object)& theObject,
 //=======================================================================
 
 Handle(TObj_ObjectIterator) TObj_Object::GetBackReferences
-                         (const Handle(Standard_Type)& theType) const
+(const Handle(Standard_Type)& theType) const
 {
-  return new TObj_SequenceIterator( myHSeqBackRef, theType );
+  return new TObj_SequenceIterator(myHSeqBackRef, theType);
 }
 
 //=======================================================================
@@ -450,7 +450,7 @@ void TObj_Object::ClearBackReferences ()
 Standard_Boolean TObj_Object::HasBackReferences() const
 {
   Handle(TObj_ObjectIterator) anItr = GetBackReferences();
-  if ( anItr.IsNull() || !anItr->More() )
+  if (anItr.IsNull() || !anItr->More())
     return Standard_False;
   return Standard_True;
 }
@@ -461,7 +461,7 @@ Standard_Boolean TObj_Object::HasBackReferences() const
 //=======================================================================
 
 Standard_Boolean TObj_Object::CanRemoveReference
-  (const Handle(TObj_Object)& /*theObject*/) const
+(const Handle(TObj_Object)& /*theObject*/) const
 {
   return Standard_False;
 }
@@ -476,37 +476,37 @@ void TObj_Object::RemoveReference (const Handle(TObj_Object)& theObject)
   Handle(TObj_Object) aNullObj;
   ReplaceReference (theObject, aNullObj);
 }
-  
+
 //=======================================================================
 //function : CanDetach
 //purpose  :
 //=======================================================================
- Standard_Boolean TObj_Object::CanDetach(const TObj_DeletingMode theMode )
+Standard_Boolean TObj_Object::CanDetach(const TObj_DeletingMode theMode)
 {
-  if( !IsAlive() )
+  if (!IsAlive())
     return Standard_False;
-  
+
   Handle(TObj_ObjectIterator) aRefs = GetBackReferences();
-  
+
   // Free Object can be deleted in any Mode
-  if ( aRefs.IsNull() || ! aRefs->More() )
+  if (aRefs.IsNull() || ! aRefs->More())
     return Standard_True;
-  
-  if( theMode == TObj_FreeOnly )
+
+  if (theMode == TObj_FreeOnly)
     return Standard_False;
 
-  if( theMode == TObj_Forced )
+  if (theMode == TObj_Forced)
     return Standard_True;
 
   // check the last KeepDepending mode
   Handle(TObj_Object) aMe = this;
-  for( ; aRefs->More(); aRefs->Next()) 
+  for (; aRefs->More(); aRefs->Next())
   {
     Handle(TObj_Object) anObject = aRefs->Value();
-    if (! anObject->CanRemoveReference(aMe) )
+    if (! anObject->CanRemoveReference(aMe))
       return Standard_False; // one of objects could not be unlinked
   }
-    
+
   return Standard_True;
 }
 
@@ -517,11 +517,11 @@ void TObj_Object::RemoveReference (const Handle(TObj_Object)& theObject)
 
 Standard_Boolean TObj_Object::Detach(const TObj_DeletingMode theMode)
 {
-  if( !IsAlive() )
+  if (!IsAlive())
     return Standard_False;
 
   // if object can not be deleted returns False
-  if(!RemoveBackReferences(theMode))
+  if (!RemoveBackReferences(theMode))
     return Standard_False;
 
   Handle(TCollection_HExtendedString) anOldName = GetName();
@@ -529,7 +529,7 @@ Standard_Boolean TObj_Object::Detach(const TObj_DeletingMode theMode)
   // detaching childs
   Handle(TObj_ObjectIterator) aChildren = GetChildren();
 
-  for(;aChildren->More(); aChildren->Next())
+  for (;aChildren->More(); aChildren->Next())
     aChildren->Value()->Detach(theMode);
 
   // Clearing its own data
@@ -543,11 +543,11 @@ Standard_Boolean TObj_Object::Detach(const TObj_DeletingMode theMode)
   {
     const Handle(TObj_TNameContainer) aDictionary = GetDictionary();
     // unregister only it is registered to me.
-    if ( !aDictionary.IsNull() && aDictionary->IsRegistered( anOldName ) )
+    if (!aDictionary.IsNull() && aDictionary->IsRegistered(anOldName))
     {
-      TDF_Label aRegisteredLabel = aDictionary->Get().Find( anOldName );
-      if ( !aRegisteredLabel.IsNull() && aRegisteredLabel == GetLabel() )
-        aDictionary->RemoveName( anOldName );
+      TDF_Label aRegisteredLabel = aDictionary->Get().Find(anOldName);
+      if (!aRegisteredLabel.IsNull() && aRegisteredLabel == GetLabel())
+        aDictionary->RemoveName(anOldName);
     }
   }
   GetLabel().ForgetAllAttributes();
@@ -561,10 +561,10 @@ Standard_Boolean TObj_Object::Detach(const TObj_DeletingMode theMode)
 //=======================================================================
 
 Standard_Boolean TObj_Object::Detach(const TDF_Label& theLabel,
-                                         const  TObj_DeletingMode theMode)
+  const  TObj_DeletingMode theMode)
 {
   Handle(TObj_Object) anObject;
-  if( GetObj(theLabel, anObject) )
+  if (GetObj(theLabel, anObject))
     return anObject->Detach(theMode);
   return Standard_True;
 }
@@ -575,32 +575,32 @@ Standard_Boolean TObj_Object::Detach(const TDF_Label& theLabel,
 //=======================================================================
 
 Standard_Boolean TObj_Object::GetObj(const TDF_Label& theLabel,
-                                         Handle(TObj_Object)& theResult,
-                                         const Standard_Boolean isSuper)
+  Handle(TObj_Object)& theResult,
+  const Standard_Boolean isSuper)
 {
-  if(theLabel.IsNull())
+  if (theLabel.IsNull())
     return Standard_False;
 
   Handle(TObj_TObject) A;
 
   // find on the current label
-  if ( theLabel.FindAttribute(TObj_TObject::GetID(), A) )
+  if (theLabel.FindAttribute(TObj_TObject::GetID(), A))
     theResult = A->Get();
   else
     theResult.Nullify();
 
-  if( !theResult.IsNull() )
+  if (!theResult.IsNull())
   {
-    if( !theResult->myLabel.IsNull() )
+    if (!theResult->myLabel.IsNull())
       return Standard_True;
 
     // if the object is not allive then it is a wrong data in the Data Model
     theResult.Nullify();
   }
-  else if( isSuper )
+  else if (isSuper)
   {
     // try to get object from the father label
-    return GetObj(theLabel.Father(),theResult,isSuper);
+    return GetObj(theLabel.Father(), theResult, isSuper);
   }
 
   return Standard_False;
@@ -613,13 +613,13 @@ Standard_Boolean TObj_Object::GetObj(const TDF_Label& theLabel,
 //=======================================================================
 
 Handle(TObj_Object) TObj_Object::GetFatherObject
-                         (const Handle(Standard_Type)& theType) const
+(const Handle(Standard_Type)& theType) const
 {
   Handle(TObj_Object) aFather, aSon(this);
 
-  while ( aSon->GetObj( aSon->GetLabel().Father(), aFather, Standard_True ) )
+  while (aSon->GetObj(aSon->GetLabel().Father(), aFather, Standard_True))
   {
-    if (theType.IsNull() || aFather->IsKind( theType ))
+    if (theType.IsNull() || aFather->IsKind(theType))
       break;
     else
     {
@@ -641,8 +641,8 @@ void TObj_Object::AfterRetrieval()
 {
   // Register the name
   Handle(TObj_Model) aModel = GetModel();
-  if ( !aModel.IsNull() )
-    aModel->RegisterName( GetName(), GetLabel(), GetDictionary() );
+  if (!aModel.IsNull())
+    aModel->RegisterName(GetName(), GetLabel(), GetDictionary());
 }
 
 //=======================================================================
@@ -662,9 +662,9 @@ void TObj_Object::BeforeStoring()
 TDF_Label TObj_Object::GetReferenceLabel() const
 {
 #ifdef DFBROWSE
-  return getLabelByRank(GetLabel(),1,"References");
+  return getLabelByRank(GetLabel(), 1, "References");
 #else
-  return GetLabel().FindChild ( 1, Standard_True );
+  return GetLabel().FindChild (1, Standard_True);
 #endif
 }
 
@@ -676,9 +676,9 @@ TDF_Label TObj_Object::GetReferenceLabel() const
 TDF_Label TObj_Object::GetDataLabel() const
 {
 #ifdef DFBROWSE
-  return getLabelByRank(GetLabel(),3,"Data");
+  return getLabelByRank(GetLabel(), 3, "Data");
 #else
-  return GetLabel().FindChild ( 3, Standard_True );
+  return GetLabel().FindChild (3, Standard_True);
 #endif
 }
 
@@ -688,14 +688,14 @@ TDF_Label TObj_Object::GetDataLabel() const
 //=======================================================================
 
 TDF_Label TObj_Object::getDataLabel (const Standard_Integer theRank1,
-                                         const Standard_Integer theRank2) const
+  const Standard_Integer theRank2) const
 {
   TDF_Label aLabel;
-  if ( theRank1 > 0 ) // protection
+  if (theRank1 > 0) // protection
   {
-    aLabel = GetDataLabel().FindChild ( theRank1, Standard_True );
-    if ( theRank2 > 0 )
-      aLabel = aLabel.FindChild ( theRank2, Standard_True );
+    aLabel = GetDataLabel().FindChild (theRank1, Standard_True);
+    if (theRank2 > 0)
+      aLabel = aLabel.FindChild (theRank2, Standard_True);
   }
   return aLabel;
 }
@@ -706,14 +706,14 @@ TDF_Label TObj_Object::getDataLabel (const Standard_Integer theRank1,
 //=======================================================================
 
 TDF_Label TObj_Object::getReferenceLabel (const Standard_Integer theRank1,
-                                              const Standard_Integer theRank2) const
+  const Standard_Integer theRank2) const
 {
   TDF_Label aLabel;
-  if ( theRank1 > 0 ) // protection
+  if (theRank1 > 0) // protection
   {
-    aLabel = GetReferenceLabel().FindChild ( theRank1, Standard_True );
-    if ( theRank2 > 0 )
-      aLabel = aLabel.FindChild ( theRank2, Standard_True );
+    aLabel = GetReferenceLabel().FindChild (theRank1, Standard_True);
+    if (theRank2 > 0)
+      aLabel = aLabel.FindChild (theRank2, Standard_True);
   }
   return aLabel;
 }
@@ -728,11 +728,11 @@ TDF_Label TObj_Object::getReferenceLabel (const Standard_Integer theRank1,
 //=======================================================================
 
 Standard_Boolean TObj_Object::isDataAttribute
-                        (const Standard_GUID&   theGUID,
-                         const Standard_Integer theRank1,
-                         const Standard_Integer theRank2) const
+(const Standard_GUID&   theGUID,
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  return getDataLabel(theRank1,theRank2).IsAttribute(theGUID);
+  return getDataLabel(theRank1, theRank2).IsAttribute(theGUID);
 }
 
 //=======================================================================
@@ -741,12 +741,12 @@ Standard_Boolean TObj_Object::isDataAttribute
 //=======================================================================
 
 Standard_Real TObj_Object::getReal (const Standard_Integer theRank1,
-                                        const Standard_Integer theRank2) const
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
 
   Handle(TDataStd_Real) aReal;
-  aLabel.FindAttribute ( TDataStd_Real::GetID(), aReal );
+  aLabel.FindAttribute (TDataStd_Real::GetID(), aReal);
   return aReal.IsNull() ? 0. : aReal->Get();
 }
 
@@ -756,18 +756,18 @@ Standard_Real TObj_Object::getReal (const Standard_Integer theRank1,
 //=======================================================================
 
 Standard_Boolean TObj_Object::setReal (const Standard_Real theValue,
-                                           const Standard_Integer theRank1,
-                                           const Standard_Integer theRank2,
-                                           const Standard_Real theTolerance) const
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2,
+  const Standard_Real theTolerance) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
 
   // check that value is actually changed
   Handle(TDataStd_Real) A;
-  if ( aLabel.FindAttribute(TDataStd_Real::GetID(), A) &&
-       fabs ( A->Get() - theValue ) <= theTolerance ) return Standard_False;
+  if (aLabel.FindAttribute(TDataStd_Real::GetID(), A) &&
+    fabs (A->Get() - theValue) <= theTolerance) return Standard_False;
 
-  TDataStd_Real::Set ( aLabel, theValue );
+  TDataStd_Real::Set (aLabel, theValue);
   return Standard_True;
 }
 
@@ -777,13 +777,13 @@ Standard_Boolean TObj_Object::setReal (const Standard_Real theValue,
 //=======================================================================
 
 Handle(TCollection_HExtendedString) TObj_Object::getExtString
-       (const Standard_Integer theRank1,
-        const Standard_Integer theRank2) const
+(const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
 
   Handle(TDataStd_Name) aName;
-  aLabel.FindAttribute ( TDataStd_Name::GetID(), aName );
+  aLabel.FindAttribute (TDataStd_Name::GetID(), aName);
   return aName.IsNull() ? 0 : new TCollection_HExtendedString(aName->Get());
 }
 
@@ -793,15 +793,15 @@ Handle(TCollection_HExtendedString) TObj_Object::getExtString
 //=======================================================================
 
 void TObj_Object::setExtString
-  (const Handle(TCollection_HExtendedString)& theValue,
-   const Standard_Integer theRank1,
-   const Standard_Integer theRank2) const
+(const Handle(TCollection_HExtendedString)& theValue,
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
-  if ( !theValue.IsNull() )
-    TDataStd_Name::Set ( aLabel, theValue->String() );
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
+  if (!theValue.IsNull())
+    TDataStd_Name::Set (aLabel, theValue->String());
   else
-    aLabel.ForgetAttribute( TDataStd_Name::GetID() );
+    aLabel.ForgetAttribute(TDataStd_Name::GetID());
 }
 
 //=======================================================================
@@ -810,14 +810,14 @@ void TObj_Object::setExtString
 //=======================================================================
 
 Handle(TCollection_HAsciiString) TObj_Object::getAsciiString
-       (const Standard_Integer theRank1,
-        const Standard_Integer theRank2) const
+(const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
 
   Handle(TDataStd_AsciiString) aStrAttr;
-  aLabel.FindAttribute ( TDataStd_AsciiString::GetID(), aStrAttr );
-  return aStrAttr.IsNull() ? 0 : new TCollection_HAsciiString( aStrAttr->Get() );
+  aLabel.FindAttribute (TDataStd_AsciiString::GetID(), aStrAttr);
+  return aStrAttr.IsNull() ? 0 : new TCollection_HAsciiString(aStrAttr->Get());
 }
 
 //=======================================================================
@@ -826,15 +826,15 @@ Handle(TCollection_HAsciiString) TObj_Object::getAsciiString
 //=======================================================================
 
 void TObj_Object::setAsciiString
-  (const Handle(TCollection_HAsciiString)& theValue,
-   const Standard_Integer theRank1,
-   const Standard_Integer theRank2) const
+(const Handle(TCollection_HAsciiString)& theValue,
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
-  if ( !theValue.IsNull() )
-    TDataStd_AsciiString::Set ( aLabel, theValue->String() );
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
+  if (!theValue.IsNull())
+    TDataStd_AsciiString::Set (aLabel, theValue->String());
   else
-    aLabel.ForgetAttribute( TDataStd_AsciiString::GetID() );
+    aLabel.ForgetAttribute(TDataStd_AsciiString::GetID());
 }
 
 //=======================================================================
@@ -843,12 +843,12 @@ void TObj_Object::setAsciiString
 //=======================================================================
 
 Standard_Integer TObj_Object::getInteger (const Standard_Integer theRank1,
-                                              const Standard_Integer theRank2) const
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
 
   Handle(TDataStd_Integer) aNum;
-  aLabel.FindAttribute ( TDataStd_Integer::GetID(), aNum );
+  aLabel.FindAttribute (TDataStd_Integer::GetID(), aNum);
   return aNum.IsNull() ? 0 : aNum->Get();
 }
 
@@ -858,17 +858,17 @@ Standard_Integer TObj_Object::getInteger (const Standard_Integer theRank1,
 //=======================================================================
 
 Standard_Boolean TObj_Object::setInteger (const Standard_Integer theValue,
-                                              const Standard_Integer theRank1,
-                                              const Standard_Integer theRank2) const
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
 
   // check that value is actually changed
   Handle(TDataStd_Integer) A;
-  if ( aLabel.FindAttribute(TDataStd_Integer::GetID(), A) &&
-       A->Get() == theValue ) return Standard_False;
+  if (aLabel.FindAttribute(TDataStd_Integer::GetID(), A) &&
+    A->Get() == theValue) return Standard_False;
 
-  TDataStd_Integer::Set ( aLabel, theValue );
+  TDataStd_Integer::Set (aLabel, theValue);
   return Standard_True;
 }
 
@@ -878,12 +878,12 @@ Standard_Boolean TObj_Object::setInteger (const Standard_Integer theValue,
 //=======================================================================
 
 Handle(TObj_Object) TObj_Object::getReference (const Standard_Integer theRank1,
-                                                       const Standard_Integer theRank2) const
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getReferenceLabel(theRank1,theRank2);
+  TDF_Label aLabel = getReferenceLabel(theRank1, theRank2);
 
   Handle(TObj_TReference) aRef;
-  aLabel.FindAttribute ( TObj_TReference::GetID(), aRef );
+  aLabel.FindAttribute (TObj_TReference::GetID(), aRef);
   return aRef.IsNull() ? Handle(TObj_Object)() : aRef->Get();
 }
 
@@ -893,24 +893,24 @@ Handle(TObj_Object) TObj_Object::getReference (const Standard_Integer theRank1,
 //=======================================================================
 
 Standard_Boolean TObj_Object::setReference (const Handle(TObj_Object) & theObject,
-                                                const Standard_Integer theRank1,
-                                                const Standard_Integer theRank2)
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2)
 {
-  TDF_Label aLabel = getReferenceLabel(theRank1,theRank2);
+  TDF_Label aLabel = getReferenceLabel(theRank1, theRank2);
+
+  if (theObject.IsNull())
+    return aLabel.ForgetAttribute (TObj_TReference::GetID());
 
-  if ( theObject.IsNull() )
-    return aLabel.ForgetAttribute ( TObj_TReference::GetID() );
-  
   // check that reference is actually changed
   Handle(TObj_TReference) A;
-  if ( aLabel.FindAttribute(TObj_TReference::GetID(), A) &&
-       A->Get() == theObject ) return Standard_False;
+  if (aLabel.FindAttribute(TObj_TReference::GetID(), A) &&
+    A->Get() == theObject) return Standard_False;
 
   // 27.07.05, PTv: remove reference attribute before create new reference (for Undo/Redo)
-  aLabel.ForgetAttribute( TObj_TReference::GetID() );
+  aLabel.ForgetAttribute(TObj_TReference::GetID());
 
   Handle(TObj_Object) me = this;
-  TObj_TReference::Set ( aLabel, theObject, me);
+  TObj_TReference::Set (aLabel, theObject, me);
   return Standard_True;
 }
 
@@ -920,17 +920,17 @@ Standard_Boolean TObj_Object::setReference (const Handle(TObj_Object) & theObjec
 //=======================================================================
 
 TDF_Label TObj_Object::addReference (const Standard_Integer theRank1,
-                                         const Handle(TObj_Object) & theObject)
+  const Handle(TObj_Object) & theObject)
 {
   TDF_Label aRefLabel = GetReferenceLabel();
-  if ( theRank1 > 0 )
-    aRefLabel = aRefLabel.FindChild ( theRank1, Standard_True );
+  if (theRank1 > 0)
+    aRefLabel = aRefLabel.FindChild (theRank1, Standard_True);
 
   TDF_TagSource aTag;
   TDF_Label aLabel = aTag.NewChild(aRefLabel);
 
   Handle(TObj_Object) me = this;
-  TObj_TReference::Set ( aLabel, theObject, me);
+  TObj_TReference::Set (aLabel, theObject, me);
   return aLabel;
 }
 
@@ -946,21 +946,21 @@ TDF_Label TObj_Object::addReference (const Standard_Integer theRank1,
 //=======================================================================
 
 Handle(TColStd_HArray1OfReal) TObj_Object::getRealArray
-                        (const Standard_Integer theLength,
-                         const Standard_Integer theRank1,
-                         const Standard_Integer theRank2,
-                         const Standard_Real    theInitialValue) const
+(const Standard_Integer theLength,
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2,
+  const Standard_Real    theInitialValue) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
   Handle(TDataStd_RealArray) anArrAttribute;
   if (!aLabel.FindAttribute(TDataStd_RealArray::GetID(), anArrAttribute))
-    if ( theLength > 0 )
+    if (theLength > 0)
     {
       anArrAttribute = TDataStd_RealArray::Set (aLabel, 1, theLength);
-      anArrAttribute->Array()->Init( theInitialValue );
+      anArrAttribute->Array()->Init(theInitialValue);
     }
   Handle(TColStd_HArray1OfReal) anArr;
-  if ( !anArrAttribute.IsNull() )
+  if (!anArrAttribute.IsNull())
     anArr = anArrAttribute->Array();
   return anArr;
 }
@@ -977,21 +977,21 @@ Handle(TColStd_HArray1OfReal) TObj_Object::getRealArray
 //=======================================================================
 
 Handle(TColStd_HArray1OfInteger) TObj_Object::getIntegerArray
-                        (const Standard_Integer theLength,
-                         const Standard_Integer theRank1,
-                         const Standard_Integer theRank2,
-                         const Standard_Integer theInitialValue) const
+(const Standard_Integer theLength,
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2,
+  const Standard_Integer theInitialValue) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
   Handle(TDataStd_IntegerArray) anArrAttribute;
   if (!aLabel.FindAttribute(TDataStd_IntegerArray::GetID(), anArrAttribute))
-    if ( theLength > 0 )
+    if (theLength > 0)
     {
       anArrAttribute = TDataStd_IntegerArray::Set (aLabel, 1, theLength);
-      anArrAttribute->Array()->Init( theInitialValue );
+      anArrAttribute->Array()->Init(theInitialValue);
     }
   Handle(TColStd_HArray1OfInteger) anArr;
-  if ( !anArrAttribute.IsNull() )
+  if (!anArrAttribute.IsNull())
     anArr = anArrAttribute->Array();
   return anArr;
 }
@@ -1008,18 +1008,18 @@ Handle(TColStd_HArray1OfInteger) TObj_Object::getIntegerArray
 //=======================================================================
 
 Handle(TColStd_HArray1OfExtendedString) TObj_Object::getExtStringArray
-                        (const Standard_Integer theLength,
-                         const Standard_Integer theRank1,
-                         const Standard_Integer theRank2) const
+(const Standard_Integer theLength,
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2) const
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
   Handle(TDataStd_ExtStringArray) anArrAttribute;
   if (!aLabel.FindAttribute(TDataStd_ExtStringArray::GetID(), anArrAttribute))
-    if ( theLength > 0 )
+    if (theLength > 0)
       anArrAttribute = TDataStd_ExtStringArray::Set (aLabel, 1, theLength);
 
   Handle(TColStd_HArray1OfExtendedString) anArr;
-  if ( !anArrAttribute.IsNull() )
+  if (!anArrAttribute.IsNull())
     anArr = anArrAttribute->Array();
   return anArr;
 }
@@ -1032,13 +1032,13 @@ Handle(TColStd_HArray1OfExtendedString) TObj_Object::getExtStringArray
 //=======================================================================
 
 void TObj_Object::setArray (const Handle(TColStd_HArray1OfReal)& theArray,
-                                const Standard_Integer theRank1,
-                                const Standard_Integer theRank2)
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2)
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
   Handle(TDataStd_RealArray) anArrAttribute;
   if (!aLabel.FindAttribute(TDataStd_RealArray::GetID(), anArrAttribute) &&
-      !theArray.IsNull())
+    !theArray.IsNull())
     anArrAttribute = TDataStd_RealArray::Set (aLabel, 1, 1);
 
   if (theArray.IsNull()) {
@@ -1050,9 +1050,9 @@ void TObj_Object::setArray (const Handle(TColStd_HArray1OfReal)& theArray,
 
   if (anArrAttribute->Array() == theArray)
     // Backup wont happen but we want it
-    anArrAttribute->Init(1,1);
+    anArrAttribute->Init(1, 1);
 
-  anArrAttribute->ChangeArray( theArray );
+  anArrAttribute->ChangeArray(theArray);
 }
 
 //=======================================================================
@@ -1063,13 +1063,13 @@ void TObj_Object::setArray (const Handle(TColStd_HArray1OfReal)& theArray,
 //=======================================================================
 
 void TObj_Object::setArray (const Handle(TColStd_HArray1OfInteger)& theArray,
-                                const Standard_Integer theRank1,
-                                const Standard_Integer theRank2)
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2)
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
   Handle(TDataStd_IntegerArray) anArrAttribute;
   if (!aLabel.FindAttribute(TDataStd_IntegerArray::GetID(), anArrAttribute) &&
-      !theArray.IsNull())
+    !theArray.IsNull())
     anArrAttribute = TDataStd_IntegerArray::Set (aLabel, 1, 1);
 
   if (theArray.IsNull()) {
@@ -1081,9 +1081,9 @@ void TObj_Object::setArray (const Handle(TColStd_HArray1OfInteger)& theArray,
 
   if (anArrAttribute->Array() == theArray)
     // Backup wont happen but we want it
-    anArrAttribute->Init(1,1);
+    anArrAttribute->Init(1, 1);
 
-  anArrAttribute->ChangeArray( theArray );
+  anArrAttribute->ChangeArray(theArray);
 }
 
 //=======================================================================
@@ -1094,13 +1094,13 @@ void TObj_Object::setArray (const Handle(TColStd_HArray1OfInteger)& theArray,
 //=======================================================================
 
 void TObj_Object::setArray (const Handle(TColStd_HArray1OfExtendedString)& theArray,
-                                const Standard_Integer theRank1,
-                                const Standard_Integer theRank2)
+  const Standard_Integer theRank1,
+  const Standard_Integer theRank2)
 {
-  TDF_Label aLabel = getDataLabel(theRank1,theRank2);
+  TDF_Label aLabel = getDataLabel(theRank1, theRank2);
   Handle(TDataStd_ExtStringArray) anArrAttribute;
   if (!aLabel.FindAttribute(TDataStd_ExtStringArray::GetID(), anArrAttribute) &&
-      !theArray.IsNull())
+    !theArray.IsNull())
     anArrAttribute = TDataStd_ExtStringArray::Set (aLabel, 1, 1);
 
   if (theArray.IsNull()) {
@@ -1112,9 +1112,9 @@ void TObj_Object::setArray (const Handle(TColStd_HArray1OfExtendedString)& theAr
 
   if (anArrAttribute->Array() == theArray)
     // Backup wont happen but we want it
-    anArrAttribute->Init(1,1);
+    anArrAttribute->Init(1, 1);
 
-  anArrAttribute->ChangeArray( theArray );
+  anArrAttribute->ChangeArray(theArray);
 }
 
 //=======================================================================
@@ -1126,7 +1126,7 @@ static void copyTagSources (const TDF_Label& theSourceLabel, const TDF_Label& th
 {
   // copy tag source on current label
   Handle(TDF_Attribute) anAttr;
-  if(theSourceLabel.FindAttribute(TDF_TagSource::GetID(), anAttr))
+  if (theSourceLabel.FindAttribute(TDF_TagSource::GetID(), anAttr))
   {
     Handle(TDF_TagSource) aTagSource = Handle(TDF_TagSource)::DownCast(anAttr);
     Handle(TDF_TagSource) aTargetTagSource = TDF_TagSource::Set(theTargetLabel);
@@ -1136,7 +1136,7 @@ static void copyTagSources (const TDF_Label& theSourceLabel, const TDF_Label& th
   // copy recursively to sub-labels; note that iteration is made by target label,
   // to avoid copying tag sources where data are not copied
   TDF_ChildIterator aLI(theTargetLabel);
-  for(; aLI.More(); aLI.Next())
+  for (; aLI.More(); aLI.Next())
   {
     TDF_Label aSourceLabel = theSourceLabel.FindChild(aLI.Value().Tag(), Standard_False);
     if (! aSourceLabel.IsNull())
@@ -1150,8 +1150,8 @@ static void copyTagSources (const TDF_Label& theSourceLabel, const TDF_Label& th
 //=======================================================================
 
 Handle(TObj_Object) TObj_Object::Clone
-       (const TDF_Label&            theTargetLabel,
-        Handle(TDF_RelocationTable) theRelocTable)
+(const TDF_Label&            theTargetLabel,
+  Handle(TDF_RelocationTable) theRelocTable)
 {
   Handle(TDF_RelocationTable) aRelocTable = theRelocTable;
   if (theRelocTable.IsNull())
@@ -1174,15 +1174,15 @@ Handle(TObj_Object) TObj_Object::Clone
 
   if (!aNewObj.IsNull())
   {
-    TObj_TObject::Set(theTargetLabel,aNewObj);
+    TObj_TObject::Set(theTargetLabel, aNewObj);
 
     // adding a record to the reloation table
     aRelocTable->SetRelocation(GetLabel(), theTargetLabel);
 
     // now set name of object.
-    const Handle(TCollection_HExtendedString) aCloneName = GetNameForClone( aNewObj );
-    if( !aCloneName.IsNull() && !aCloneName->IsEmpty() )
-      aNewObj->SetName( new TCollection_HExtendedString( aCloneName ) );
+    const Handle(TCollection_HExtendedString) aCloneName = GetNameForClone(aNewObj);
+    if (!aCloneName.IsNull() && !aCloneName->IsEmpty())
+      aNewObj->SetName(new TCollection_HExtendedString(aCloneName));
 
     // copy the data
     copyData (aNewObj);
@@ -1195,7 +1195,7 @@ Handle(TObj_Object) TObj_Object::Clone
     copyTagSources (GetChildLabel(), aTargetLabel);
 
     // copy the references
-    if(theRelocTable.IsNull())
+    if (theRelocTable.IsNull())
       CopyReferences(aNewObj, aRelocTable);
   }
 
@@ -1212,10 +1212,10 @@ Handle(TObj_Object) TObj_Object::Clone
 //=======================================================================
 
 Standard_Boolean TObj_Object::copyData
-                (const Handle(TObj_Object)& theTargetObject)
+(const Handle(TObj_Object)& theTargetObject)
 {
   Standard_Boolean IsDone = Standard_False;
-  if ( !theTargetObject->DynamicType()->SubType( DynamicType() ) )
+  if (!theTargetObject->DynamicType()->SubType(DynamicType()))
     return IsDone;
   // init the copier by labels.
   TDF_Label aDataLabel = GetDataLabel();
@@ -1236,28 +1236,28 @@ Standard_Boolean TObj_Object::copyData
 //=======================================================================
 
 void TObj_Object::CopyChildren
-                (TDF_Label&                         theTargetLabel,
-                 const Handle(TDF_RelocationTable)& theRelocTable)
+(TDF_Label&                         theTargetLabel,
+  const Handle(TDF_RelocationTable)& theRelocTable)
 {
   TDF_Label aSourceChildLabel = GetChildLabel();
   Handle(TObj_ObjectIterator) aChildren = // GetChildren();
     new TObj_OcafObjectIterator (aSourceChildLabel, NULL, Standard_True); // to support children on sublabels of child label
-  for(;aChildren->More(); aChildren->Next())
+  for (;aChildren->More(); aChildren->Next())
   {
     Handle(TObj_Object) aChild = aChildren->Value();
-    if(!aChild.IsNull())
+    if (!aChild.IsNull())
     {
       // to support childs on sublabels of sublabel of child label
       TColStd_SequenceOfInteger aTags;
       TDF_Label aCurChildLab = aChild->GetLabel();
-      while ( !aCurChildLab.IsNull() && aCurChildLab != aSourceChildLabel )
+      while (!aCurChildLab.IsNull() && aCurChildLab != aSourceChildLabel)
       {
-        aTags.Append( aCurChildLab.Tag() );
+        aTags.Append(aCurChildLab.Tag());
         aCurChildLab = aCurChildLab.Father();
       }
       TDF_Label aChildLabel = theTargetLabel;
-      for ( Standard_Integer i = aTags.Length(); i > 0 ; i-- )
-        aChildLabel = aChildLabel.FindChild( aTags.Value( i ), Standard_True );
+      for (Standard_Integer i = aTags.Length(); i > 0 ; i--)
+        aChildLabel = aChildLabel.FindChild(aTags.Value(i), Standard_True);
 
       aChild->Clone(aChildLabel, theRelocTable);
     }
@@ -1270,24 +1270,24 @@ void TObj_Object::CopyChildren
 //=======================================================================
 
 void TObj_Object::CopyReferences
-                (const Handle(TObj_Object)& theTargetObject,
-                 const Handle(TDF_RelocationTable)& theRelocTable)
+(const Handle(TObj_Object)& theTargetObject,
+  const Handle(TDF_RelocationTable)& theRelocTable)
 {
   // recursive copy of references
   Handle(TObj_ObjectIterator) aSrcChildren = //GetChildren();
   // to support childs on sublabels of sublabel of child label
-   new TObj_OcafObjectIterator(GetChildLabel(), NULL, Standard_True);
-  for(; aSrcChildren->More(); aSrcChildren->Next())
+    new TObj_OcafObjectIterator(GetChildLabel(), NULL, Standard_True);
+  for (; aSrcChildren->More(); aSrcChildren->Next())
   {
     Handle(TObj_Object) aSrcChild = aSrcChildren->Value();
     TDF_Label aSrcL = aSrcChild->GetLabel();
     TDF_Label aDestLabel;
-    if( !theRelocTable->HasRelocation(aSrcL, aDestLabel) )
+    if (!theRelocTable->HasRelocation(aSrcL, aDestLabel))
       continue;
     Handle(TObj_Object) aDstChild;
-    if ( !TObj_Object::GetObj( aDestLabel, aDstChild ) )
+    if (!TObj_Object::GetObj(aDestLabel, aDstChild))
       continue;
-    if ( aDstChild.IsNull() || !aDstChild->IsAlive() || aSrcChild->DynamicType() != aDstChild->DynamicType() )
+    if (aDstChild.IsNull() || !aDstChild->IsAlive() || aSrcChild->DynamicType() != aDstChild->DynamicType())
       continue; // should not be with relocation table
 
     aSrcChild->CopyReferences(aDstChild, theRelocTable);
@@ -1305,12 +1305,12 @@ void TObj_Object::CopyReferences
 //=======================================================================
 
 void TObj_Object::copyReferences
-                         (const TDF_Label&                   theSourceLabel,
-                          TDF_Label&                         theTargetLabel,
-                          const Handle(TDF_RelocationTable)& theRelocTable)
+(const TDF_Label&                   theSourceLabel,
+  TDF_Label&                         theTargetLabel,
+  const Handle(TDF_RelocationTable)& theRelocTable)
 {
   TDF_AttributeIterator anIter(theSourceLabel);
-  for(; anIter.More(); anIter.Next())
+  for (; anIter.More(); anIter.Next())
   {
     Handle(TDF_Attribute) anAttr = anIter.Value()->NewEmpty();
     theTargetLabel.AddAttribute(anAttr);
@@ -1319,7 +1319,7 @@ void TObj_Object::copyReferences
   }
   TDF_ChildIterator aLI(theSourceLabel);
   TDF_Label aTargetLabel;
-  for(; aLI.More(); aLI.Next())
+  for (; aLI.More(); aLI.Next())
   {
     aTargetLabel = theTargetLabel.FindChild(aLI.Value().Tag(), Standard_True);
     copyReferences(aLI.Value(), aTargetLabel, theRelocTable);
@@ -1332,14 +1332,14 @@ void TObj_Object::copyReferences
 //=======================================================================
 
 void TObj_Object::ReplaceReference (const Handle(TObj_Object)& theOldObject,
-                                        const Handle(TObj_Object)& theNewObject)
+  const Handle(TObj_Object)& theNewObject)
 {
   Handle(TObj_LabelIterator) anItr =
-    Handle(TObj_LabelIterator)::DownCast( GetReferences() );
+    Handle(TObj_LabelIterator)::DownCast(GetReferences());
   if (anItr.IsNull())
     return;
   // iterates on references.
-  for (; anItr->More(); anItr->Next() )
+  for (; anItr->More(); anItr->Next())
   {
     Handle(TObj_Object) anObj = anItr->Value();
     if (anObj != theOldObject)
@@ -1354,7 +1354,7 @@ void TObj_Object::ReplaceReference (const Handle(TObj_Object)& theOldObject,
     }
     // set reference to new object.
     Handle(TObj_Object) me = this;
-    TObj_TReference::Set ( aRefLabel, theNewObject, me);
+    TObj_TReference::Set (aRefLabel, theNewObject, me);
     break;
   }
 }
@@ -1370,7 +1370,7 @@ Standard_Boolean TObj_Object::IsAlive() const
     return Standard_False;
 
   Handle(TObj_Object) anObj;
-  if ( !GetObj( myLabel, anObj ) )
+  if (!GetObj(myLabel, anObj))
     return Standard_False;
 
   return Standard_True;
@@ -1431,9 +1431,9 @@ Standard_Boolean TObj_Object::RemoveBackReferences(const TObj_DeletingMode theMo
   Handle(TObj_ObjectIterator) aRefs = GetBackReferences();
 
   // Free Object can be deleted in any Mode
-  if ( aRefs.IsNull() || !aRefs->More()) return Standard_True;
+  if (aRefs.IsNull() || !aRefs->More()) return Standard_True;
 
-  if( theMode == TObj_FreeOnly) return Standard_False;
+  if (theMode == TObj_FreeOnly) return Standard_False;
 
   // Defining the sequence of objects which are referenced to this one. The
   // first sequence stores containers the second one object with strong
@@ -1443,18 +1443,18 @@ Standard_Boolean TObj_Object::RemoveBackReferences(const TObj_DeletingMode theMo
   Handle(TObj_Object) aMe = this;
 
   // Sorting the referencing objects
-  for( ; aRefs->More() ; aRefs->Next())
+  for (; aRefs->More() ; aRefs->Next())
   {
     Handle(TObj_Object) anObject = aRefs->Value();
-    if ( anObject.IsNull() || !anObject->IsAlive() )
+    if (anObject.IsNull() || !anObject->IsAlive())
       continue;
-    if ( anObject->CanRemoveReference(aMe) )
+    if (anObject->CanRemoveReference(aMe))
       aContainers.Append(anObject);
     else
       aStrongs.Append(anObject);
   }
   // Can not be removed without deletion of referenced objects mode
-  if( theMode == TObj_KeepDepending && aStrongs.Length() > 0 )
+  if (theMode == TObj_KeepDepending && aStrongs.Length() > 0)
     return Standard_False;
   // Delete or link off the referencing objects
   Standard_Integer i;
@@ -1462,15 +1462,15 @@ Standard_Boolean TObj_Object::RemoveBackReferences(const TObj_DeletingMode theMo
   for (i = 1; i <= aContainers.Length(); i++)
   {
     Handle(TObj_Object) anObj = aContainers(i);
-    if ( anObj.IsNull() || anObj->GetLabel().IsNull() )
+    if (anObj.IsNull() || anObj->GetLabel().IsNull())
       continue; // undead object on dead label
     Handle(TDF_Data) aData = anObj->GetLabel().Data();
     Standard_Boolean aModifMode = aData->IsModificationAllowed();
-    if ( anOwnData != aData )
-      aData->AllowModification( Standard_True );
+    if (anOwnData != aData)
+      aData->AllowModification(Standard_True);
     anObj->RemoveReference(aMe);
-    if ( anOwnData != aData )
-      aData->AllowModification( aModifMode );
+    if (anOwnData != aData)
+      aData->AllowModification(aModifMode);
   }
   /* PTv 21.11.2006
   object from other document refers to current object and must be killed
@@ -1481,15 +1481,15 @@ Standard_Boolean TObj_Object::RemoveBackReferences(const TObj_DeletingMode theMo
   for (i = 1; i <= aStrongs.Length(); i++)
   {
     Handle(TObj_Object) anObj = aStrongs(i);
-    if ( anObj.IsNull() || anObj->GetLabel().IsNull() )
+    if (anObj.IsNull() || anObj->GetLabel().IsNull())
       continue; // undead object on dead label
     Handle(TDF_Data) aData = anObj->GetLabel().Data();
     Standard_Boolean aModifMode = aData->IsModificationAllowed();
-    if ( anOwnData != aData )
-      aData->AllowModification( Standard_True );
+    if (anOwnData != aData)
+      aData->AllowModification(Standard_True);
     anObj->Detach(theMode);
-    if ( anOwnData != aData )
-      aData->AllowModification( aModifMode );
+    if (anOwnData != aData)
+      aData->AllowModification(aModifMode);
   }
 
   return Standard_True;
@@ -1509,26 +1509,26 @@ Standard_Boolean TObj_Object::RemoveBackReferences(const TObj_DeletingMode theMo
 //=======================================================================
 
 Standard_Boolean TObj_Object::RelocateReferences
-                         (const TDF_Label&       theFromRoot,
-                          const TDF_Label&       theToRoot,
-                          const Standard_Boolean theUpdateBackRefs)
+(const TDF_Label&       theFromRoot,
+  const TDF_Label&       theToRoot,
+  const Standard_Boolean theUpdateBackRefs)
 {
   TDF_ChildIDIterator aRefIt (GetReferenceLabel(),
-                              TObj_TReference::GetID(),
-                              Standard_True );
+    TObj_TReference::GetID(),
+    Standard_True);
   Handle(TObj_Object) anObj;
-  for (  ; aRefIt.More(); aRefIt.Next() )
+  for (; aRefIt.More(); aRefIt.Next())
   {
     Handle(TObj_TReference) aRef =
-      Handle(TObj_TReference)::DownCast( aRefIt.Value() );
+      Handle(TObj_TReference)::DownCast(aRefIt.Value());
 
     TDF_Label aNewLabel, aLabel = aRef->GetLabel();
-    if ( aLabel.Data() != theFromRoot.Data() ||
-         aLabel.IsDescendant( theToRoot ))
+    if (aLabel.Data() != theFromRoot.Data() ||
+      aLabel.IsDescendant(theToRoot))
       continue; // need not to relocate
 
-    TDF_Tool::RelocateLabel( aLabel, theFromRoot, theToRoot, aNewLabel );
-    if ( aNewLabel.IsNull() || !TObj_Object::GetObj( aNewLabel, anObj ))
+    TDF_Tool::RelocateLabel(aLabel, theFromRoot, theToRoot, aNewLabel);
+    if (aNewLabel.IsNull() || !TObj_Object::GetObj(aNewLabel, anObj))
       return Standard_False;
 
     // care of back references
@@ -1536,14 +1536,14 @@ Standard_Boolean TObj_Object::RelocateReferences
     {
       Handle(TObj_Object) me = this;
       // a new referred object
-      anObj->AddBackReference( me );
+      anObj->AddBackReference(me);
       // an old object
       anObj = aRef->Get();
       if (!anObj.IsNull())
-        anObj->RemoveBackReference( me );
+        anObj->RemoveBackReference(me);
     }
 
-    aRef->Set( aNewLabel, aRef->GetMasterLabel() );
+    aRef->Set(aNewLabel, aRef->GetMasterLabel());
   }
 
   return Standard_True;
@@ -1555,21 +1555,21 @@ Standard_Boolean TObj_Object::RelocateReferences
 //=======================================================================
 
 Standard_Boolean TObj_Object::GetBadReference
-                         (const TDF_Label& theRoot,
-                          TDF_Label&       theBadReference) const
+(const TDF_Label& theRoot,
+  TDF_Label&       theBadReference) const
 {
   TDF_ChildIDIterator aRefIt (GetReferenceLabel(),
-                              TObj_TReference::GetID(),
-                              Standard_True );
+    TObj_TReference::GetID(),
+    Standard_True);
   Handle(TObj_Object) anObj;
-  for (  ; aRefIt.More(); aRefIt.Next() )
+  for (; aRefIt.More(); aRefIt.Next())
   {
     Handle(TObj_TReference) aRef =
-      Handle(TObj_TReference)::DownCast( aRefIt.Value() );
+      Handle(TObj_TReference)::DownCast(aRefIt.Value());
 
     TDF_Label aLabel = aRef->GetLabel();
-    if ( aLabel.Data() == theRoot.Data() &&
-         !aLabel.IsDescendant( theRoot ))
+    if (aLabel.Data() == theRoot.Data() &&
+      !aLabel.IsDescendant(theRoot))
     {
       theBadReference = aLabel;
       return Standard_True;
@@ -1597,9 +1597,9 @@ Standard_Integer TObj_Object::GetTypeFlags() const
 Handle(TObj_TNameContainer) TObj_Object::GetDictionary() const
 {
   Handle(TObj_Model) aModel = GetModel();
-  if ( !aModel.IsNull() )
+  if (!aModel.IsNull())
     return aModel->GetDictionary();
-  return NULL; 
+  return NULL;
 }
 
 //=======================================================================
@@ -1607,9 +1607,9 @@ Handle(TObj_TNameContainer) TObj_Object::GetDictionary() const
 //purpose  :
 //=======================================================================
 
-Standard_Boolean TObj_Object::SetOrder( const Standard_Integer& theIndx )
-{ 
-  setInteger( theIndx, DataTag_Order );
+Standard_Boolean TObj_Object::SetOrder(const Standard_Integer& theIndx)
+{
+  setInteger(theIndx, DataTag_Order);
   return Standard_True;
 }
 
@@ -1620,8 +1620,18 @@ Standard_Boolean TObj_Object::SetOrder( const Standard_Integer& theIndx )
 
 Standard_Integer TObj_Object::GetOrder() const
 {
-  Standard_Integer order = getInteger( DataTag_Order );
-  if ( !order )
+  Standard_Integer order = getInteger(DataTag_Order);
+  if (!order)
     order = GetLabel().Tag();
   return order;
 }
+
+//=======================================================================
+//function : HasModifications
+//purpose  :
+//=======================================================================
+
+Standard_Boolean TObj_Object::HasModifications() const
+{
+  return (!IsAlive() ? Standard_False : GetLabel().Data()->HasModifications(GetLabel()));
+}
\ No newline at end of file

diff --git a/src/TObj/TObj_Object.hxx b/src/TObj/TObj_Object.hxx
index 8afecf0a46902236b7622866d2ad34c52e491016..a02231cbf5653c114eb06c5492285f63b5c12f0f 100644 (file)
--- a/src/TObj/TObj_Object.hxx
+++ b/src/TObj/TObj_Object.hxx
@@ -365,6 +365,14 @@ class TObj_Object : public Standard_Transient
    //! sets order of object
    virtual Standard_EXPORT Standard_Boolean SetOrder( const Standard_Integer& theIndx );
 
+   public:
+  /**
+  * Public methods to check modifications of the object since last commit
+  */
+  //
+  Standard_EXPORT Standard_Boolean HasModifications() const;
+ 
+
  protected:
   /**
   * Protected Methods copy data of object to other object