Added the system of reinitialization of attributes instead of re-creation of them...

diff --git a/src/GeomData/GeomData_Dir.cpp b/src/GeomData/GeomData_Dir.cpp
index d5272dda21f432786c2ca04ff8e983b99a7a5108..477a89c2079691ee5196b6a9142306fa3e814f96 100644 (file)
--- a/src/GeomData/GeomData_Dir.cpp
+++ b/src/GeomData/GeomData_Dir.cpp
@@ -58,9 +58,15 @@ std::shared_ptr<GeomAPI_XYZ> GeomData_Dir::xyz()
 
 GeomData_Dir::GeomData_Dir(TDF_Label& theLabel)
 {
-  myIsInitialized = theLabel.FindAttribute(TDataStd_RealArray::GetID(), myCoords) == Standard_True;
+  myLab = theLabel;
+  reinit();
+}
+
+void GeomData_Dir::reinit()
+{
+  myIsInitialized = myLab.FindAttribute(TDataStd_RealArray::GetID(), myCoords) == Standard_True;
   if (!myIsInitialized) {
     // create attribute: not initialized by value yet, just zero
-    myCoords = TDataStd_RealArray::Set(theLabel, 0, 2);
+    myCoords = TDataStd_RealArray::Set(myLab, 0, 2);
   }
 }

