Sending events on attributes data changed

diff --git a/src/GeomData/CMakeLists.txt b/src/GeomData/CMakeLists.txt
index de9142621337e532d65139719aba0ca8c14e02f0..b69c280d060d7ae678882a7c9307b80589227e8b 100644 (file)
--- a/src/GeomData/CMakeLists.txt
+++ b/src/GeomData/CMakeLists.txt
@@ -16,7 +16,7 @@ SET(PROJECT_SOURCES
 
 ADD_DEFINITIONS(-DGEOMDATA_EXPORTS ${CAS_DEFINITIONS} ${BOOST_DEFINITIONS})
 ADD_LIBRARY(GeomData SHARED ${PROJECT_SOURCES} ${PROJECT_HEADERS})
-TARGET_LINK_LIBRARIES(GeomData ${PROJECT_LIBRARIES} ${CAS_OCAF} ModelAPI GeomAPI)
+TARGET_LINK_LIBRARIES(GeomData ${PROJECT_LIBRARIES} ${CAS_OCAF} ModelAPI GeomAPI Events)
 
 INCLUDE_DIRECTORIES(
   ../ModelAPI
@@ -24,6 +24,7 @@ INCLUDE_DIRECTORIES(
   ../GeomAPI
   ../Events
   ../Config
+  ../Model
   ${CAS_INCLUDE_DIRS}
 )
 

diff --git a/src/GeomData/GeomData_Dir.cpp b/src/GeomData/GeomData_Dir.cpp
index 22dac3fe4df1cb7c186986feeb655bfda658bd1a..5090a06267f562b7ccc9bb141e6c9b829bf7f05e 100644 (file)
--- a/src/GeomData/GeomData_Dir.cpp
+++ b/src/GeomData/GeomData_Dir.cpp
@@ -5,14 +5,21 @@
 #include "GeomData_Dir.h"
 #include "GeomAPI_Dir.h"
 #include <gp_Dir.hxx>
+#include "Model_Events.h"
+#include <Events_Loop.h>
 
 using namespace std;
 
 void GeomData_Dir::setValue(const double theX, const double theY, const double theZ)
 {
-  myCoords->SetValue(0, theX);
-  myCoords->SetValue(1, theY);
-  myCoords->SetValue(2, theZ);
+  if (myCoords->Value(0) != theX || myCoords->Value(1) != theY || myCoords->Value(2) != theZ) {
+    myCoords->SetValue(0, theX);
+    myCoords->SetValue(1, theY);
+    myCoords->SetValue(2, theZ);
+    static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_UPDATED);
+    Model_FeatureUpdatedMessage aMsg(feature(), anEvent);
+    Events_Loop::loop()->send(aMsg);
+  }
 }
 
 double GeomData_Dir::x() const

diff --git a/src/GeomData/GeomData_Point.cpp b/src/GeomData/GeomData_Point.cpp
index 6f57d4157225eea930577ce8acb462d4820821ab..b928f36958adc8fe426919943d80bfa854ce6dc6 100644 (file)
--- a/src/GeomData/GeomData_Point.cpp
+++ b/src/GeomData/GeomData_Point.cpp
@@ -3,14 +3,21 @@
 // Author:      Mikhail PONIKAROV
 
 #include "GeomData_Point.h"
+#include "Model_Events.h"
+#include <Events_Loop.h>
 
 using namespace std;
 
 void GeomData_Point::setValue(const double theX, const double theY, const double theZ)
 {
-  myCoords->SetValue(0, theX);
-  myCoords->SetValue(1, theY);
-  myCoords->SetValue(2, theZ);
+  if (myCoords->Value(0) != theX || myCoords->Value(1) != theY || myCoords->Value(2) != theZ) {
+    myCoords->SetValue(0, theX);
+    myCoords->SetValue(1, theY);
+    myCoords->SetValue(2, theZ);
+    static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_UPDATED);
+    Model_FeatureUpdatedMessage aMsg(feature(), anEvent);
+    Events_Loop::loop()->send(aMsg);
+  }
 }
 
 double GeomData_Point::x() const

