laned_track.h

// SPDX-FileCopyrightText: © 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/arrangement/audio_region.h"
#include "structure/arrangement/midi_region.h"
#include "structure/tracks/track.h"
#include "structure/tracks/track_lane.h"
#include "structure/tracks/track_lane_list.h"
 
#define DEFINE_LANED_TRACK_QML_PROPERTIES(ClassType) \
public: \
  /* ================================================================ */ \
  /* lanesVisible */ \
  /* ================================================================ */ \
  Q_PROPERTY ( \
    bool lanesVisible READ getLanesVisible WRITE setLanesVisible NOTIFY \
      lanesVisibleChanged) \
  bool getLanesVisible () 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); \
\
  /* ================================================================ */ \
  /* lanes */ \
  /* ================================================================ */ \
  Q_PROPERTY (TrackLaneList * lanes READ getLanes CONSTANT) \
  TrackLaneList * getLanes () const \
  { \
    return const_cast<TrackLaneList *> (&lanes_); \
  }
 
namespace zrythm::structure::tracks
{
class LanedTrack : virtual public Track
{
public:
  ~LanedTrack () noexcept override = default;

  void set_lanes_visible (bool visible);
 
protected:
  LanedTrack () noexcept { }
 
public:
  bool lanes_visible_ = false;

  int last_lane_idx_ = 0;

  int last_lane_created_ = 0;

  bool block_auto_creation_and_deletion_ = false;
};

template <typename TrackLaneT> class LanedTrackImpl : public LanedTrack
{
public:
  using RegionT = typename TrackLaneT::RegionT;
  using TrackLaneType = TrackLaneT;
 
  LanedTrackImpl ();
 
  ~LanedTrackImpl () override = default;

  bool create_missing_lanes (int pos);

  void remove_empty_last_lanes ();

  bool has_soloed_lanes () const
  {
    return std::ranges::any_of (lanes_, [] (const auto &lane) {
      return std::get<TrackLaneT *> (lane)->get_soloed ();
    });
  }

  double get_visible_lane_heights () const;

  void generate_lanes () { add_lane (); }
 
  void clear_objects () override;
 
  void get_regions_in_range (
    std::vector<arrangement::ArrangerObjectUuidReference> &regions,
    std::optional<signed_frame_t>                          p1,
    std::optional<signed_frame_t>                          p2) override;
 
  int get_lane_index (const TrackLaneT &lane) const
  {
    return std::ranges::find_if (
             lanes_.lanes_,
             [&] (const auto &lane_var) {
               return std::get<TrackLaneT *> (lane_var) == std::addressof (lane);
             })
           - lanes_.begin ();
  }
 
  TrackLaneT &get_lane_at (const size_t index)
  {
    return *std::get<TrackLaneT *> (lanes_.at (index));
  }
 
protected:
  friend void init_from (
    LanedTrackImpl        &obj,
    const LanedTrackImpl  &other,
    utils::ObjectCloneType clone_type)
  {
    init_from (obj.lanes_, other.lanes_, clone_type);
    for (auto &lane_var : obj.lanes_)
      {
        auto lane = std::get<TrackLaneT *> (lane_var);
        lane->track_ = &obj;
      }
    obj.lanes_visible_ = other.lanes_visible_;
  }
 
  void set_playback_caches () override;
 
private:
  static constexpr std::string_view kLanesVisibleKey = "lanesVisible";
  static constexpr std::string_view kLanesListKey = "lanesList";
  friend void to_json (nlohmann::json &j, const LanedTrackImpl &track)
  {
    j[kLanesVisibleKey] = track.lanes_visible_;
    j[kLanesListKey] = track.lanes_;
  }
  friend void from_json (const nlohmann::json &j, LanedTrackImpl &track)
  {
    j.at (kLanesVisibleKey).get_to (track.lanes_visible_);
    j.at (kLanesListKey).get_to (track.lanes_);
  }
 
  void add_lane ();
 
public:
  TrackLaneList lanes_;

  std::vector<std::unique_ptr<TrackLaneT>> lane_snapshots_;
 
  static_assert (TrackLaneSubclass<TrackLaneT>);
};
 
using LanedTrackVariant = std::variant<MidiTrack, InstrumentTrack, AudioTrack>;
using LanedTrackPtrVariant = to_pointer_variant<LanedTrackVariant>;
 
extern template class LanedTrackImpl<MidiLane>;
extern template class LanedTrackImpl<AudioLane>;
 
}