node.h

#pragma once
 
#include <QBrush>
#include <QDataStream>
#include <QGraphicsEllipseItem>
#include <QGraphicsItem>
#include <memory>
 
#include "config.h"
#include "control_widget.h"
#include "node_base.h"
#include "save_info.h"
#include "transition.h"
#include "types.h"
#include "widgets/controls/canvas_control_widget.h"
 
class Flow;
class CanvasMessage;
class QGraphicsSceneMouseEvent;
class QGraphicsSceneHoverEvent;

class NodeItem : public NodeBase
{
public:
  enum
  {
    Type = Types::NODE
  };

  NodeItem(const QString& id, std::shared_ptr<NodeSaveInfo> info, const QPointF& initialPosition, std::shared_ptr<NodeConfig> nodeConfig,
           QGraphicsItem* parent = nullptr);

  virtual ~NodeItem();

  int type() const override;

  VoidResult start() override;

  QRectF nodeRect() const override;
  QRectF sceneNodeRect() const;
 
  bool hasControl();
 
  template <typename T>
  bool hasControl()
  {
    return mControlActive && mControlWidget && qobject_cast<T*>(mControlWidget->controlWidget()) != nullptr;
  }
 
  void highlight(const QColor& color, const QString& message, int durationMs = 1000);
  void dismissHighlight();
 
  void showSimulationControls(maki::ControlWidget* controls, const QColor& highlightColor);
  void showControls(maki::ControlWidget* controls, const ControlProperties& properties);
  void dismissControl();
  void hideControl();

  QPainterPath shape() const override;

  void paint(QPainter* painter, const QStyleOptionGraphicsItem* style, QWidget* widget) override;

  HelpConfig help() const;

  QString nodeName() const;

  QString nodeType() const;

  QString behaviour() const;

  QVector<ControlsConfig> controls() const;

  QVector<std::shared_ptr<IParameter>> properties() const;

  QVector<PropertyConfig> configurationProperties() const;

  Types::LibraryTypes function() const;

  const PropertyInfo* getProperty(const QString& key) const;

  void setProperty(const QString& key, const maki::Value& value);

  void renameNode(const QString& name);

  NodeItem* parentNode() const;

  QVector<NodeItem*> children() const;

  QPointF edgePointToward(const QPointF& targetScenePos) const;

  QVector<std::shared_ptr<IParameter>> fields() const;

  PropertyInfo getField(const QString& key) const;

  VoidResult setField(const QString& key, const QJsonObject& property);

  VoidResult setField(const QString& key, std::shared_ptr<PropertyInfo> property);

  void removeField(const QString& key);

  void setEvent(int index, const FlowConfig& event);

  QVector<std::shared_ptr<IFlow>> flowConfigs() const;
 
  QVector<std::shared_ptr<IFlow>> eventConfigs() const;
 
  QVector<std::shared_ptr<IFlow>> allEventFlowConfigs() const;

  void addParent(NodeItem* node);

  void addChild(NodeItem* node, std::shared_ptr<NodeSaveInfo> info);

  void childRemoved(NodeItem* child);

  QVector<Flow*> flows() const;

  Flow* createFlow(const QString& flowName, std::shared_ptr<FlowSaveInfo> info);

  Flow* getFlow(const QString& flowId) const;

  void deleteFlow(const QString& flowId);

  void updateFlow();

  qreal baseScale() const;

  QVector<TransitionConfig> configTransitions() const;

  void applySize(const QSizeF& size);

  void updatePosition(const QPointF& position);
 
  // "signals":
  std::function<void(NodeItem* item)> nodeModified;
  std::function<void(Flow* flow, NodeItem* item)> flowAdded;
  std::function<void(NodeItem* item)> nodeMoved;
  std::function<void(NodeItem* item, bool enter)> nodeHovered;
 
  // "slots":
  void onProperties();
 
  // Serialization functions

  NodeSaveInfo saveInfo() const;
  friend QDataStream& operator<<(QDataStream& out, const NodeItem& config);

  friend QDataStream& operator>>(QDataStream& in, NodeItem& config);
 
protected:
  void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override;

  void mousePressEvent(QGraphicsSceneMouseEvent* event) override;

  void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) override;
 
  void hoverEnterEvent(QGraphicsSceneHoverEvent* event) override;
  void hoverLeaveEvent(QGraphicsSceneHoverEvent* event) override;

  QVariant itemChange(GraphicsItemChange change, const QVariant& value) override;
 
private:
  std::shared_ptr<NodeSaveInfo> mStorage;  
 
  QVector<Flow*> mFlows;              
  NodeItem* mParentNode;              
  QVector<NodeItem*> mChildrenNodes;  
  CanvasMessage* mHighlightMessage = nullptr;
  CanvasControlWidget* mControlWidget = nullptr;
  bool mControlActive = false;
 
  qreal mBaseScale;             
  QSizeF mSize{0, 0};           
  QPointF mDragStartPos{0, 0};  
  QPointF mLastPosition{0, 0};  
 
  bool mIsResizing{false};             
  QPointF mResizeStartMousePos{0, 0};  
  QSizeF mResizeStartSize{0, 0};       

  void updateExtrasPosition();

  QSizeF clampSize(qreal width, qreal height) const;

  QPointF clampPosInside(const QRectF& inner, const QRectF& childSceneRect) const;

  void fitInsideParent(qreal padding);

  QRectF parentInnerSceneRect(qreal padding) const;
 
  void ensureMainFlowExists();
};