diff --git a/src/GeomData/GeomData_Point2D.cpp b/src/GeomData/GeomData_Point2D.cpp
index 3e576226bfb1c07a61153c4232ab24524a653ab3..bbf3e55fb578d27d567beb57409ce69f80ff9457 100644 (file)
--- a/src/GeomData/GeomData_Point2D.cpp
+++ b/src/GeomData/GeomData_Point2D.cpp
@@ -3,13 +3,20 @@
 // Author:      Mikhail PONIKAROV
 
 #include "GeomData_Point2D.h"
+#include "Model_Events.h"
+#include <Events_Loop.h>
 
 using namespace std;
 
 void GeomData_Point2D::setValue(const double theX, const double theY)
 {
-  myCoords->SetValue(0, theX);
-  myCoords->SetValue(1, theY);
+  if (myCoords->Value(0) != theX || myCoords->Value(1) != theY) {
+    myCoords->SetValue(0, theX);
+    myCoords->SetValue(1, theY);
+    static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_UPDATED);
+    Model_FeatureUpdatedMessage aMsg(feature(), anEvent);
+    Events_Loop::loop()->send(aMsg);
+  }
 }
 
 double GeomData_Point2D::x() const

diff --git a/src/Model/Model_AttributeDocRef.cpp b/src/Model/Model_AttributeDocRef.cpp
index 9df9c22190611371b1cd80357fc9de7b3de3fa14..82492e2d6dcac4b2850f46a12f67012823677d4e 100644 (file)
--- a/src/Model/Model_AttributeDocRef.cpp
+++ b/src/Model/Model_AttributeDocRef.cpp
@@ -4,12 +4,21 @@
 
 #include "Model_AttributeDocRef.h"
 #include "Model_Application.h"
+#include "Model_Events.h"
+#include <Events_Loop.h>
 
 using namespace std;
 
 void Model_AttributeDocRef::setValue(boost::shared_ptr<ModelAPI_Document> theDoc)
 {
-  myComment->Set(TCollection_ExtendedString(theDoc->id().c_str()));
+  TCollection_ExtendedString aNewID(theDoc->id().c_str());
+  if (myComment->Get() != aNewID) {
+    myComment->Set(TCollection_ExtendedString(theDoc->id().c_str()));
+
+    static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_UPDATED);
+    Model_FeatureUpdatedMessage aMsg(feature(), anEvent);
+    Events_Loop::loop()->send(aMsg);
+  }
 }
 
 boost::shared_ptr<ModelAPI_Document> Model_AttributeDocRef::value()

diff --git a/src/Model/Model_AttributeDouble.cpp b/src/Model/Model_AttributeDouble.cpp
index 23e15f0e1ad9457e92570a83dec685aa67ed0314..13b4c97c650b8984971a2e0fdb7689432304a463 100644 (file)
--- a/src/Model/Model_AttributeDouble.cpp
+++ b/src/Model/Model_AttributeDouble.cpp
@@ -3,12 +3,19 @@
 // Author:      Mikhail PONIKAROV
 
 #include "Model_AttributeDouble.h"
+#include "Model_Events.h"
+#include <Events_Loop.h>
 
 using namespace std;
 
 void Model_AttributeDouble::setValue(const double theValue)
 {
-  myReal->Set(theValue);
+  if (myReal->Get() != theValue) {
+    myReal->Set(theValue);
+    static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_UPDATED);
+    Model_FeatureUpdatedMessage aMsg(feature(), anEvent);
+    Events_Loop::loop()->send(aMsg);
+  }
 }
 
 double Model_AttributeDouble::value()

diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp
index 0bb5a12c82268f7e9075e58f2335eaaf98ad68af..5b26417a200191515540f1806624487bd9f6b266 100644 (file)
--- a/src/Model/Model_Data.cpp
+++ b/src/Model/Model_Data.cpp
@@ -49,8 +49,10 @@ void Model_Data::addAttribute(string theID, string theAttrType)
   else if (theAttrType == GeomData_Point2D::type())
     anAttr = new GeomData_Point2D(anAttrLab);
 
