automation_clip_canvas_item.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <optional>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "gui/qquick/clip_canvas_item_base.h"
#include "structure/arrangement/automation_clip.h"
 
#include <QColor>
#include <QItemSelectionModel>
#include <QPointer>
 
namespace zrythm::gui::qquick
{
 
class AutomationClipCanvasRenderer;
 
class AutomationClipCanvasItem : public ClipCanvasItemBase
{
  Q_OBJECT
  QML_NAMED_ELEMENT (AutomationClipCanvas)
 
  Q_PROPERTY (
    zrythm::structure::arrangement::AutomationClip * automationClip READ
      automationClip WRITE setAutomationClip NOTIFY automationClipChanged)
  Q_PROPERTY (
    QColor curveColor READ curveColor WRITE setCurveColor NOTIFY
      curveColorChanged)
  Q_PROPERTY (
    QItemSelectionModel * selectionModel READ selectionModel WRITE
      setSelectionModel NOTIFY selectionModelChanged)
  Q_PROPERTY (
    bool dragActive READ dragActive WRITE setDragActive NOTIFY dragActiveChanged)
  Q_PROPERTY (
    qreal dragDeltaPx READ dragDeltaPx WRITE setDragDeltaPx NOTIFY
      dragDeltaPxChanged)
  Q_PROPERTY (
    qreal dragDeltaY READ dragDeltaY WRITE setDragDeltaY NOTIFY dragDeltaYChanged)
  Q_PROPERTY (
    bool drawPoints READ drawPoints WRITE setDrawPoints NOTIFY drawPointsChanged)
  Q_PROPERTY (
    bool applyLoops READ applyLoops WRITE setApplyLoops NOTIFY applyLoopsChanged)
  Q_PROPERTY (
    qreal hoveredX READ hoveredX WRITE setHoveredX NOTIFY hoveredXChanged)
  Q_PROPERTY (qreal contentWidth READ contentWidth NOTIFY contentWidthChanged)
  Q_PROPERTY (
    qreal contentLeftMargin READ contentLeftMargin NOTIFY
      contentLeftMarginChanged)
public:
  explicit AutomationClipCanvasItem (QQuickItem * parent = nullptr);
 
  QCanvasPainterItemRenderer * createItemRenderer () const override;
 
  structure::arrangement::AutomationClip * automationClip () const
  {
    return automation_clip_;
  }
  void setAutomationClip (structure::arrangement::AutomationClip * clip);
 
  QColor curveColor () const { return curve_color_; }
  void   setCurveColor (const QColor &color);
 
  QItemSelectionModel * selectionModel () const { return selection_model_; }
  void                  setSelectionModel (QItemSelectionModel * model);
 
  bool  dragActive () const { return drag_active_; }
  void  setDragActive (bool active);
  qreal dragDeltaPx () const { return drag_delta_px_; }
  void  setDragDeltaPx (qreal px);
  qreal dragDeltaY () const { return drag_delta_y_; }
  void  setDragDeltaY (qreal dy);

  bool drawPoints () const { return draw_points_; }
  void setDrawPoints (bool draw);

  bool applyLoops () const { return apply_loops_; }
  void setApplyLoops (bool apply);

  qreal hoveredX () const { return hovered_x_; }
  void  setHoveredX (qreal x);

  qreal contentWidth () const;

  qreal contentLeftMargin () const;

  std::unordered_set<structure::arrangement::ArrangerObject::Uuid>
  draggedUuids () const;

  Q_INVOKABLE structure::arrangement::AutomationPoint *
              segmentHitTest (qreal x, qreal y, qreal tolerance) const;
 
Q_SIGNALS:
  void automationClipChanged ();
  void curveColorChanged ();
  void selectionModelChanged ();
  void dragActiveChanged ();
  void dragDeltaPxChanged ();
  void dragDeltaYChanged ();
  void drawPointsChanged ();
  void applyLoopsChanged ();
  void hoveredXChanged ();
  void contentWidthChanged ();
  void contentLeftMarginChanged ();
 
private:
  std::pair<double, double> computeEffectiveBounds () const;

  void invalidateBounds ();
 
private:
  QPointer<structure::arrangement::AutomationClip> automation_clip_;
  QColor                                           curve_color_;
  QPointer<QItemSelectionModel>                    selection_model_;
  bool                                             drag_active_ = false;
  qreal                                            drag_delta_px_ = 0.0;
  qreal                                            drag_delta_y_ = 0.0;
  bool                                             draw_points_ = false;
  bool                                             apply_loops_ = true;
  qreal                                            hovered_x_ = -1.0;
  std::vector<QMetaObject::Connection>             clip_connections_;
  mutable std::optional<std::pair<double, double>> cached_bounds_;
};
 
} // namespace zrythm::gui::qquick