automation_tracklist.h

// SPDX-FileCopyrightText: © 2018-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/tracks/automation_track.h"
 
#include <QAbstractListModel>
 
namespace zrythm::structure::tracks
{
static constexpr int DEFAULT_AUTOMATION_TRACK_HEIGHT = 48;
static constexpr int MIN_AUTOMATION_TRACK_HEIGHT = 26;
 
class AutomationTracklist;

class AutomationTrackHolder : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (double height READ height WRITE setHeight NOTIFY heightChanged)
  Q_PROPERTY (bool visible READ visible WRITE setVisible NOTIFY visibleChanged)
  Q_PROPERTY (
    bool createdByUser READ createdByUser WRITE setCreatedByUser NOTIFY
      createdByUserChanged)
  Q_PROPERTY (
    zrythm::structure::tracks::AutomationTrack * automationTrack READ
      automationTrack CONSTANT)
  QML_UNCREATABLE ("")
 
public:
  struct Dependencies
  {
    const dsp::TempoMapWrapper &tempo_map_;
    utils::IObjectRegistry     &registry_;
  };
 
  AutomationTrackHolder (Dependencies dependencies, QObject * parent = nullptr)
      : QObject (parent), dependencies_ (dependencies)
  {
  }
  AutomationTrackHolder (
    Dependencies                               dependencies,
    utils::QObjectUniquePtr<AutomationTrack> &&at,
    QObject *                                  parent = nullptr)
      : AutomationTrackHolder (dependencies, parent)
  {
    automation_track_ = std::move (at);
    automation_track_->setParent (this);
  }
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  double height () const { return height_; }
  void   setHeight (double height)
  {
    height =
      std::max (height, static_cast<double> (MIN_AUTOMATION_TRACK_HEIGHT));
    if (qFuzzyCompare (height, height_))
      return;
 
    height_ = height;
    Q_EMIT heightChanged (height);
  }
  Q_SIGNAL void heightChanged (double height);
 
  bool visible () const { return visible_; }
  void setVisible (bool visible)
  {
    assert (created_by_user_);
    if (visible == visible_)
      return;
 
    visible_ = visible;
    Q_EMIT visibleChanged (visible);
  }
  Q_SIGNAL void visibleChanged (bool visible);
 
  bool createdByUser () const { return created_by_user_; }
  void setCreatedByUser (bool created)
  {
    if (created == created_by_user_)
      return;
 
    created_by_user_ = created;
    Q_EMIT createdByUserChanged (created);
  }
  Q_SIGNAL void createdByUserChanged (bool created);
 
  AutomationTrack * automationTrack () const
  {
    return automation_track_.get ();
  }
 
  // ========================================================================
 
public:
  bool created_by_user_{};
 
private:
  Dependencies dependencies_;
 
  utils::QObjectUniquePtr<AutomationTrack> automation_track_;

  bool visible_{};

  double height_{ DEFAULT_AUTOMATION_TRACK_HEIGHT };
 
private:
  static constexpr auto kAutomationTrackKey = "automationTrack"sv;
  static constexpr auto kCreatedByUserKey = "createdByUser"sv;
  static constexpr auto kVisible = "visible"sv;
  static constexpr auto kHeightKey = "height"sv;
  friend void to_json (nlohmann::json &j, const AutomationTrackHolder &nfo);
  friend void from_json (const nlohmann::json &j, AutomationTrackHolder &nfo);
};

class AutomationTracklist : public QAbstractListModel
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (
    bool automationVisible READ automationVisible WRITE setAutomationVisible
      NOTIFY automationVisibleChanged)
  QML_UNCREATABLE ("")
 
public:
  AutomationTracklist (
    AutomationTrackHolder::Dependencies dependencies,
    QObject *                           parent = nullptr);
 
