canvas.h

#pragma once
 
#include <QApplication>
#include <QDropEvent>
#include <QGraphicsItem>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QJsonObject>
#include <QMouseEvent>
#include <QPainter>
#include <QTimer>
 
#include "elements/node.h"
#include "json.h"
#include "node_info.h"
#include "save_info.h"
#include "system/focus_properties.h"
 
class QUndoStack;
class CanvasView;
class TransitionItem;
class ConfigurationTable;
class EdgeRouter;

class Canvas : public QGraphicsScene
{
  Q_OBJECT
public:
  struct CopiedNode
  {
    NodeSaveInfo info;           
    QPointF posRelativeToMouse;  
 
    QJsonObject toJson() const
    {
      QJsonObject object;
      object["info"] = info.toJson();
      object["position"] = JSON::fromPointF(posRelativeToMouse);
      return object;
    }
 
    static CopiedNode fromJson(const QJsonObject& object)
    {
      CopiedNode copied;
      copied.info = NodeSaveInfo::fromJson(object["info"].toObject());
      copied.posRelativeToMouse = JSON::toPointF(object["position"].toObject());
      return copied;
    }
  };
 
  enum class NodeCreation
  {
    Dropping,
    Pasting,
    Loading,
    Populating,
    Inserting
  };

  Canvas(const QString& canvasId, std::shared_ptr<ConfigurationTable> configTable, std::shared_ptr<EdgeRouter> router, QObject* parent = nullptr);
 
  ~Canvas();
  QString id() const;

  void pasteCopiedItems();

  void copySelectedItems(NodeItem* node);

  void deleteSelectedItems();
 
  void autoRoute();

  qreal getScale() const;

  QPointF getCenter() const;

  VoidResult loadFromSave(const SaveInfo& info);

  QList<NodeItem*> availableNodes();

  virtual Types::LibraryTypes type() const;

  QUndoStack* undoStack() const;

  void nodeClicked(NodeItem* node);

  void populate(const FlowSaveInfo& flow);

  void themeChanged();
 
  // Used for undo commands
  void createNode(const NodeSaveInfo& info, NodeCreation creation);

  void removeNode(const NodeSaveInfo& info);

  void moveNodeTo(const QString& nodeId, const QPointF& position);

  void setNodeSize(const QString& nodeId, const QSizeF& size);

  void createTransition(const TransitionSaveInfo& info);

  void removeTransition(const TransitionSaveInfo& info);

  void requestAlignNodes(const QList<Types::AlignmentNode>& items, Types::AlignmentMode mode, Types::AlignmentDirection direction);

  void alignNodes(const QList<Types::AlignmentNode>& items, Types::AlignmentMode mode, Types::AlignmentDirection direction, bool useGiven);
 
  void alignSelectedNodes(Types::AlignmentMode mode);
  void distributeSelectedNodes();
  void distributeNodesVertically(const QList<Types::AlignmentNode>& nodes);
  void distributeNodesHorizontally(const QList<Types::AlignmentNode>& nodes);
 
  std::shared_ptr<EdgeRouter> router() const;
 
  virtual void suggestCapability(NodeItem* node);
  virtual void suggestedNodes(NodeItem* node, QStringList consumers, QStringList producers);
 
protected:
  void dragEnterEvent(QGraphicsSceneDragDropEvent* event) override;

  void dragMoveEvent(QGraphicsSceneDragDropEvent* event) override;

  void dropEvent(QGraphicsSceneDragDropEvent* event) override;

  void mousePressEvent(QGraphicsSceneMouseEvent* event) override;

  void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override;

  void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) override;

  void contextMenuEvent(QGraphicsSceneContextMenuEvent* event) override;

  virtual void updateParent(NodeItem* node, std::shared_ptr<NodeSaveInfo> storage, bool adding);
 
signals:
  void nodeSelected(NodeItem* node, bool selected);

  void nodeAdded(NodeItem* node);

  void nodeRemoved(const QString& nodeId, const QString& parentId);

  void nodeModified(NodeItem* node);

  void transitionSelected(TransitionItem* transtion);

  void createEvent(NodeItem* node);

  void openFlow(Flow* flow, const QString& nodeId, const maki::FocusProperties& properties);

  void flowAdded(Flow* flow, NodeItem* node);

  void flowRemoved(const QString& flowId, NodeItem* node);
 
public slots:
  void onFocusNode(const QString& flowId, const QString& nodeId, const maki::FocusProperties& properties);

  void onRemoveNode(const QString& flowId, const QString& nodeId);

  void onFlowSelected(const QString& flowId, const QString& nodeId);

  void onFlowRemoved(const QString& flowId, const QString& nodeId);
 
