Provide connection of new features in SALOME module

[modules/shaper.git] / src / Model / Model_Events.h

diff --git a/src/Model/Model_Events.h b/src/Model/Model_Events.h
index c9c60b65ffd77a2be6b9fb3a2e4dc1c5a832da55..1fbf1980e1481b40ab2c1ef50340bf6131fc09f7 100644 (file)
--- a/src/Model/Model_Events.h
+++ b/src/Model/Model_Events.h
@@ -6,13 +6,14 @@
 #define Model_Events_HeaderFile
 
 #include <Model.h>
-#include <Events_Message.h>
+#include <Events_MessageGroup.h>
 #include <Events_Loop.h>
 #include <boost/shared_ptr.hpp>
 #include <string>
-#include <list>
+#include <set>
+
+#include "ModelAPI_Feature.h"
 
-class ModelAPI_Feature;
 class ModelAPI_Document;
 
 /// Event ID that feature is created (comes with Model_FeatureUpdatedMessage)
@@ -22,56 +23,88 @@ static const char * EVENT_FEATURE_UPDATED = "FeatureUpdated";
 /// Event ID that data of feature is deleted (comes with Model_FeatureDeletedMessage)
 static const char * EVENT_FEATURE_DELETED = "FeatureDeleted";
 /// Event ID that data of feature is updated (comes with Model_FeaturesMovedMessage)
-static const char * EVENT_FEATURES_MOVED = "FeaturesMoved";
+static const char * EVENT_FEATURE_MOVED = "FeaturesMoved";
 
-/// Message that feature was changed (used for Object Browser update)
-class Model_FeatureUpdatedMessage : public Events_Message {
-  boost::shared_ptr<ModelAPI_Feature> myFeature; ///< which feature is changed
+/// Message that feature was changed (used for Object Browser update): moved, updated and deleted
+class Model_FeatureUpdatedMessage : public Events_MessageGroup {
+  std::set<FeaturePtr > myFeatures; ///< which feature is changed
 public:
   /// sender is not important, all information is located in the feature
   Model_FeatureUpdatedMessage(
-    const boost::shared_ptr<ModelAPI_Feature>& theFeature,
-    const Events_ID& theEvent) : Events_Message(theEvent, 0), myFeature(theFeature)
-  {}
+    const FeaturePtr& theFeature,
+    const Events_ID& theEvent) : Events_MessageGroup(theEvent, 0)
+  {if (theFeature) myFeatures.insert(theFeature);}
 
   /// Returns the feature that has been updated
-  boost::shared_ptr<ModelAPI_Feature> feature() const {return myFeature;}
+  std::set<FeaturePtr > features() const {return myFeatures;}
+
+  //! Creates a new empty group (to store it in the loop before flush)
+  virtual Events_MessageGroup* newEmpty() {
+    FeaturePtr anEmptyFeature;
+    return new Model_FeatureUpdatedMessage(anEmptyFeature, eventID());
+  }
+
+  //! Allows to join the given message with the current one
+  virtual void Join(Events_MessageGroup& theJoined) {
+    Model_FeatureUpdatedMessage* aJoined = dynamic_cast<Model_FeatureUpdatedMessage*>(&theJoined);
+    std::set<FeaturePtr >::iterator aFIter = aJoined->myFeatures.begin();
+    for(; aFIter != aJoined->myFeatures.end(); aFIter++) {
+      myFeatures.insert(*aFIter);
+    }
+  }
 };
 
 /// Message that feature was deleted (used for Object Browser update)
-class Model_FeatureDeletedMessage : public Events_Message {
+class Model_FeatureDeletedMessage : public Events_MessageGroup {
   boost::shared_ptr<ModelAPI_Document> myDoc; ///< document owner of the feature
-  std::string myGroup; ///< group identifier that contained the deleted feature
+  std::set<std::string> myGroups; ///< group identifiers that contained the deleted feature
 public:
   /// creates a message by initialization of fields
-  Model_FeatureDeletedMessage(const boost::shared_ptr<ModelAPI_Document>& theDoc,
-    const std::string& theGroup);
+//  Model_FeatureDeletedMessage(const boost::shared_ptr<ModelAPI_Document>& theDoc,
+//    const std::string& theGroup);
 
   /// Returns the ID of this message (EVENT_FEATURE_DELETED)
-  static const Events_ID messageId();
+//  static const Events_ID messageId();
 
   /// Returns the feature that has been updated
   boost::shared_ptr<ModelAPI_Document> document() const {return myDoc;}
 
   /// Returns the group where the feature was deleted
-  const std::string& group() const {return myGroup;}
-};
+  const std::set<std::string >& groups() const {return myGroups;}
 
-/// Message that features were moved (used for the feature preview update)
-class Model_FeaturesMovedMessage : public Events_Message {
-  std::list<boost::shared_ptr<ModelAPI_Feature> > myFeatures; ///< which features are moved
-public:
-  /// creates a message by initialization of fields
-  MODEL_EXPORT Model_FeaturesMovedMessage();
+  //! Creates a new empty group (to store it in the loop before flush)
+//  virtual Events_MessageGroup* newEmpty();
+
+  //! Allows to join the given message with the current one
+//  virtual void Join(Events_MessageGroup& theJoined);
+
+  Events_MessageGroup* newEmpty() {
+    return new Model_FeatureDeletedMessage(myDoc, "");
+  }
+
+  Model_FeatureDeletedMessage(
+    const boost::shared_ptr<ModelAPI_Document>& theDoc, const std::string& theGroup)
+    : Events_MessageGroup(messageId(), 0), myDoc(theDoc)
 
-  /// Returns the ID of this message (EVENT_FEATURES_MOVED)
-  static const Events_ID messageId();
+  {
+    if (!theGroup.empty())
+      myGroups.insert(theGroup);
+  }
 
-  /// Sets a list of features
-  MODEL_EXPORT void setFeatures(const std::list<boost::shared_ptr<ModelAPI_Feature> >& theFeatures);
+  const Events_ID messageId()
+  {
+    static Events_ID MY_ID = Events_Loop::eventByName(EVENT_FEATURE_DELETED);
+    return MY_ID;
+  }
 
-  /// Returns a list of features
-  MODEL_EXPORT const std::list<boost::shared_ptr<ModelAPI_Feature> >& features() const;
+  void Join(Events_MessageGroup& theJoined)
+  {
+    Model_FeatureDeletedMessage* aJoined = dynamic_cast<Model_FeatureDeletedMessage*>(&theJoined);
+    std::set<std::string>::iterator aGIter = aJoined->myGroups.begin();
+    for(; aGIter != aJoined->myGroups.end(); aGIter++) {
+      myGroups.insert(*aGIter);
+    }
+  }
 };
 
 #endif