Added duplicate selection (CTRL+D), undo and redo (CTRL+Z/Y) with scene history.

.gitignore

@@ -1,3 +1,4 @@
 *.py
 *.pyc
 CMakeLists.txt.user
+/build

CMakeLists.txt

@@ -34,6 +34,8 @@ set(CPP_SOURCE_FILES
   src/FlowView.cpp
   src/FlowViewStyle.cpp
   src/Node.cpp
+  src/Group.cpp
+  src/GroupGraphicsObject.cpp
   src/NodeConnectionInteraction.cpp
   src/NodeDataModel.cpp
   src/NodeGeometry.cpp

include/nodes/internal/Connection.hpp

@@ -23,6 +23,7 @@ namespace QtNodes
 class Node;
 class NodeData;
 class ConnectionGraphicsObject;
+class Group;
 
 ///
 class NODE_EDITOR_PUBLIC Connection
@@ -44,7 +45,8 @@ class NODE_EDITOR_PUBLIC Connection
   Connection(Node& nodeIn,
              PortIndex portIndexIn,
              Node& nodeOut,
-             PortIndex portIndexOut);
+             PortIndex portIndexOut,
+             QUuid *id = nullptr);
 
   Connection(const Connection&) = delete;
   Connection operator=(const Connection&) = delete;
@@ -55,7 +57,8 @@ class NODE_EDITOR_PUBLIC Connection
 
   QJsonObject
   save() const override;
-
+
+  QJsonObject copyWithNewID(QUuid in, QUuid out);
 public:
 
   QUuid
@@ -78,6 +81,10 @@ class NODE_EDITOR_PUBLIC Connection
   setNodeToPort(Node& node,
                 PortType portType,
                 PortIndex portIndex);
+  void
+  setGroup(Group* group,
+                PortType portType, 
+                PortIndex portIndex);
 
   void
   removeFromNodes() const;
@@ -104,8 +111,14 @@ class NODE_EDITOR_PUBLIC Connection
   Node*&
   getNode(PortType portType);
 
+  Group*
+  getGroup(PortType portType) const;
+
   PortIndex
   getPortIndex(PortType portType) const;
+
+  PortIndex
+  getGroupPortIndex(PortType portType) const;
 
   void
   clearNode(PortType portType);
@@ -132,6 +145,12 @@ class NODE_EDITOR_PUBLIC Connection
   PortIndex _outPortIndex;
   PortIndex _inPortIndex;
 
+  Group* _outGroup = nullptr;
+  Group* _inGroup  = nullptr;
+
+  PortIndex _outGroupPortIndex;
+  PortIndex _inGroupPortIndex;
+
 private:
 
   ConnectionState    _connectionState;

include/nodes/internal/DataModelRegistry.hpp

@@ -24,6 +24,8 @@ class NODE_EDITOR_PUBLIC DataModelRegistry
   using RegisteredModelsCategoryMap = std::unordered_map<QString, QString>;
   using CategoriesSet               = std::set<QString>;
 
+  using RegisteredTemplatesMap      = std::unordered_map<QString, QString>;
+
   struct TypeConverterItem
   {
     RegistryItemPtr Model{};
@@ -82,10 +84,23 @@ class NODE_EDITOR_PUBLIC DataModelRegistry
       converter->DestinationType = converter->Model->dataType(PortType::Out, 0);
 
       auto typeConverterKey = std::make_pair(converter->SourceType.id, converter->DestinationType.id);
-	  _registeredTypeConverters[typeConverterKey] = std::move(converter);
+	    _registeredTypeConverters[typeConverterKey] = std::move(converter);
     }
   }
 
+  void
+  registerTemplate(QString templateName, QString templateFilePath)
+  {
+      _registeredTemplates[templateName] = templateFilePath;
+  }
+
+  void 
+  removeTemplate(QString templateName)
+  {
+    _registeredTemplates.erase(templateName);
+  }
+
+
   //Parameter order alias, so a category can be set without forcing to manually pass a model instance
   template<typename ModelType, bool TypeConverter = false>
   void
@@ -103,6 +118,9 @@ class NODE_EDITOR_PUBLIC DataModelRegistry
   RegisteredModelsCategoryMap const &
   registeredModelsCategoryAssociation() const;
 
+  RegisteredTemplatesMap &
+  RegisteredTemplates();
+
   CategoriesSet const &
   categories() const;
 
