NodalIntervalView.hpp

#pragma once
#include <Process/Dataflow/NodeItem.hpp>
 
#include <Scenario/Document/ScenarioDocument/ScenarioDocumentViewConstants.hpp>
 
#include <score/graphics/RectItem.hpp>
 
#include <QPointer>
#include <QRectF>
 
#include <score_plugin_scenario_export.h>
 
class QGraphicsRectItem;
 
#include <nano_observer.hpp>
 
namespace Scenario
{
class IntervalModel;
class SCORE_PLUGIN_SCENARIO_TEST_EXPORT NodalIntervalView final
    : public score::EmptyRectItem
    , public Nano::Observer
{
  W_OBJECT(NodalIntervalView)
public:
  enum ItemsToShow
  {
    AllItems,
    OnlyEffects
  };
  NodalIntervalView(
      ItemsToShow sh, const IntervalModel& model, const Process::Context& ctx,
      QGraphicsItem* parent);
 
  ~NodalIntervalView();
 
  void on_drop(QPointF pos, const QMimeData* data);
  void on_playPercentageChanged(double t, TimeVal parent_dur);
 
  void recenter();
  void recenterRelativeToView();
  void panBy(QPointF delta);
  void rescale();
  void zoomPlus();
  void zoomMinus();
  void zoomTo(double newZoomLevel);
  void reveal(const Process::NodeItem& item);
  QRectF enclosingRect() const noexcept;
 
  QGraphicsItem& nodeContainer() const noexcept { return *m_container; }
  double zoom() const noexcept { return m_container->transform().m11(); }
  const IntervalModel& model() const noexcept { return m_model; }
 
  QPointF pastePosition(QPointF scenePos) const;
  int type() const override { return ItemType::Type::NodalIntervalView; }
 
  void openProcessPicker(QPointF nodePos);
 
private:
  void setZoom(double z);
  void setupNode(Process::NodeItem* item);
  void showNode(const Process::NodeItem& item);
  void updateSelectionRectStyle();
  void on_processAdded(const Process::ProcessModel& proc);
  void on_processRemoving(const Process::ProcessModel& model);
  void on_zoomRatioChanged(ZoomRatio ratio);
  void on_dropOnNode(const QPointF& pt, const QMimeData& mime);
 
  QRectF visibleRect() const;
  QPointF viewportCenter() const;
  void pickInitialViewport();
  void placeContainer(QPointF center);
  void storeCenterFromContainer();
 
  void dragEnterEvent(QGraphicsSceneDragDropEvent* event) override;
  void dragLeaveEvent(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 mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) override;
  void contextMenuEvent(QGraphicsSceneContextMenuEvent* event) override;
  void wheelEvent(QGraphicsSceneWheelEvent* event) override;
 
  const IntervalModel& m_model;
  const Process::Context& m_context;
  ItemsToShow m_itemsToShow{};
  std::vector<Process::NodeItem*> m_nodeItems;
  QGraphicsItem* m_container{};
  QGraphicsRectItem* m_selectionRect{};
  QPointF m_pressedPos{};
  double m_zoomLevel = 0;
 
  QPointF m_rubberBandOrigin{};
  QRectF m_rubberBandRect{};
  bool m_rubberBanding{false};
  bool m_autoCenter{false};
  QPointer<Process::NodeItem> m_nodeToShow;
  bool m_dropping{false};
};
 
SCORE_PLUGIN_SCENARIO_EXPORT bool revealInNodalView(const QGraphicsItem& item);
}