tracklist.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/arrangement/arranger_object.h"
#include "structure/tracks/singleton_tracks.h"
#include "structure/tracks/track.h"
#include "structure/tracks/track_collection.h"
#include "structure/tracks/track_routing.h"
#include "structure/tracks/track_span.h"
 
#include <QtQmlIntegration/qqmlintegration.h>
 
namespace zrythm::structure::tracks
{

class Tracklist : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (
    zrythm::structure::tracks::TrackRouting * trackRouting READ trackRouting
      CONSTANT)
  Q_PROPERTY (
    zrythm::structure::tracks::SingletonTracks * singletonTracks READ
      singletonTracks CONSTANT)
  Q_PROPERTY (
    zrythm::structure::tracks::TrackCollection * collection READ collection
      CONSTANT)
  Q_PROPERTY (
    int pinnedTracksCutoff READ pinnedTracksCutoff WRITE setPinnedTracksCutoff
      NOTIFY pinnedTracksCutoffChanged)
  QML_UNCREATABLE ("")
 
public:
  using ArrangerObjectPtrVariant = arrangement::ArrangerObjectPtrVariant;
  using ArrangerObject = arrangement::ArrangerObject;
 
public:
  explicit Tracklist (TrackRegistry &track_registry, QObject * parent = nullptr);
  Z_DISABLE_COPY_MOVE (Tracklist)
  ~Tracklist () override;
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  TrackCollection * collection () const { return track_collection_.get (); }
 
  SingletonTracks * singletonTracks () const
  {
    return singleton_tracks_.get ();
  }
 
  Q_INVOKABLE Track * getTrackForTimelineObject (
    const arrangement::ArrangerObject * timelineObject) const;
  Q_INVOKABLE TrackLane * getTrackLaneForObject (
    const arrangement::ArrangerObject * timelineObject) const;
 
  Q_INVOKABLE bool isTrackPinned (const Track * track) const
  {
    return is_track_pinned (track->get_uuid ());
  }
 
  Q_INVOKABLE bool shouldBeVisible (const Track * track) const
  {
    return should_be_visible (track->get_uuid ());
  }
 
  Q_INVOKABLE bool hasChannel (const Track * track) const
  {
    return track->channel () != nullptr;
  }
 
  TrackRouting * trackRouting () const { return track_routing_.get (); }
 
  int  pinnedTracksCutoff () const { return pinned_tracks_cutoff_; }
  void setPinnedTracksCutoff (int index)
  {
    if (index == pinned_tracks_cutoff_)
      return;
 
    pinned_tracks_cutoff_ = index;
    Q_EMIT pinnedTracksCutoffChanged (index);
  }
  Q_SIGNAL void pinnedTracksCutoffChanged (int index);
 
  // ========================================================================
 
  friend void init_from (
    Tracklist             &obj,
    const Tracklist       &other,
    utils::ObjectCloneType clone_type);
 
  std::optional<TrackPtrVariant> get_track (const TrackUuid &id) const
  {
    auto span = collection ()->get_track_span ();
    auto it = std::ranges::find (span, id, TrackSpan::uuid_projection);
    if (it == span.end ()) [[unlikely]]
      {
        return std::nullopt;
      }
    return std::make_optional (*it);
  }

  std::optional<TrackPtrVariant>
  get_visible_track_after_delta (Track::Uuid track_id, int delta) const;

  bool multiply_track_heights (
    double multiplier,
    bool   visible_only,
    bool   check_only,
    bool   fire_events);

  void handle_click (TrackUuid track_id, bool ctrl, bool shift, bool dragged);
 
  std::vector<ArrangerObjectPtrVariant> get_timeline_objects () const;

  void
  clear_selections_for_object_siblings (const ArrangerObject::Uuid &object_id);
 
  std::optional<TrackUuidReference>
  get_track_for_plugin (const plugins::Plugin::Uuid &plugin_id) const;

   */
  bool should_be_visible (const Track::Uuid &track_id) const;


  bool is_track_pinned (int index) const
  {
    return index < pinned_tracks_cutoff_;
  }
 
  bool is_track_pinned (Track::Uuid track_id) const
  {
    return is_track_pinned (
      static_cast<int> (collection ()->get_track_index (track_id)));
  }
 
  auto get_track_route_target (const TrackUuid &source_track) const
  {
    return track_routing_->get_output_track (source_track);
  }

  void mark_track_for_bounce (
    TrackPtrVariant track_var,
    bool            bounce,
    bool            mark_regions,
    bool            mark_children,
    bool            mark_parents);
 
private:
  static constexpr auto kPinnedTracksCutoffKey = "pinnedTracksCutoff"sv;
  static constexpr auto kTracksKey = "tracks"sv;
  friend void           to_json (nlohmann::json &j, const Tracklist &t);
  friend void           from_json (const nlohmann::json &j, Tracklist &t);
 
private:
  auto &get_track_registry () const { return track_registry_; }
  auto &get_track_registry () { return track_registry_; }
 
private:
  TrackRegistry &track_registry_;

  utils::QObjectUniquePtr<TrackCollection> track_collection_;
 
  utils::QObjectUniquePtr<TrackRouting> track_routing_;
 
  utils::QObjectUniquePtr<SingletonTracks> singleton_tracks_;

  int pinned_tracks_cutoff_ = 0;
};
}