@@ -116,5 +134,7 @@ class NODE_EDITOR_PUBLIC DataModelRegistry
   CategoriesSet _categories{};
   RegisteredModelsMap _registeredModels{};
   RegisteredTypeConvertersMap _registeredTypeConverters{};
+
+  RegisteredTemplatesMap _registeredTemplates{};
 };
 }

include/nodes/internal/FlowScene.hpp

@@ -11,18 +11,40 @@
 #include "QUuidStdHash.hpp"
 #include "Export.hpp"
 #include "DataModelRegistry.hpp"
+#include <stack>
 
 namespace QtNodes
 {
 
 class NodeDataModel;
 class FlowItemInterface;
 class Node;
+class Group;
 class NodeGraphicsObject;
 class Connection;
 class ConnectionGraphicsObject;
 class NodeStyle;
 
+
+
+struct UndoRedoAction {
+
+  std::function<int(void*)> undoAction;
+  std::function<int(void*)> redoAction;
+  std::string name;
+  UndoRedoAction(std::function<int(void*)> undoAction, std::function<int(void*)> redoAction, std::string name) {
+    this->undoAction = undoAction;
+    this->redoAction = redoAction;
+    this->name = name;
+  };
+};
+
+
+struct Anchor {
+  QPointF position;
+  double scale;
+};
+
 /// Scene holds connections and nodes.
 class NODE_EDITOR_PUBLIC FlowScene
   : public QGraphicsScene
@@ -35,6 +57,10 @@ class NODE_EDITOR_PUBLIC FlowScene
 
   ~FlowScene();
 
+  std::vector<UndoRedoAction> undoActions;
+  std::vector<UndoRedoAction> redoActions;
+  void PrintActions();
+  int historyInx; 
 public:
 
   std::shared_ptr<Connection>createConnection(PortType connectedPort,
@@ -44,18 +70,37 @@ class NODE_EDITOR_PUBLIC FlowScene
   std::shared_ptr<Connection>createConnection(Node& nodeIn,
                                               PortIndex portIndexIn,
                                               Node& nodeOut,
-                                              PortIndex portIndexOut);
+                                              PortIndex portIndexOut,
+                                              QUuid *id=nullptr);
 
   std::shared_ptr<Connection>restoreConnection(QJsonObject const &connectionJson);
 
   void deleteConnection(Connection& connection);
+  void deleteConnection(Connection* connection);
+  void deleteConnectionWithID(QUuid id);
 
   Node&createNode(std::unique_ptr<NodeDataModel> && dataModel);
+
+  Node&createNodeWithID(std::unique_ptr<NodeDataModel> && dataModel, QUuid id);
+
+  Group& createGroup();
+
+  Group& pasteGroup(QJsonObject const& nodeJson, QPointF nodeGroupCentroid, QPointF mousePos);
 
-  Node&restoreNode(QJsonObject const& nodeJson);
+  Node&restoreNode(QJsonObject const& nodeJson, bool keepId=false);
+
+  Group& restoreGroup(QJsonObject const& nodeJson);
+
+  QUuid pasteNode(QJsonObject &json, QPointF nodeGroupCentroid, QPointF mousePos);
+
+  void pasteConnection(QJsonObject const &connectionJson, QUuid newIn, QUuid newOut);
 
   void removeNode(Node& node);
 
+  void removeNodeWithID(QUuid id);
+
+  void removeGroup(Group& node);
+
   DataModelRegistry&registry() const;
 
   void setRegistry(std::shared_ptr<DataModelRegistry> registry);
@@ -71,13 +116,19 @@ class NODE_EDITOR_PUBLIC FlowScene
   void setNodePosition(Node& node, const QPointF& pos) const;
 
   QSizeF getNodeSize(const Node& node) const;
+
+  void resolveGroups(Group& node);
+
+  void resolveGroups(Node& n);
+
 public:
 
-  std::unordered_map<QUuid, std::unique_ptr<Node> > const &nodes() const;
+  std::unordered_map<QUuid, std::shared_ptr<Node> > const &nodes() const;
+  std::unordered_map<QUuid, std::shared_ptr<Node> >  &nodes();
 
   std::unordered_map<QUuid, std::shared_ptr<Connection> > const &connections() const;
 
-  std::vector<Node*>selectedNodes() const;
+  std::vector<std::shared_ptr<Node>>selectedNodes() const;
 
 public:
 
@@ -89,20 +140,45 @@ class NODE_EDITOR_PUBLIC FlowScene
 
   QByteArray saveToMemory() const;
 
+  void saveToClipBoard();
+
   void loadFromMemory(const QByteArray& data);
+
+  void AddAction(UndoRedoAction action);
+
+  void Undo();
+
+  void Redo();
+
+  void ResetHistory();
+
+  int GetHistoryIndex();
 
 signals:
 
   void nodeCreated(Node &n);
+
+  void groupCreated(Group &g);
 
   void nodeDeleted(Node &n);
 
   void connectionCreated(Connection &c);
+
   void connectionDeleted(Connection &c);
 
   void nodeMoved(Node& n, const QPointF& newLocation);
 
+  void groupMoved(Group& n, const QPointF& newLocation);
+
+  void nodeMoveFinished(Node& n, const QPointF& newLocation, const QPointF &oldLocation);
+
+  void groupMoveFinished(Group& g, const QPointF& newLocation, const QPointF& oldLocation);
+
+  void nodeClicked(Node& n);
+
   void nodeDoubleClicked(Node& n);
+
+  void groupDoubleClicked(Group& g);
 
   void connectionHovered(Connection& c, QPoint screenPos);
 
@@ -113,18 +189,35 @@ class NODE_EDITOR_PUBLIC FlowScene
   void nodeHoverLeft(Node& n);
 
   void nodeContextMenu(Node& n, const QPointF& pos);
+
+
+public:
+
+  std::vector<Anchor> anchors;  
+
+  int gridSize=1;
+  bool snapping=false;
 
 private:
 
   using SharedConnection = std::shared_ptr<Connection>;
-  using UniqueNode       = std::unique_ptr<Node>;
+  using UniqueNode       = std::shared_ptr<Node>;
 
   std::unordered_map<QUuid, SharedConnection> _connections;
   std::unordered_map<QUuid, UniqueNode>       _nodes;
   std::shared_ptr<DataModelRegistry>          _registry;
+  std::unordered_map<QUuid, std::shared_ptr<Group>> _groups;
+
+  bool writeToHistory; 
+
+
+private: 
 };
 
 Node*
 locateNodeAt(QPointF scenePoint, FlowScene &scene,
              QTransform viewTransform);
