track_lane_list.h

// SPDX-FileCopyrightText: © 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/tracks/track_lane.h"
#include "utils/expandable_tick_range.h"
#include "utils/qt.h"
 
namespace zrythm::structure::tracks
{
class TrackLaneList : public QAbstractListModel
{
  Q_OBJECT
  Q_PROPERTY (
    bool lanesVisible READ lanesVisible WRITE setLanesVisible NOTIFY
      lanesVisibleChanged)
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  enum Roles
  {
    TrackLanePtrRole = Qt::UserRole + 1,
  };
  Q_ENUM (Roles)
 
public:
  TrackLaneList (
    structure::arrangement::ArrangerObjectRegistry &obj_registry,
    dsp::FileAudioSourceRegistry                   &file_audio_source_registry,
    QObject *                                       parent = nullptr);
  ~TrackLaneList () override;
  Q_DISABLE_COPY_MOVE (TrackLaneList)
 
  // ========================================================================
  // 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 TrackLane * getFirstLane () const
  {
    return lanes_.front ().get ();
  }
 
  bool lanesVisible () const { return lanes_visible_; }
  void setLanesVisible (bool visible)
  {
    if (lanes_visible_ == visible)
      return;
 
    lanes_visible_ = visible;
    Q_EMIT lanesVisibleChanged (visible);
  }
  Q_SIGNAL void lanesVisibleChanged (bool visible);

  Q_INVOKABLE TrackLane * addLane () { return insertLane (rowCount ()); }
  Q_INVOKABLE TrackLane * insertLane (size_t index);
  Q_INVOKABLE void        removeLane (size_t index);
 
  Q_INVOKABLE void moveLane (size_t from_index, size_t to_index);
 
  Q_SIGNAL void
  laneObjectsNeedRecache (utils::ExpandableTickRange affectedRange);
 
  Q_SIGNAL void totalHeightChanged ();
 
  // ========================================================================
 
  [[nodiscard]] size_t size () const noexcept { return lanes_.size (); }
 
  [[nodiscard]] bool empty () const noexcept { return lanes_.empty (); }
 
  TrackLane * at (size_t idx) const { return lanes_.at (idx).get (); }

  utils::QObjectUniquePtr<TrackLane> pop_back ();
 
  void clear ();
 
  auto &lanes () const { return lanes_; }
 
  auto lanes_view () const
  {
    return lanes_
           | std::views::transform (&utils::QObjectUniquePtr<TrackLane>::get);
  }

   * @brief Gets the total height of all visible lanes (if any).
   */
  double get_visible_lane_heights () const
  {
    if (!lanes_visible_)
      return 0;
 
    return std::ranges::fold_left (
      lanes_view () | std::views::transform (&TrackLane::height), 0,
      std::plus{});
  }

  void create_missing_lanes (size_t index);

  void remove_empty_last_lanes ();
 
private:
  static constexpr auto             kLanesKey = "lanes"sv;
  static constexpr std::string_view kLanesVisibleKey = "lanesVisible";
  friend void to_json (nlohmann::json &j, const TrackLaneList &p);
  friend void from_json (const nlohmann::json &j, TrackLaneList &p);
 
  void erase (size_t pos);
 
  void update_default_lane_names ();
 
private:
  TrackLane::TrackLaneDependencies                dependencies_;
  std::vector<utils::QObjectUniquePtr<TrackLane>> lanes_;

  bool lanes_visible_ = false;
 
  BOOST_DESCRIBE_CLASS (TrackLaneList, (), (), (), (lanes_, lanes_visible_))
};
}