-  if (anAttr)
+  if (anAttr) {
     myAttrs[theID] = boost::shared_ptr<ModelAPI_Attribute>(anAttr);
+    anAttr->setFeature(myFeature);
+  }
   else
     ; // TODO: generate error on unknown attribute request and/or add mechanism for customization
 }

diff --git a/src/Model/Model_Data.h b/src/Model/Model_Data.h
index 647024e6d1290388f62ef50c583c0009741dc2cf..1548c709e4f96eafb45d9ac5c3255c716f04a330 100644 (file)
--- a/src/Model/Model_Data.h
+++ b/src/Model/Model_Data.h
@@ -12,6 +12,7 @@
 #include <map>
 
 class ModelAPI_Attribute;
+class ModelAPI_Feature;
 
 /**\class Model_Data
  * \ingroup DataModel
@@ -25,7 +26,8 @@ class Model_Data: public ModelAPI_Data
   /// All attributes of the object identified by the attribute ID
   std::map<std::string, boost::shared_ptr<ModelAPI_Attribute> > myAttrs;
 
-  boost::shared_ptr<ModelAPI_Document> myDoc; ///< document this feature belongs to
+  /// needed here to emit signal that feature changed on change of the attribute
+  boost::shared_ptr<ModelAPI_Feature> myFeature;
 
   Model_Data();
 
@@ -53,14 +55,12 @@ public:
   /// \param theAttrType type of the created attribute (received from the type method)
   MODEL_EXPORT virtual void addAttribute(std::string theID, std::string theAttrType);
 
-  /// Returns the document of this data
-  MODEL_EXPORT virtual boost::shared_ptr<ModelAPI_Document> document() {return myDoc;}
-
   /// Puts feature to the document data sub-structure
   MODEL_EXPORT void setLabel(TDF_Label& theLab);
 
-  /// Sets the document of this data
-  MODEL_EXPORT virtual void setDocument(const boost::shared_ptr<ModelAPI_Document>& theDoc) {myDoc = theDoc;}
+  /// Sets the feature of this data
+  MODEL_EXPORT virtual void setFeature(boost::shared_ptr<ModelAPI_Feature> theFeature)
+    {myFeature = theFeature;}
 };
 
 #endif

diff --git a/src/Model/Model_Document.cpp b/src/Model/Model_Document.cpp
index d33caaae8109707c31480b20d5ef28a1aa43813f..304bef421dd7a3fca954e164ea484e4607b50c4e 100644 (file)
--- a/src/Model/Model_Document.cpp
+++ b/src/Model/Model_Document.cpp
@@ -223,10 +223,11 @@ void Model_Document::addFeature(const boost::shared_ptr<ModelAPI_Feature> theFea
   TDF_Label aGroupLab = groupLabel(aGroup);
   TDF_Label anObjLab = aGroupLab.NewChild();
   boost::shared_ptr<Model_Data> aData(new Model_Data);
+  aData->setFeature(theFeature);
   aData->setLabel(anObjLab);
   boost::shared_ptr<ModelAPI_Document> aThis = Model_Application::getApplication()->getDocument(myID);
-  aData->setDocument(aThis);
   theFeature->setData(aData);
+  theFeature->setDoc(aThis);
   setUniqueName(theFeature);
   theFeature->initAttributes();
   // keep the feature ID to restore document later correctly
@@ -237,7 +238,7 @@ void Model_Document::addFeature(const boost::shared_ptr<ModelAPI_Feature> theFea
 
   // event: feature is added
   static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_CREATED);
-  ModelAPI_FeatureUpdatedMessage aMsg(aThis, theFeature, anEvent);
+  Model_FeatureUpdatedMessage aMsg(theFeature, anEvent);
   Events_Loop::loop()->send(aMsg);
 }
 
@@ -256,8 +257,8 @@ boost::shared_ptr<ModelAPI_Feature> Model_Document::feature(TDF_Label& theLabel)
 
 int Model_Document::featureIndex(boost::shared_ptr<ModelAPI_Feature> theFeature)
 {
-  if (theFeature->data()->document().get() != this) {
-    return theFeature->data()->document()->featureIndex(theFeature);
+  if (theFeature->document().get() != this) {
+    return theFeature->document()->featureIndex(theFeature);
   }
   boost::shared_ptr<Model_Data> aData = boost::dynamic_pointer_cast<Model_Data>(theFeature->data());
   Handle(TDataStd_Integer) aFeatureIndex;
@@ -370,7 +371,7 @@ void Model_Document::synchronizeFeatures()
     myGroups.erase(aGroupName);
     aGroupNamesIter = myGroupsNames.erase(aGroupNamesIter);
     // say that features were deleted from group
-    ModelAPI_FeatureDeletedMessage aMsg(aThis, aGroupName);
+    Model_FeatureDeletedMessage aMsg(aThis, aGroupName);
     Events_Loop::loop()->send(aMsg);
   }
   // create new groups basing on the following data model update
@@ -407,7 +408,7 @@ void Model_Document::synchronizeFeatures()
       if (aDSTag > aFeatureTag) { // feature is removed
         aFIter = aFeatures.erase(aFIter);
         // event: model is updated
-        ModelAPI_FeatureDeletedMessage aMsg(aThis, aGroupName);
+        Model_FeatureDeletedMessage aMsg(aThis, aGroupName);
         Events_Loop::loop()->send(aMsg);
       } else if (aDSTag < aFeatureTag) { // a new feature is inserted
         // create a feature
@@ -418,12 +419,13 @@ void Model_Document::synchronizeFeatures()
         boost::shared_ptr<Model_Data> aData(new Model_Data);
         TDF_Label aLab = aFLabIter.Value()->Label();
         aData->setLabel(aLab);
-        aData->setDocument(Model_Application::getApplication()->getDocument(myID));
+        aData->setFeature(aFeature);
+        aFeature->setDoc(aThis);
         aFeature->setData(aData);
         aFeature->initAttributes();
         // event: model is updated
         static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_CREATED);
-        ModelAPI_FeatureUpdatedMessage aMsg(aThis, aFeature, anEvent);
+        Model_FeatureUpdatedMessage aMsg(aFeature, anEvent);
         Events_Loop::loop()->send(aMsg);
 
         if (aFIter == aFeatures.end()) {

diff --git a/src/Model/Model_Events.cpp b/src/Model/Model_Events.cpp
index b71ecff50e068a2ab7d75775888446271c43ea6c..f4bede4e44ebc09faf54dfac9af7b84e0f09f1c7 100644 (file)
--- a/src/Model/Model_Events.cpp
+++ b/src/Model/Model_Events.cpp
@@ -5,20 +5,14 @@
 #include <Model_Events.h>
 #include <Events_Loop.h>
 
-ModelAPI_FeatureUpdatedMessage::ModelAPI_FeatureUpdatedMessage(
-  const boost::shared_ptr<ModelAPI_Document>& theDoc,
-  const boost::shared_ptr<ModelAPI_Feature>& theFeature, const Events_ID& theEvent)
-  : Events_Message(theEvent, 0), myFeature(theFeature), myDoc(theDoc)
-{}
-
-ModelAPI_FeatureDeletedMessage::ModelAPI_FeatureDeletedMessage(
+Model_FeatureDeletedMessage::Model_FeatureDeletedMessage(
   const boost::shared_ptr<ModelAPI_Document>& theDoc, const std::string& theGroup)
   : Events_Message(messageId(), 0), myDoc(theDoc), myGroup(theGroup)
 
 {
 }
 
-const Events_ID ModelAPI_FeatureDeletedMessage::messageId()
+const Events_ID Model_FeatureDeletedMessage::messageId()
 {
   static Events_ID MY_ID = Events_Loop::eventByName(EVENT_FEATURE_DELETED);
   return MY_ID;

diff --git a/src/Model/Model_Events.h b/src/Model/Model_Events.h
index feda6ab0263a8ce85e458916ab77227e9c8956d0..5c526db97374d6e0b4270152383dee33dc0e06a0 100644 (file)
--- a/src/Model/Model_Events.h
+++ b/src/Model/Model_Events.h
@@ -21,29 +21,26 @@ static const char * EVENT_FEATURE_UPDATED = "FeatureUpdated";
 static const char * EVENT_FEATURE_DELETED = "FeatureDeleted";
 
 /// Message that feature was changed (used for Object Browser update)
-class ModelAPI_FeatureUpdatedMessage : public Events_Message {
-  boost::shared_ptr<ModelAPI_Document> myDoc; ///< document owner of the feature
+class Model_FeatureUpdatedMessage : public Events_Message {
   boost::shared_ptr<ModelAPI_Feature> myFeature; ///< which feature is changed
 public:
   /// sender is not important, all information is located in the feature
-  ModelAPI_FeatureUpdatedMessage(
-    const boost::shared_ptr<ModelAPI_Document>& theDoc,
+  Model_FeatureUpdatedMessage(
     const boost::shared_ptr<ModelAPI_Feature>& theFeature,
-    const Events_ID& theEvent);
+    const Events_ID& theEvent) : Events_Message(theEvent, 0), myFeature(theFeature)
+  {}
 
   /// Returns the feature that has been updated
   boost::shared_ptr<ModelAPI_Feature> feature() const {return myFeature;}
-  /// Returns the document that has been updated
-  boost::shared_ptr<ModelAPI_Document> document() const {return myDoc;}
 };
 
 /// Message that feature was deleted (used for Object Browser update)
-class ModelAPI_FeatureDeletedMessage : public Events_Message {
+class Model_FeatureDeletedMessage : public Events_Message {
   boost::shared_ptr<ModelAPI_Document> myDoc; ///< document owner of the feature
   std::string myGroup; ///< group identifier that contained the deleted feature
 public:
   /// creates a message by initialization of fields
-  ModelAPI_FeatureDeletedMessage(const boost::shared_ptr<ModelAPI_Document>& theDoc,
+  Model_FeatureDeletedMessage(const boost::shared_ptr<ModelAPI_Document>& theDoc,
     const std::string& theGroup);
 
   /// Returns the ID of this message (EVENT_FEATURE_DELETED)

diff --git a/src/ModelAPI/ModelAPI_Attribute.h b/src/ModelAPI/ModelAPI_Attribute.h
index dfcdae495aefcf6f582c711b395af81c841384da..011430d723d31ee1859a45152577838dcd007ed5 100644 (file)
--- a/src/ModelAPI/ModelAPI_Attribute.h
+++ b/src/ModelAPI/ModelAPI_Attribute.h
@@ -7,21 +7,31 @@
 
 #include "ModelAPI.h"
 #include <string>
+#include <boost/shared_ptr.hpp>
+
+class ModelAPI_Feature;
 
 /**\class ModelAPI_Attribute
  * \ingroup DataModel
  * \brief Generic attribute of the Object.
  */