protected:
  std::shared_ptr<ConfigurationTable> mConfigTable;  
  std::shared_ptr<EdgeRouter> mRouter;               
  QUndoStack* mUndoStack = nullptr;                  
 
  std::shared_ptr<NodeConfig> getNodeConfig(const QString& key) const;
  virtual void addedItemNode(NodeItem* node, std::shared_ptr<NodeSaveInfo> info);
  virtual void addedItemFlow(Flow* flow, NodeItem* node);
  virtual void onNodeHovered(NodeItem* node, bool entered);
  virtual void addTransition(TransitionItem* transition);
  virtual void removeTransition(TransitionItem* transition);
  virtual bool canAddTransition(NodeItem* node) const;
  virtual TransitionConfig nextTransition(NodeItem* node) const;
  virtual QVector<TransitionSaveInfo> transitionsOfNode(const QString& nodeId);
  virtual QVector<QGraphicsItem*> cleanTransitionsOfNode(const QString& nodeId);
  virtual void onNodeMoved(const NodeItem* node);
  virtual void showSimulationControls(NodeItem* node, maki::ControlWidget* controls, const QColor& highlightColor);
 
  virtual bool insertDroppedNodeOnTransition(TransitionItem* transition, std::shared_ptr<NodeSaveInfo> info);

  NodeItem* createNode(NodeCreation creation, std::shared_ptr<NodeSaveInfo> info, const QPointF& position, NodeItem* parent);

  CanvasView* parentView() const;
 
private:
  NodeItem* mHoveredNode = nullptr;       
  TransitionItem* mTransition = nullptr;  
  NodeItem* mNode = nullptr;              
  QPointF mStartDragPosition;             
  bool mDragging = false;                 
  bool mMouseDown = false;                
 
  QPointF mSelectionStart;
  QGraphicsRectItem* mSelectionRect = nullptr;
 
  const QString mId;  
 
  QList<CopiedNode> mCopiedNodes;   
  QList<NodeItem*> mSelectedNodes;  
 
  NodeItem* mSuggestionSourceNode = nullptr;
  QTimer* mSuggestionHideTimer = nullptr;
 
  void createSuggestedNode(const QString& nodeType, NodeItem* sourceNode);

  void clearCanvas();

  void selectNode(NodeItem* node, bool select);

  NodeItem* findNodeWithId(const QString& id) const;
  TransitionItem* findTransitionWithId(const QString& id) const;

  QList<NodeItem*> selectedNodes() const;

  void alignNodesHorizontally(const QList<Types::AlignmentNode>& items, Types::AlignmentDirection direction);

  void alignNodesVertically(const QList<Types::AlignmentNode>& items, Types::AlignmentDirection direction);
 
  // Context menu
  void createAlignMenu(QMenu* alignMenu, const QList<Types::AlignmentNode>& items);  
 
  QVector<QGraphicsItem*> removeNode(NodeItem* node);  
 
  void clearSelectedNodes();                                                           
  bool isModifierSet(QGraphicsSceneMouseEvent* event, Qt::KeyboardModifier modifier);  
 
  bool nodeClickHandler(QGraphicsSceneMouseEvent* event, QGraphicsItem* item);        
  bool transitionClickHandler(QGraphicsSceneMouseEvent* event, QGraphicsItem* item);  
 
  void createNodeContextMenu(QMenu* menu, NodeItem* node, const QList<NodeItem*>& items);  
  void createTransitionContextMenu(QMenu* menu, const QList<NodeItem*>& items);            
 
  bool isParentSelected(NodeItem* node);  
  void pasteCopiedItems(const QPointF& mousePosition, NodeItem* parentNode, QList<CopiedNode> nodes,
                        bool relative);  
 
  VoidResult loadFromSave(const QVector<std::shared_ptr<INode>>& nodes, NodeItem* parent);  
 
  void onSelectionChanged();
 
  TransitionItem* transitionAt(const QPointF& scenePos) const;
  void updateCapabilityDropPreview(const QPointF& scenePos);
};
 
inline QDataStream& operator<<(QDataStream& out, const Canvas::CopiedNode& node)
{
  out << node.info;
  out << node.posRelativeToMouse;
  return out;
}
 
inline QDataStream& operator>>(QDataStream& in, Canvas::CopiedNode& node)
{
  in >> node.info;
  in >> node.posRelativeToMouse;
  return in;
}