diff --git a/src/GeomData/GeomData_Dir.h b/src/GeomData/GeomData_Dir.h
index debd400552702b68455955f17d775b3f6f97d8ae..846dcd343f32d4089a64dd0a289d6941de701cf2 100644 (file)
--- a/src/GeomData/GeomData_Dir.h
+++ b/src/GeomData/GeomData_Dir.h
@@ -22,6 +22,7 @@ class GeomAPI_XYZ;
  */
 class GeomData_Dir : public GeomDataAPI_Dir
 {
+  TDF_Label myLab; ///< the main label of the attribute
   Handle_TDataStd_RealArray myCoords;  ///< X, Y and Z doubles as real array attribute [0; 2]
  public:
   /// Defines the double value
@@ -43,6 +44,8 @@ class GeomData_Dir : public GeomDataAPI_Dir
  protected:
   /// Initializes attributes
   GEOMDATA_EXPORT GeomData_Dir(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/GeomData/GeomData_Point.cpp b/src/GeomData/GeomData_Point.cpp
index f6becd98da1e7c418eecb0e0b61df4396371cb88..9ceced262ea3fa533b192dd00e79dee5471b0732 100644 (file)
--- a/src/GeomData/GeomData_Point.cpp
+++ b/src/GeomData/GeomData_Point.cpp
@@ -20,6 +20,15 @@ GeomData_Point::GeomData_Point()
   myIsInitialized = false;
 }
 
+void GeomData_Point::reinit()
+{
+  myIsInitialized = true;
+  for (int aComponent = 0; aComponent < NUM_COMPONENTS; ++aComponent) {
+    myExpression[aComponent]->reinit();
+    myIsInitialized = myIsInitialized && myExpression[aComponent]->isInitialized();
+  }
+}
+
 void GeomData_Point::setCalculatedValue(const double theX, const double theY, const double theZ)
 {
   if (!myIsInitialized || x() != theX || y() != theY || z() != theZ) {

diff --git a/src/GeomData/GeomData_Point.h b/src/GeomData/GeomData_Point.h
index 3c08a706f641db6cbb10fd95d3eb8e0e7fe266f2..8936ffef82462bb4abdf1bac10f12fb502544f68 100644 (file)
--- a/src/GeomData/GeomData_Point.h
+++ b/src/GeomData/GeomData_Point.h
@@ -74,6 +74,8 @@ class GeomData_Point : public GeomDataAPI_Point
  protected:
   /// Initializes attributes
   GEOMDATA_EXPORT GeomData_Point();
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/GeomData/GeomData_Point2D.cpp b/src/GeomData/GeomData_Point2D.cpp
index 8b6116b63e51cf7fd7e019d5088cd291119c562b..7c9cb73e31de9b7c7f36962aa99145366aa62da5 100644 (file)
--- a/src/GeomData/GeomData_Point2D.cpp
+++ b/src/GeomData/GeomData_Point2D.cpp
@@ -20,6 +20,15 @@ GeomData_Point2D::GeomData_Point2D()
   myIsInitialized = false;
 }
 
+void GeomData_Point2D::reinit()
+{
+  myIsInitialized = true;
+  for (int aComponent = 0; aComponent < NUM_COMPONENTS; ++aComponent) {
+    myExpression[aComponent]->reinit();
+    myIsInitialized = myIsInitialized && myExpression[aComponent]->isInitialized();
+  }
+}
+
 void GeomData_Point2D::setCalculatedValue(const double theX, const double theY)
 {
   if (!myIsInitialized || x() != theX || y() != theY) {

diff --git a/src/GeomData/GeomData_Point2D.h b/src/GeomData/GeomData_Point2D.h
index d73b20207f24209ab97df5ab067ac21465f21cf4..017802d5f50c889fb6b93f1dfb59a84c6a200435 100644 (file)
--- a/src/GeomData/GeomData_Point2D.h
+++ b/src/GeomData/GeomData_Point2D.h
@@ -69,6 +69,8 @@ class GeomData_Point2D : public GeomDataAPI_Point2D
  protected:
   /// Initializes attributes
   GEOMDATA_EXPORT GeomData_Point2D();
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_AttributeBoolean.cpp b/src/Model/Model_AttributeBoolean.cpp
index f603def2d681f8ffbea1fa3b2cf146d286fce82c..d576a8870be398222cdac5052fae5879695467c9 100644 (file)
--- a/src/Model/Model_AttributeBoolean.cpp
+++ b/src/Model/Model_AttributeBoolean.cpp
@@ -29,6 +29,11 @@ bool Model_AttributeBoolean::value()
 Model_AttributeBoolean::Model_AttributeBoolean(TDF_Label& theLabel)
 {
   myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeBoolean::reinit()
+{
   // check the attribute could be already presented in this doc (after load document)
-  myIsInitialized = theLabel.FindAttribute(TDataStd_Integer::GetID(), myBool) == Standard_True;
+  myIsInitialized = myLab.FindAttribute(TDataStd_Integer::GetID(), myBool) == Standard_True;
 }

diff --git a/src/Model/Model_AttributeBoolean.h b/src/Model/Model_AttributeBoolean.h
index 1ad1f487e170854ef9f1bdf06a076294ceb8aeb4..e579649e9ce922c0a0f2d1f99e1b0cba877b71c7 100644 (file)
--- a/src/Model/Model_AttributeBoolean.h
+++ b/src/Model/Model_AttributeBoolean.h
@@ -32,6 +32,9 @@ class Model_AttributeBoolean : public ModelAPI_AttributeBoolean
   /// Initializes attibutes
   Model_AttributeBoolean(TDF_Label& theLabel);
 
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
+
   friend class Model_Data;
 };
 

diff --git a/src/Model/Model_AttributeDocRef.cpp b/src/Model/Model_AttributeDocRef.cpp
index 5c3eaf442de29aabcc5fd9f643be35d99bb02fdf..a2aef9d7d2c5f20327ac6b6bc536816269485eea 100644 (file)
--- a/src/Model/Model_AttributeDocRef.cpp
+++ b/src/Model/Model_AttributeDocRef.cpp
@@ -37,3 +37,8 @@ Model_AttributeDocRef::Model_AttributeDocRef(TDF_Label& theLabel)
     myID = TDataStd_Integer::Set(theLabel, aNewID);
   }
 }
+
+void Model_AttributeDocRef::reinit()
+{
+  // myLab is unknown, nevertheless, lose of attribute DocRef for live feature seems impossible
+}

diff --git a/src/Model/Model_AttributeDocRef.h b/src/Model/Model_AttributeDocRef.h
index 04eacc4372978ddebb19e8e1f2f78c2fb55e2709..d054fca8e86a50c7bcf7f117ed34740ee0824d91 100644 (file)
--- a/src/Model/Model_AttributeDocRef.h
+++ b/src/Model/Model_AttributeDocRef.h
@@ -35,6 +35,9 @@ class Model_AttributeDocRef : public ModelAPI_AttributeDocRef
   /// Initializes attibutes
   Model_AttributeDocRef(TDF_Label& theLabel);
 
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
+
   friend class Model_Data;
 };
 

diff --git a/src/Model/Model_AttributeDouble.cpp b/src/Model/Model_AttributeDouble.cpp
index 05a25684182f51e35e24930e769d481639b317f3..4efa7bedc3a244432963aa536f4e794ab4f5c01b 100644 (file)
--- a/src/Model/Model_AttributeDouble.cpp
+++ b/src/Model/Model_AttributeDouble.cpp
@@ -8,12 +8,20 @@
 
 #include <ModelAPI_Data.h>
 #include <ModelAPI_Events.h>
-#include <ModelAPI_Expression.h>
+#include <Model_Expression.h>
 #include <ModelAPI_Object.h>
 
-Model_AttributeDouble::Model_AttributeDouble()
+Model_AttributeDouble::Model_AttributeDouble(TDF_Label& theLabel)
 {
-  myIsInitialized = false;
+  TDF_Label anExpressionLab = theLabel.FindChild(1);
+  myExpression.reset(new Model_ExpressionDouble(anExpressionLab));
+  myIsInitialized = myExpression->isInitialized();
+}
+
+void Model_AttributeDouble::reinit()
+{
+  myExpression->reinit();
+  myIsInitialized = myExpression->isInitialized();
 }
 
 void Model_AttributeDouble::setCalculatedValue(const double theValue)

diff --git a/src/Model/Model_AttributeDouble.h b/src/Model/Model_AttributeDouble.h
index abf394aa611c84b59883de8932ef3eb86d9445c5..883b9b545c81c5d298cdb13c2e3c6c8223f86f73 100644 (file)
--- a/src/Model/Model_AttributeDouble.h
+++ b/src/Model/Model_AttributeDouble.h
@@ -59,7 +59,9 @@ class Model_AttributeDouble : public ModelAPI_AttributeDouble
 
  protected:
   /// Initializes attributes
-  Model_AttributeDouble();
+  Model_AttributeDouble(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_AttributeDoubleArray.cpp b/src/Model/Model_AttributeDoubleArray.cpp
index 3a6b2ad9f9f27a53e8175afe9fb4e81e7a327b86..fd1e4dfdc3455982f9e49ba7e67fdd4ab5af5a7f 100644 (file)
--- a/src/Model/Model_AttributeDoubleArray.cpp
+++ b/src/Model/Model_AttributeDoubleArray.cpp
@@ -71,6 +71,11 @@ double Model_AttributeDoubleArray::value(const int theIndex)
 Model_AttributeDoubleArray::Model_AttributeDoubleArray(TDF_Label& theLabel)
 {
   myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeDoubleArray::reinit()
+{
   // check the attribute could be already presented in this doc (after load document)
   myIsInitialized =
     myLab.FindAttribute(TDataStd_RealArray::GetID(), myArray) == Standard_True;

diff --git a/src/Model/Model_AttributeDoubleArray.h b/src/Model/Model_AttributeDoubleArray.h
index 74d960624f0df2b9c89d1984df428dbf7cad49e4..192d60629ecc82f0909064b84bcdfac679e2cfca 100644 (file)
--- a/src/Model/Model_AttributeDoubleArray.h
+++ b/src/Model/Model_AttributeDoubleArray.h
@@ -38,6 +38,8 @@ public:
 protected:
   /// Initializes attibutes
   Model_AttributeDoubleArray(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
 private:
   /// The OCCT array that keeps all values.

diff --git a/src/Model/Model_AttributeIntArray.cpp b/src/Model/Model_AttributeIntArray.cpp
index c01107332b47d371c7d6f7678bafd0c2aa7ca4a6..c05a9e19c32a108725d0175bfd922768da0ca161 100644 (file)
--- a/src/Model/Model_AttributeIntArray.cpp
+++ b/src/Model/Model_AttributeIntArray.cpp
@@ -71,6 +71,11 @@ int Model_AttributeIntArray::value(const int theIndex)
 Model_AttributeIntArray::Model_AttributeIntArray(TDF_Label& theLabel)
 {
   myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeIntArray::reinit()
+{
   // check the attribute could be already presented in this doc (after load document)
   myIsInitialized = 
     myLab.FindAttribute(TDataStd_IntegerArray::GetID(), myArray) == Standard_True;

diff --git a/src/Model/Model_AttributeIntArray.h b/src/Model/Model_AttributeIntArray.h
index 82808f53774ed8b360dc9a8bcb1f0f19bb5dfee2..190d3d5a6dd62463d232f59e62e24ae3a88dd714 100644 (file)
--- a/src/Model/Model_AttributeIntArray.h
+++ b/src/Model/Model_AttributeIntArray.h
@@ -47,6 +47,8 @@ class Model_AttributeIntArray : public ModelAPI_AttributeIntArray
  protected:
   /// Initializes attibutes
   Model_AttributeIntArray(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_AttributeInteger.cpp b/src/Model/Model_AttributeInteger.cpp
index 38ce002c5271c01206c0d66f80795047984de6a7..3f61cbd966561b8f2598c913ad3cb54e10d35589 100644 (file)
--- a/src/Model/Model_AttributeInteger.cpp
+++ b/src/Model/Model_AttributeInteger.cpp
@@ -8,12 +8,20 @@
 
 #include <ModelAPI_Data.h>
 #include <ModelAPI_Events.h>
-#include <ModelAPI_Expression.h>
+#include <Model_Expression.h>
 #include <ModelAPI_Object.h>
 
-Model_AttributeInteger::Model_AttributeInteger()
+Model_AttributeInteger::Model_AttributeInteger(TDF_Label& theLabel)
 {
-  myIsInitialized = false;
+  // to the same label to support the backward compatibility
+  myExpression.reset(new Model_ExpressionInteger(theLabel));
+  myIsInitialized = myExpression->isInitialized();
+}
+
+void Model_AttributeInteger::reinit()
+{
+  myExpression->reinit();
+  myIsInitialized = myExpression->isInitialized();
 }
 
 void Model_AttributeInteger::setCalculatedValue(const int theValue)

diff --git a/src/Model/Model_AttributeInteger.h b/src/Model/Model_AttributeInteger.h
index 870db29908d383499274846bfe65b03e247098c5..c56ff8af9b45a20339f4416799cd45ebaf811a93 100644 (file)
--- a/src/Model/Model_AttributeInteger.h
+++ b/src/Model/Model_AttributeInteger.h
@@ -57,7 +57,9 @@ class Model_AttributeInteger : public ModelAPI_AttributeInteger
 
  protected:
   /// Initializes attributes
-  Model_AttributeInteger();
+  Model_AttributeInteger(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 

diff --git a/src/Model/Model_AttributeRefAttr.cpp b/src/Model/Model_AttributeRefAttr.cpp
index 0c24fe3e1b762cfa047e634473aca9408b288c2c..6456b68a8bd1b2fc98a3164beca9a2bdb6c5d0ea 100644 (file)
--- a/src/Model/Model_AttributeRefAttr.cpp
+++ b/src/Model/Model_AttributeRefAttr.cpp
@@ -94,12 +94,18 @@ bool Model_AttributeRefAttr::isInitialized()
 
 Model_AttributeRefAttr::Model_AttributeRefAttr(TDF_Label& theLabel)
 {
-  myIsInitialized = theLabel.FindAttribute(TDataStd_Comment::GetID(), myID) == Standard_True;
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeRefAttr::reinit()
+{
+  myIsInitialized = myLab.FindAttribute(TDataStd_Comment::GetID(), myID) == Standard_True;
   if (!myIsInitialized) {
     // create attribute: not initialized by value yet
-    myID = TDataStd_Comment::Set(theLabel, "");
-    myRef = TDF_Reference::Set(theLabel, theLabel);  // not initialized: reference to itself
+    myID = TDataStd_Comment::Set(myLab, "");
+    myRef = TDF_Reference::Set(myLab, myLab);  // not initialized: reference to itself
   } else {
-    theLabel.FindAttribute(TDF_Reference::GetID(), myRef);
+    myLab.FindAttribute(TDF_Reference::GetID(), myRef);
   }
 }

diff --git a/src/Model/Model_AttributeRefAttr.h b/src/Model/Model_AttributeRefAttr.h
index 40e3e0ecbec066380b0252fb7a6c89088558037a..f0e1495631cfb5ac678d29acb31a123ba88563b6 100644 (file)
--- a/src/Model/Model_AttributeRefAttr.h
+++ b/src/Model/Model_AttributeRefAttr.h
@@ -22,6 +22,7 @@
 class Model_AttributeRefAttr : public ModelAPI_AttributeRefAttr
 {
   Handle_TDF_Reference myRef;  ///< reference to the feature label
+  TDF_Label myLab; ///< the main label of this attribute
   ///< ID of the referenced attribute (empty if this is a reference to a feature)
   Handle_TDataStd_Comment myID;
  public:
@@ -46,6 +47,8 @@ class Model_AttributeRefAttr : public ModelAPI_AttributeRefAttr
  protected:
   /// Objects are created for features automatically
   MODEL_EXPORT Model_AttributeRefAttr(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_AttributeRefAttrList.cpp b/src/Model/Model_AttributeRefAttrList.cpp
index 3cfd46274cc54ce37279d6dd3242c9185c9806be..e1ffa3b62ea2987ee3f9949d06dde7c99c476613 100755 (executable)
--- a/src/Model/Model_AttributeRefAttrList.cpp
+++ b/src/Model/Model_AttributeRefAttrList.cpp
@@ -308,11 +308,17 @@ void Model_AttributeRefAttrList::remove(const std::set<int>& theIndices)
 
 Model_AttributeRefAttrList::Model_AttributeRefAttrList(TDF_Label& theLabel)
 {
-  myIsInitialized = theLabel.FindAttribute(TDataStd_ReferenceList::GetID(), myRef) == Standard_True;
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeRefAttrList::reinit()
+{
+  myIsInitialized = myLab.FindAttribute(TDataStd_ReferenceList::GetID(), myRef) == Standard_True;
   if (!myIsInitialized) {
-    myRef = TDataStd_ReferenceList::Set(theLabel);
-    myIDs = TDataStd_ExtStringList::Set(theLabel);
+    myRef = TDataStd_ReferenceList::Set(myLab);
+    myIDs = TDataStd_ExtStringList::Set(myLab);
   } else {
-    theLabel.FindAttribute(TDataStd_ExtStringList::GetID(), myIDs);
+    myLab.FindAttribute(TDataStd_ExtStringList::GetID(), myIDs);
   }
 }

diff --git a/src/Model/Model_AttributeRefAttrList.h b/src/Model/Model_AttributeRefAttrList.h
index 2e666db26557e2cbab6388e40a6fbfa96574d990..6d877e3e75d2cb48b35a77674809871226268b88 100755 (executable)
--- a/src/Model/Model_AttributeRefAttrList.h
+++ b/src/Model/Model_AttributeRefAttrList.h
@@ -11,6 +11,7 @@
 #include "ModelAPI_AttributeRefAttrList.h"
 #include "ModelAPI_Feature.h"
 
+#include <TDF_Label.hxx>
 #include <TDataStd_ReferenceList.hxx>
 #include <TDataStd_ExtStringList.hxx>
 
@@ -22,6 +23,7 @@
 
 class Model_AttributeRefAttrList : public ModelAPI_AttributeRefAttrList
 {
+  TDF_Label myLab; ///< the main label of this attribute
   Handle_TDataStd_ReferenceList myRef;  ///< references to the features labels
   Handle_TDataStd_ExtStringList myIDs;  ///< the referenced attributes IDs (empty for just object)
  public:
@@ -71,6 +73,8 @@ class Model_AttributeRefAttrList : public ModelAPI_AttributeRefAttrList
  protected:
   /// Objects are created for features automatically
   MODEL_EXPORT Model_AttributeRefAttrList(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_AttributeRefList.cpp b/src/Model/Model_AttributeRefList.cpp
index 36d11541c50724c82befa3355af40875bee1e31a..9d6f25ff36d448b2f70d7b97a68b77eb3e4b2935 100644 (file)
--- a/src/Model/Model_AttributeRefList.cpp
+++ b/src/Model/Model_AttributeRefList.cpp
@@ -343,11 +343,17 @@ void Model_AttributeRefList::remove(const std::set<int>& theIndices)
 
 Model_AttributeRefList::Model_AttributeRefList(TDF_Label& theLabel)
 {
-  myIsInitialized = theLabel.FindAttribute(TDataStd_ReferenceList::GetID(), myRef) == Standard_True;
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeRefList::reinit()
+{
+  myIsInitialized = myLab.FindAttribute(TDataStd_ReferenceList::GetID(), myRef) == Standard_True;
   if (!myIsInitialized) {
-    myRef = TDataStd_ReferenceList::Set(theLabel);
+    myRef = TDataStd_ReferenceList::Set(myLab);
   }
-  if (!theLabel.FindAttribute(TDataStd_ExtStringList::GetID(), myExtDocRef)) {
-    myExtDocRef = TDataStd_ExtStringList::Set(theLabel);
+  if (!myLab.FindAttribute(TDataStd_ExtStringList::GetID(), myExtDocRef)) {
+    myExtDocRef = TDataStd_ExtStringList::Set(myLab);
   }
 }

diff --git a/src/Model/Model_AttributeRefList.h b/src/Model/Model_AttributeRefList.h
index b3690b2272466bff7c8fb6683f3a893524ceeba5..5d752156ed23e6e7086b5006fbae65a48081adfe 100644 (file)
--- a/src/Model/Model_AttributeRefList.h
+++ b/src/Model/Model_AttributeRefList.h
@@ -22,6 +22,7 @@
 
 class Model_AttributeRefList : public ModelAPI_AttributeRefList
 {
+  TDF_Label myLab; ///< the main label of this attribute
   Handle_TDataStd_ReferenceList myRef;  ///< references to the features labels
   /// pairs of doc ID and entries if reference is to external object, appends some in this list if
   /// something in myRef is empty
@@ -73,6 +74,8 @@ class Model_AttributeRefList : public ModelAPI_AttributeRefList
  protected:
   /// Objects are created for features automatically
   MODEL_EXPORT Model_AttributeRefList(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
   /// Returns the object by iterators (theExtIter is iterated if necessary)
   ObjectPtr iteratedObject(TDF_ListIteratorOfLabelList& theLIter,
     TDataStd_ListIteratorOfListOfExtendedString& theExtIter,

diff --git a/src/Model/Model_AttributeReference.cpp b/src/Model/Model_AttributeReference.cpp
index b4d5acbeeead1cdd1684f34133d94ae7c756b29b..b17b72f87ba72c863cff12990e57451445a20838 100644 (file)
--- a/src/Model/Model_AttributeReference.cpp
+++ b/src/Model/Model_AttributeReference.cpp
@@ -104,9 +104,15 @@ bool Model_AttributeReference::isInitialized()
 
 Model_AttributeReference::Model_AttributeReference(TDF_Label& theLabel)
 {
-  myIsInitialized = theLabel.FindAttribute(TDF_Reference::GetID(), myRef) == Standard_True;
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeReference::reinit()
+{
+  myIsInitialized = myLab.FindAttribute(TDF_Reference::GetID(), myRef) == Standard_True;
   if (!myIsInitialized) {
-    myRef = TDF_Reference::Set(theLabel, theLabel);  // not initialized references to itself
+    myRef = TDF_Reference::Set(myLab, myLab);  // not initialized references to itself
   } else {
     if (owner()) {
       std::shared_ptr<Model_Document> aDoc =

diff --git a/src/Model/Model_AttributeReference.h b/src/Model/Model_AttributeReference.h
index 7ea779b6ce656afa2da6a068d4e2c5aca4e83ee7..ea9b721f527b64c4d4ef78d357a1f009e0fd4a24 100644 (file)
--- a/src/Model/Model_AttributeReference.h
+++ b/src/Model/Model_AttributeReference.h
@@ -20,6 +20,7 @@
 
 class Model_AttributeReference : public ModelAPI_AttributeReference
 {
+  TDF_Label myLab; ///< the main label of this attribute
   Handle_TDF_Reference myRef;  ///< references to the feature label
  public:
   /// Defines the object referenced from this attribute
@@ -39,6 +40,8 @@ class Model_AttributeReference : public ModelAPI_AttributeReference
 protected:
   /// Objects are created for features automatically
   MODEL_EXPORT Model_AttributeReference(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
   friend class Model_AttributeSelection;

diff --git a/src/Model/Model_AttributeSelection.h b/src/Model/Model_AttributeSelection.h
index 2f9250642d023a018a0c265aebf27f4521580010..d1a426693e524ebf828f369111368f3ec6b45926 100644 (file)
--- a/src/Model/Model_AttributeSelection.h
+++ b/src/Model/Model_AttributeSelection.h
@@ -75,7 +75,8 @@ public:
 protected:
   /// Objects are created for features automatically
   MODEL_EXPORT Model_AttributeSelection(TDF_Label& theLabel);
-    /// Performs the selection for the body result (TNaming Selection)
+
+  /// Performs the selection for the body result (TNaming Selection)
 
   /// Performs the selection for the body result (TNaming selection)
   virtual void selectBody(

diff --git a/src/Model/Model_AttributeSelectionList.cpp b/src/Model/Model_AttributeSelectionList.cpp
index e97a2ee4918331235f52a227afc75931a4e2f9fb..856db04473f8860fe7d6c5f7152ecba4d4a0ba10 100644 (file)
--- a/src/Model/Model_AttributeSelectionList.cpp
+++ b/src/Model/Model_AttributeSelectionList.cpp
@@ -288,16 +288,23 @@ bool Model_AttributeSelectionList::isInitialized()
 
 Model_AttributeSelectionList::Model_AttributeSelectionList(TDF_Label& theLabel)
 {
-  myIsInitialized = theLabel.FindAttribute(TDataStd_Integer::GetID(), mySize) == Standard_True;
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeSelectionList::reinit()
+{
+  myIsInitialized = myLab.FindAttribute(TDataStd_Integer::GetID(), mySize) == Standard_True;
   if (!myIsInitialized) {
-    mySize = TDataStd_Integer::Set(theLabel, 0);
-    mySelectionType = TDataStd_Comment::Set(theLabel, "");
+    mySize = TDataStd_Integer::Set(myLab, 0);
+    mySelectionType = TDataStd_Comment::Set(myLab, "");
   } else { // recollect mySubs
-    theLabel.FindAttribute(TDataStd_Comment::GetID(), mySelectionType);
+    myLab.FindAttribute(TDataStd_Comment::GetID(), mySelectionType);
   }
   myIsCashed = false;
 }
 
+
 void Model_AttributeSelectionList::cashValues(const bool theEnabled)
 {
   myIsCashed = theEnabled;

diff --git a/src/Model/Model_AttributeSelectionList.h b/src/Model/Model_AttributeSelectionList.h
index 3c6317d5ab4a06ccf685254c941e1e29b5f25657..c3b50a3d7910d33b3f96037510ba84b8bffef23d 100644 (file)
--- a/src/Model/Model_AttributeSelectionList.h
+++ b/src/Model/Model_AttributeSelectionList.h
@@ -23,6 +23,7 @@
 
 class Model_AttributeSelectionList : public ModelAPI_AttributeSelectionList
 {
+  TDF_Label myLab; ///< the main label of this attribute
   Handle(TDataStd_Integer) mySize;  ///< Contains size of this list
   /// Contains current type name (same as selection attribute)
   Handle(TDataStd_Comment) mySelectionType;
@@ -88,6 +89,8 @@ public:
 protected:
   /// Objects are created for features automatically
   MODEL_EXPORT Model_AttributeSelectionList(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_AttributeString.cpp b/src/Model/Model_AttributeString.cpp
index 773a8bef919fbeaf61988b4080f8da2512d0e13b..72eb091932cb241b7662ab9bab9047f64196f48a 100644 (file)
--- a/src/Model/Model_AttributeString.cpp
+++ b/src/Model/Model_AttributeString.cpp
@@ -37,6 +37,11 @@ std::string Model_AttributeString::value()
 Model_AttributeString::Model_AttributeString(TDF_Label& theLabel)
 {
   myLab = theLabel;
+  reinit();
+}
+
+void Model_AttributeString::reinit()
+{
   // check the attribute could be already presented in this doc (after load document)
-  myIsInitialized = theLabel.FindAttribute(TDataStd_Name::GetID(), myString) == Standard_True;
+  myIsInitialized = myLab.FindAttribute(TDataStd_Name::GetID(), myString) == Standard_True;
 }

diff --git a/src/Model/Model_AttributeString.h b/src/Model/Model_AttributeString.h
index ac020f051cb82c2a88c0e66cb18fd34731e78b90..0d5e382ae02519f4261ee3149fd5d15f01d95ebe 100644 (file)
--- a/src/Model/Model_AttributeString.h
+++ b/src/Model/Model_AttributeString.h
@@ -34,6 +34,8 @@ class Model_AttributeString : public ModelAPI_AttributeString
  protected:
   /// Initializes attibutes
   Model_AttributeString(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
   friend class Model_Data;
 };

diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp
index 7f86b2116b0bc3c38fa6f24a681d3684c8f78b7e..75c9732427a00276a7014e35ac74630fd246e0a9 100644 (file)
--- a/src/Model/Model_Data.cpp
+++ b/src/Model/Model_Data.cpp
@@ -126,18 +126,9 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin
   if (theAttrType == ModelAPI_AttributeDocRef::typeId()) {
     anAttr = new Model_AttributeDocRef(anAttrLab);
   } else if (theAttrType == Model_AttributeInteger::typeId()) {
-    Model_AttributeInteger* anAttribute = new Model_AttributeInteger();
-    // Expression should use the same label to support backward compatibility
-    TDF_Label anExpressionLab = anAttrLab;
-    anAttribute->myExpression.reset(new Model_ExpressionInteger(anExpressionLab));
-    anAttribute->myIsInitialized = anAttribute->myExpression->isInitialized();
-    anAttr = anAttribute;
+    anAttr = new Model_AttributeInteger(anAttrLab);
   } else if (theAttrType == ModelAPI_AttributeDouble::typeId()) {
-    Model_AttributeDouble* anAttribute = new Model_AttributeDouble();
-    TDF_Label anExpressionLab = anAttrLab.FindChild(1);
-    anAttribute->myExpression.reset(new Model_ExpressionDouble(anExpressionLab));
-    anAttribute->myIsInitialized = anAttribute->myExpression->isInitialized();
-    anAttr = anAttribute;
+    anAttr = new Model_AttributeDouble(anAttrLab);
   } else if (theAttrType == Model_AttributeBoolean::typeId()) {
     anAttr = new Model_AttributeBoolean(anAttrLab);
   } else if (theAttrType == Model_AttributeString::typeId()) {

diff --git a/src/Model/Model_Expression.cpp b/src/Model/Model_Expression.cpp
index 7082bd60c0293ba31434b1c9cea62cfa43619228..3a1d62ab25642c774dab95588c636644c3a99d8d 100644 (file)
--- a/src/Model/Model_Expression.cpp
+++ b/src/Model/Model_Expression.cpp
@@ -75,35 +75,21 @@ std::set<std::string> Model_Expression::usedParameters() const
   return aResult;
 }
 
+///////////////// Model_ExpressionDouble /////////////
 Model_ExpressionDouble::Model_ExpressionDouble(TDF_Label& theLabel)
     : Model_Expression(theLabel)
 {
-  if (!theLabel.FindAttribute(TDataStd_Real::GetID(), myReal)) {
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_ExpressionDouble::reinit()
+{
+  if (!myLab.FindAttribute(TDataStd_Real::GetID(), myReal)) {
     myIsInitialized = false;
-    // MPV: temporarily to support the previously saved files (to check and resolve bugs), to be removed
-    Handle(TDataStd_RealArray) anOldArray;
-    if (theLabel.Father().FindAttribute(TDataStd_RealArray::GetID(), anOldArray) == Standard_True) {
-      myReal = TDataStd_Real::Set(theLabel, 0.);
-      myReal->Set(anOldArray->Value(theLabel.Tag() - 1));
-      myIsInitialized = true;
-      Handle(TDataStd_ExtStringArray) anOldExp;
-      if (theLabel.Father().FindAttribute(TDataStd_ExtStringArray::GetID(), anOldExp) == Standard_True) {
-        myText->Set(anOldExp->Value(theLabel.Tag() - 1));
-      }
-    } else {
-      Handle(TDataStd_Real) anOldReal;
-      if (theLabel.Father().FindAttribute(TDataStd_Real::GetID(), anOldReal)) {
-        myIsInitialized = true;
-        myReal = TDataStd_Real::Set(theLabel, 0.);
-        myReal->Set(anOldReal->Get());
-        Handle(TDataStd_Name) aText;
-        if (theLabel.Father().FindAttribute(TDataStd_Name::GetID(), aText)) {
-          myText->Set(aText->Get());
-        }
-      }
-    }
-  } else
+  } else {
     myIsInitialized = true;
+  }
 }
 
 void Model_ExpressionDouble::setValue(const double theValue)
@@ -137,14 +123,21 @@ bool Model_ExpressionDouble::isInvalid()
   return myText->Label().IsAttribute(kInvalidGUID) == Standard_True;
 }
 
-
+///////////////// Model_ExpressionInteger /////////////
 Model_ExpressionInteger::Model_ExpressionInteger(TDF_Label& theLabel)
     : Model_Expression(theLabel)
 {
-  if (!theLabel.FindAttribute(TDataStd_Integer::GetID(), myInteger)) {
+  myLab = theLabel;
+  reinit();
+}
+
+void Model_ExpressionInteger::reinit()
+{
+  if (!myLab.FindAttribute(TDataStd_Integer::GetID(), myInteger)) {
     myIsInitialized = false;
-  } else
+  } else {
     myIsInitialized = true;
+  }
 }
 
 void Model_ExpressionInteger::setValue(const int theValue)

diff --git a/src/Model/Model_Expression.h b/src/Model/Model_Expression.h
index fa2be8f75736468a3c40bd5ea24a6cf9b049008d..2c5b2cd7a4fcd82b0456b391f75a12a4654f6f9b 100644 (file)
--- a/src/Model/Model_Expression.h
+++ b/src/Model/Model_Expression.h
@@ -50,8 +50,7 @@ class Model_Expression : public virtual ModelAPI_Expression
   Handle_TDataStd_Name myText; ///< Text representation of the attribute (may differ for parameters)
   Handle_TDataStd_Comment myError; ///< Error of expression of the text attribute
   Handle_TDataStd_ExtStringList myUsedParameters; ///< Parameters used in expression
-
-  friend class Model_Data;
+  TDF_Label myLab; ///< if attribute is not initialized, store label here
 };
 
 
@@ -109,7 +108,10 @@ class Model_ExpressionDouble :
  protected:
   /// Initializes attributes
   Model_ExpressionDouble(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
+  friend class Model_AttributeDouble;
   friend class Model_Data;
 
  private:
@@ -171,8 +173,10 @@ class Model_ExpressionInteger :
  protected:
   /// Initializes attributes
   Model_ExpressionInteger(TDF_Label& theLabel);
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  virtual void reinit();
 
-  friend class Model_Data;
+  friend class Model_AttributeInteger;
 
  private:
   Handle_TDataStd_Integer myInteger;

diff --git a/src/Model/Model_Objects.cpp b/src/Model/Model_Objects.cpp
index f1edf57aac1a427ab90f77430dd4a4197015690b..c55a9430717793a234e2d24073c6d7e2ea127f3f 100644 (file)
--- a/src/Model/Model_Objects.cpp
+++ b/src/Model/Model_Objects.cpp
@@ -664,9 +664,10 @@ void Model_Objects::synchronizeFeatures(
       aKeptFeatures.insert(aFeature);
       if (anUpdatedMap.Contains(aFeatureLabel)) {
         if (!theOpen) { // on abort/undo/redo reinitialize attributes is something is changed
-          std::shared_ptr<Model_Data> aD = std::dynamic_pointer_cast<Model_Data>(aFeature->data());
-          aD->myAttrs.clear();
-          aFeature->initAttributes();
+          std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs = aFeature->data()->attributes("");
+          std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
+          for(; anAttr != anAttrs.end(); anAttr++)
+            (*anAttr)->reinit();
         }
         ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent);
         if (aFeature->getKind() == "Parameter") { // if parameters are changed, update the results (issue 937)

diff --git a/src/ModelAPI/ModelAPI_Attribute.cpp b/src/ModelAPI/ModelAPI_Attribute.cpp
index e7553a05da282865ec233007a0e627e3a8b4e446..dd704bd31d22b15454ff35fcd87717ba559b916a 100644 (file)
--- a/src/ModelAPI/ModelAPI_Attribute.cpp
+++ b/src/ModelAPI/ModelAPI_Attribute.cpp
@@ -83,3 +83,5 @@ void ModelAPI_Attribute::setID(const std::string theID)
 {
   myID = theID;
 }
+
+void ModelAPI_Attribute::reinit() {}

diff --git a/src/ModelAPI/ModelAPI_Attribute.h b/src/ModelAPI/ModelAPI_Attribute.h
index 22231be4b4382372c0036a17d2c1aee7b3148d5f..95fd0544eec181d253eb975ba52d380dec6c8f27 100644 (file)
--- a/src/ModelAPI/ModelAPI_Attribute.h
+++ b/src/ModelAPI/ModelAPI_Attribute.h
@@ -79,7 +79,11 @@ class ModelAPI_Attribute
   /// Sets the ID of the attribute in Data (called from Data)
   MODELAPI_EXPORT virtual void setID(const std::string theID);
 
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  MODELAPI_EXPORT virtual void reinit();
+
   friend class Model_Data;
+  friend class Model_Objects;
 };
 
 //! Pointer on attribute object

diff --git a/src/ModelAPI/ModelAPI_Expression.h b/src/ModelAPI/ModelAPI_Expression.h
index c583e58c7afecbb52991f6e62ac33a2b48e2079f..dbfdeba6955b4ff5350a35ac2c88329862c4ba9a 100644 (file)
--- a/src/ModelAPI/ModelAPI_Expression.h
+++ b/src/ModelAPI/ModelAPI_Expression.h
@@ -56,10 +56,16 @@ class ModelAPI_Expression
  protected:
   /// Objects are created for features automatically
   MODELAPI_EXPORT ModelAPI_Expression();
+  /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+  MODELAPI_EXPORT virtual void reinit() = 0;
 
   bool myIsInitialized; ///< is some value assigned to this attribute
 
   friend class Model_Data;
+  friend class Model_AttributeDouble;
+  friend class Model_AttributeInteger;
+  friend class GeomData_Point;
+  friend class GeomData_Point2D;
 };
 
 

diff --git a/src/SketchPlugin/Test/TestConstraintDistance.py b/src/SketchPlugin/Test/TestConstraintDistance.py
index 75f4d3fbbbdf94a956e845f5b83a75898548a54b..38761a36d709b02f8518f1428998cbc328c58f7c 100644 (file)
--- a/src/SketchPlugin/Test/TestConstraintDistance.py
+++ b/src/SketchPlugin/Test/TestConstraintDistance.py
@@ -109,7 +109,6 @@ aSession.finishOperation()
 aSession.startOperation()
 aFlyoutPoint = geomDataAPI_Point2D(aConstraint.attribute("ConstraintFlyoutValuePnt"))
 aFlyoutPoint.setValue(50.0, 100.0)
-aSession.finishOperation()
 aSession.abortOperation()
 assert (refattrA.isInitialized())
 assert (refattrB.isInitialized())
@@ -163,7 +162,6 @@ aSession.finishOperation()
 aSession.startOperation()
 aFlyoutPoint = geomDataAPI_Point2D(aConstraint.attribute("ConstraintFlyoutValuePnt"))
 aFlyoutPoint.setValue(50.0, 100.0)
-aSession.finishOperation()
 aSession.abortOperation()
 assert (refattrA.isInitialized())
 assert (refattrB.isInitialized())