-class MODELAPI_EXPORT ModelAPI_Attribute
+class ModelAPI_Attribute
 {
+  ///< needed here to emit signal that feature changed on change of the attribute
+  boost::shared_ptr<ModelAPI_Feature> myFeature;
 public:
   
   /// Returns the type of this class of attributes, not static method
-  virtual std::string attributeType() = 0;
+  MODELAPI_EXPORT virtual std::string attributeType() = 0;
 
   /// To virtually destroy the fields of successors
-  virtual ~ModelAPI_Attribute() {}
+  MODELAPI_EXPORT virtual ~ModelAPI_Attribute() {}
+
+  MODELAPI_EXPORT void setFeature(const boost::shared_ptr<ModelAPI_Feature>& theFeature)
+    {myFeature = theFeature;}
 
+  MODELAPI_EXPORT const boost::shared_ptr<ModelAPI_Feature>& feature()
+  {return myFeature;}
 protected:
   /// Objects are created for features automatically
   ModelAPI_Attribute(){}

diff --git a/src/ModelAPI/ModelAPI_AttributeDocRef.h b/src/ModelAPI/ModelAPI_AttributeDocRef.h
index 473db7a44782e1784f28eb575a964bd61a2837e5..4765542cd06c7bc0edcd80db4369e52bac6d326d 100644 (file)
--- a/src/ModelAPI/ModelAPI_AttributeDocRef.h
+++ b/src/ModelAPI/ModelAPI_AttributeDocRef.h
@@ -13,27 +13,27 @@
  * \brief Attribute that contains reference to another document.
  */
 
-class MODELAPI_EXPORT ModelAPI_AttributeDocRef : public ModelAPI_Attribute
+class ModelAPI_AttributeDocRef : public ModelAPI_Attribute
 {
 public:
   /// Defines the document referenced from this attribute
-  virtual void setValue(boost::shared_ptr<ModelAPI_Document> theDoc) = 0;
+  MODELAPI_EXPORT virtual void setValue(boost::shared_ptr<ModelAPI_Document> theDoc) = 0;
 
   /// Returns document referenced from this attribute
-  virtual boost::shared_ptr<ModelAPI_Document> value() = 0;
+  MODELAPI_EXPORT virtual boost::shared_ptr<ModelAPI_Document> value() = 0;
 
   /// Returns the type of this class of attributes
-  static std::string type() {return "DocRef";}
+  MODELAPI_EXPORT static std::string type() {return "DocRef";}
 
   /// Returns the type of this class of attributes, not static method
-  virtual std::string attributeType() {return type();}
+  MODELAPI_EXPORT virtual std::string attributeType() {return type();}
 
   /// To virtually destroy the fields of successors
-  virtual ~ModelAPI_AttributeDocRef() {}
+  MODELAPI_EXPORT virtual ~ModelAPI_AttributeDocRef() {}
 
 protected:
   /// Objects are created for features automatically
-  ModelAPI_AttributeDocRef()
+  MODELAPI_EXPORT ModelAPI_AttributeDocRef()
   {}
 };
 

diff --git a/src/ModelAPI/ModelAPI_AttributeDouble.h b/src/ModelAPI/ModelAPI_AttributeDouble.h
index 024da5ea51bea4746d6db7e357e2ad66f0f702ba..81bdb66904dc4702a0454ee3b4c356ad9088ca0e 100644 (file)
--- a/src/ModelAPI/ModelAPI_AttributeDouble.h
+++ b/src/ModelAPI/ModelAPI_AttributeDouble.h
@@ -12,27 +12,27 @@
  * \brief Attribute that contains real value with double precision.
  */
 
-class MODELAPI_EXPORT ModelAPI_AttributeDouble : public ModelAPI_Attribute
+class ModelAPI_AttributeDouble : public ModelAPI_Attribute
 {
 public:
   /// Defines the double value
-  virtual void setValue(const double theValue) = 0;
+  MODELAPI_EXPORT virtual void setValue(const double theValue) = 0;
 
   /// Returns the double value
-  virtual double value() = 0;
+  MODELAPI_EXPORT virtual double value() = 0;
 
   /// Returns the type of this class of attributes
-  static std::string type() {return "Double";}
+  MODELAPI_EXPORT static std::string type() {return "Double";}
 
   /// Returns the type of this class of attributes, not static method
-  virtual std::string attributeType() {return type();}
+  MODELAPI_EXPORT virtual std::string attributeType() {return type();}
 
   /// To virtually destroy the fields of successors
-  virtual ~ModelAPI_AttributeDouble() {}
+  MODELAPI_EXPORT virtual ~ModelAPI_AttributeDouble() {}
 
 protected:
   /// Objects are created for features automatically
-  ModelAPI_AttributeDouble()
+  MODELAPI_EXPORT ModelAPI_AttributeDouble()
   {}
 };
 

diff --git a/src/ModelAPI/ModelAPI_Data.h b/src/ModelAPI/ModelAPI_Data.h
index 077e75d2766110a4eafea99537fb1641afd967f1..2922f6d9b3891b4875e51e509a96a4d401670c94 100644 (file)
--- a/src/ModelAPI/ModelAPI_Data.h
+++ b/src/ModelAPI/ModelAPI_Data.h
@@ -45,9 +45,6 @@ public:
   /// \param theAttrType type of the created attribute (received from the type method)
   virtual void addAttribute(std::string theID, std::string theAttrType) = 0;
 
-  /// Returns the document of this data
-  virtual boost::shared_ptr<ModelAPI_Document> document() = 0;
-
   /// To virtually destroy the fields of successors
   virtual ~ModelAPI_Data() {}
 

diff --git a/src/ModelAPI/ModelAPI_Feature.h b/src/ModelAPI/ModelAPI_Feature.h
index 8c1a82e75e2a3a22380065e42dab13463cba0662..6c458bab42218957046fac00a45df1818fb6e192 100644 (file)
--- a/src/ModelAPI/ModelAPI_Feature.h
+++ b/src/ModelAPI/ModelAPI_Feature.h
@@ -22,6 +22,7 @@ class ModelAPI_Document;
 class ModelAPI_Feature
 {
   boost::shared_ptr<ModelAPI_Data> myData; ///< manager of the data model of a feature
+  boost::shared_ptr<ModelAPI_Document> myDoc; ///< document this feature belongs to
 
 public:
   /// Returns the kind of a feature (like "Point")
@@ -44,6 +45,10 @@ public:
   MODELAPI_EXPORT virtual boost::shared_ptr<ModelAPI_Document> documentToAdd()
   {return ModelAPI_PluginManager::get()->currentDocument();}
 
+  /// Returns document this feature belongs to
+  MODELAPI_EXPORT virtual boost::shared_ptr<ModelAPI_Document> document()
+  {return myDoc;}
+
   /// To virtually destroy the fields of successors
   virtual ~ModelAPI_Feature() {}
 
@@ -55,6 +60,9 @@ protected:
 
   /// Sets the data manager of an object (document does)
   MODELAPI_EXPORT void setData(boost::shared_ptr<ModelAPI_Data> theData) {myData = theData;}
+  /// Sets the data manager of an object (document does)
+  MODELAPI_EXPORT void setDoc(boost::shared_ptr<ModelAPI_Document> theDoc) {myDoc = theDoc;}
+
   friend class Model_Document;
 };
 

diff --git a/src/XGUI/XGUI_DocumentDataModel.cpp b/src/XGUI/XGUI_DocumentDataModel.cpp
index 50ea7c707b4e5dde0904308e794153c3e7bcb75d..1ee46e331e9d07ca4d2c47980bf40cdea6af65a0 100644 (file)
--- a/src/XGUI/XGUI_DocumentDataModel.cpp
+++ b/src/XGUI/XGUI_DocumentDataModel.cpp
@@ -42,9 +42,9 @@ void XGUI_DocumentDataModel::processEvent(const Events_Message* theMessage)
 {
   // Created object event *******************
   if (QString(theMessage->eventID().eventText()) == EVENT_FEATURE_CREATED) {
-    const ModelAPI_FeatureUpdatedMessage* aUpdMsg = dynamic_cast<const ModelAPI_FeatureUpdatedMessage*>(theMessage);
-    boost::shared_ptr<ModelAPI_Document> aDoc = aUpdMsg->document();
+    const Model_FeatureUpdatedMessage* aUpdMsg = dynamic_cast<const Model_FeatureUpdatedMessage*>(theMessage);
     boost::shared_ptr<ModelAPI_Feature> aFeature = aUpdMsg->feature();
+    boost::shared_ptr<ModelAPI_Document> aDoc = aFeature->document();
 
     if (aDoc == myDocument) {  // If root objects
       if (aFeature->getGroup().compare(PARTS_GROUP) == 0) { // Updsate only Parts group
@@ -79,7 +79,7 @@ void XGUI_DocumentDataModel::processEvent(const Events_Message* theMessage)
 
   // Deteted object event ***********************
   } else if (QString(theMessage->eventID().eventText()) == EVENT_FEATURE_DELETED) {
-    const ModelAPI_FeatureDeletedMessage* aUpdMsg = dynamic_cast<const ModelAPI_FeatureDeletedMessage*>(theMessage);
+    const Model_FeatureDeletedMessage* aUpdMsg = dynamic_cast<const Model_FeatureDeletedMessage*>(theMessage);
     boost::shared_ptr<ModelAPI_Document> aDoc = aUpdMsg->document();
 
     if (aDoc == myDocument) {  // If root objects