public:
  enum Roles
  {
    AutomationTrackHolderRole = Qt::UserRole + 1,
    AutomationTrackRole,
  };
 
  // ========================================================================
  // QML Interface
  // ========================================================================
  QHash<int, QByteArray> roleNames () const override;
  int rowCount (const QModelIndex &parent = QModelIndex ()) const override;
  QVariant
  data (const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
  Q_INVOKABLE void
  showNextAvailableAutomationTrack (AutomationTrack * current_automation_track);
  Q_INVOKABLE void
  hideAutomationTrack (AutomationTrack * current_automation_track);
 
  bool          automationVisible () const { return automation_visible_; }
  void          setAutomationVisible (bool visible);
  Q_SIGNAL void automationVisibleChanged (bool visible);
 
  // ========================================================================
 
  friend void init_from (
    AutomationTracklist       &obj,
    const AutomationTracklist &other,
    utils::ObjectCloneType     clone_type);

  AutomationTrack *
  add_automation_track (utils::QObjectUniquePtr<AutomationTrack> &&at);
 
  AutomationTrack *
  add_automation_track (utils::QObjectUniquePtr<AutomationTrackHolder> &&ath);
 
  AutomationTrack * automation_track_at (size_t index) const
  {
    return automation_tracks_.at (index)->automationTrack ();
  }

  AutomationTrack *
  get_visible_automation_track_after_delta (const AutomationTrack &at, int delta)
    const;
 
  int get_visible_automation_track_count_between (
    const AutomationTrack &src,
    const AutomationTrack &dest) const;

  utils::QObjectUniquePtr<AutomationTrackHolder>
  remove_automation_track (AutomationTrack &at);

  void clear_arranger_objects ();

   * automation track.
   */
  static int get_y_px_from_normalized_val (
    const double automation_track_height,
    const float  normalized_val)
  {
    return static_cast<int> (
      automation_track_height - (normalized_val * automation_track_height));
  }

  void
  set_automation_track_index (AutomationTrack &at, int index, bool push_down);

  AutomationTrackHolder * get_first_invisible_automation_track_holder () const;
 
  auto &automation_track_holders () const { return automation_tracks_; }
 
  auto automation_tracks () const
  {
    return std::views::transform (
      automation_track_holders (),
      [] (const auto &th) { return th->automationTrack (); });
  }
 
  AutomationTrack *
  get_previous_visible_automation_track (const AutomationTrack &at) const;
 
  AutomationTrack *
  get_next_visible_automation_track (const AutomationTrack &at) const;
 
private:
  static constexpr auto kAutomationTracksKey = "automationTracks"sv;
  static constexpr auto kAutomationVisibleKey = "automationVisible"sv;
  friend void to_json (nlohmann::json &j, const AutomationTracklist &ats);
  friend void from_json (const nlohmann::json &j, AutomationTracklist &ats);
 
  auto &automation_track_holders () { return automation_tracks_; }
  auto  get_iterator_for_automation_track (const AutomationTrack &at) const
  {
    auto it = std::ranges::find (
      automation_track_holders (), &at,
      [&] (const auto &ath) { return ath->automationTrack (); });
    if (it == automation_track_holders ().end ())
      {
        throw std::runtime_error ("Automation track not found");
      }
    return it;
  }
  auto get_iterator_for_automation_track (const AutomationTrack &at)
  {
    auto it = std::ranges::find (
      automation_track_holders (), &at,
      [&] (const auto &ath) { return ath->automationTrack (); });
    if (it == automation_track_holders ().end ())
      {
        throw std::runtime_error ("Automation track not found");
      }
    return it;
  }
  int get_automation_track_index (const AutomationTrack &at) const
  {
    return static_cast<int> (std::distance (
      automation_track_holders ().begin (),
      get_iterator_for_automation_track (at)));
  }
 
private:
  AutomationTrackHolder::Dependencies dependencies_;

  std::vector<utils::QObjectUniquePtr<AutomationTrackHolder>> automation_tracks_;

  bool automation_visible_{};
 
  BOOST_DESCRIBE_CLASS (
    AutomationTracklist,
    (),
    (),
    (),
    (automation_tracks_, automation_visible_))
};
 
}