+Group*
+locateGroupAt(QPointF scenePoint, FlowScene &scene,
+             QTransform viewTransform);
 }

include/nodes/internal/FlowView.hpp

@@ -3,11 +3,12 @@
 #include <QtWidgets/QGraphicsView>
 
 #include "Export.hpp"
-
+  
 namespace QtNodes
 {
 
 class FlowScene;
+class NodeGraphicsObject;
 
 class NODE_EDITOR_PUBLIC FlowView
   : public QGraphicsView
@@ -27,13 +28,28 @@ class NODE_EDITOR_PUBLIC FlowView
 
   void setScene(FlowScene *scene);
 
+  QJsonObject selectionToJson(bool includePartialConnections=false);
+  void jsonToScene(QJsonObject object);
+  void jsonToSceneMousePos(QJsonObject object);
+  void deleteJsonElements(const QJsonObject &object);
+
+  void goToNode(NodeGraphicsObject *node);
+  void goToNodeID(QUuid ID);
+
+
 public slots:
 
   void scaleUp();
 
   void scaleDown();
-
+  
   void deleteSelectedNodes();
+
+  void duplicateSelectedNode();
+
+  void copySelectedNodes();
+
+  void pasteSelectedNodes();
 
 protected:
 
@@ -53,6 +69,10 @@ public slots:
 
   void showEvent(QShowEvent *event) override;
 
+  void addAnchor(int index);
+  void goToAnchor(int index);
+
+
 protected:
 
   FlowScene * scene();
@@ -61,6 +81,13 @@ public slots:
 
   QAction* _clearSelectionAction;
   QAction* _deleteSelectionAction;
+  QAction* _duplicateSelectionAction;
+  QAction* _copymultiplenodes;
+  QAction* _pastemultiplenodes;
+  QAction* _undoAction;
+  QAction* _redoAction;
+
+  std::vector<QAction*> anchorActions;
 
   QPointF _clickPos;