arranger_object.h

// SPDX-FileCopyrightText: © 2019-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __GUI_BACKEND_ARRANGER_OBJECT_H__
#define __GUI_BACKEND_ARRANGER_OBJECT_H__
 
#include "gui/backend/position_proxy.h"
#include "gui/dsp/arranger_object_fwd.h"
#include "gui/dsp/track_fwd.h"
 
#include <QtGlobal>
 
using namespace zrythm;
 
#define DEFINE_ARRANGER_OBJECT_QML_PROPERTIES(ClassType) \
public: \
  /* ================================================================ */ \
  /* type */ \
  /* ================================================================ */ \
  Q_PROPERTY (int type READ getType CONSTANT) \
  int getType () const \
  { \
    return ENUM_VALUE_TO_INT (get_type ()); \
  } \
  /* ================================================================ */ \
  /* hasLength */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool hasLength READ getHasLength CONSTANT) \
  bool getHasLength () const \
  { \
    return std::derived_from<ClassType, BoundedObject>; \
  } \
  /* ================================================================ */ \
  /* selected */ \
  /* ================================================================ */ \
  Q_PROPERTY (bool selected READ getSelected NOTIFY selectedChanged) \
  bool getSelected () const \
  { \
    if (selection_status_getter_) \
      { \
        return (*selection_status_getter_) (get_uuid ()); \
      } \
    return false; \
  } \
  Q_SIGNAL void selectedChanged (bool selected); \
  /* ================================================================ */ \
  /* position */ \
  /* ================================================================ */ \
  Q_PROPERTY (PositionProxy * position READ getPosition CONSTANT) \
  PositionProxy * getPosition () const \
  { \
    return pos_; \
  } \
  /* ================================================================ */ \
  /* misc. signals */ \
  /* ================================================================ */ \
  Q_SIGNAL void addedToProject (); \
  Q_SIGNAL void removedFromProject ();
 
#define DECLARE_FINAL_ARRANGER_OBJECT_CONSTRUCTORS(ClassType) \
public: \
  ClassType ( \
    ArrangerObjectRegistry &obj_registry, TrackResolver track_resolver, \
    QObject * parent = nullptr);

class ArrangerObject : public utils::UuidIdentifiableObject<ArrangerObject>
{
  Z_DISABLE_COPY_MOVE (ArrangerObject)
 
public:
  using SelectionStatusGetter = std::function<bool (const Uuid &)>;
 
  static constexpr double DEFAULT_NUDGE_TICKS = 0.1;

  enum class ResizeType
  {
    Normal,
    Loop,
    Fade,
    Stretch,

    StretchTempoChange,
  };

  enum class Type
  {
    MidiRegion,
    AudioRegion,
    ChordRegion,
    AutomationRegion,
    MidiNote,
    ChordObject,
    ScaleObject,
    Marker,
    AutomationPoint,
  };

  enum class Flags
  {
    NonProject = 1 << 0,

    // FLAG_SNAPSHOT = 1 << 1,
  };
 
  enum class PositionType
  {
    Start,
    End,
    ClipStart,
    LoopStart,
    LoopEnd,
    FadeIn,
    FadeOut,
  };
 
  using Position = zrythm::dsp::Position;
 
public:
  ~ArrangerObject () noexcept override = default;
 
  using ArrangerObjectPtr = ArrangerObject *;
 
  auto get_type () const { return type_; }

  virtual utils::Utf8String gen_human_friendly_name () const
  {
    /* this will be called if unimplemented - it's not needed for things like
     * Velocity, which don't have reasonable names. */
    z_return_val_if_reached ({});
  };

  bool is_start_hit_by_range (
    const dsp::Position &start,
    const dsp::Position &end,
    bool                 range_start_inclusive = true,
    bool                 range_end_inclusive = false) const
  {
    return is_start_hit_by_range (
      start.frames_, end.frames_, range_start_inclusive, range_end_inclusive);
  }

  bool is_start_hit_by_range (
    const signed_frame_t global_frames_start,
    const signed_frame_t global_frames_end,
    bool                 range_start_inclusive = true,
    bool                 range_end_inclusive = false) const
  {
    return (range_start_inclusive
              ? (pos_->frames_ >= global_frames_start)
              : (pos_->frames_ > global_frames_start))
           && (range_end_inclusive ? (pos_->frames_ <= global_frames_end) : (pos_->frames_ < global_frames_end));
  }

  void set_parent_on_base_qproperties (QObject &derived);

  auto get_position () const { return *static_cast<dsp::Position *> (pos_); };

  void position_setter_validated (
    const dsp::Position &pos,
    dsp::TicksPerFrame   ticks_per_frame);
 
  void set_position_unvalidated (const dsp::Position &pos)
  {
    // FIXME qobject updates...
    *static_cast<dsp::Position *> (pos_) = pos;
  }

  bool is_position_valid (
    const dsp::Position &pos,
    PositionType         pos_type,
    dsp::TicksPerFrame   ticks_per_frame) const;

  bool set_position (
    const dsp::Position &pos,
    PositionType         pos_type,
    bool                 validate,
    dsp::TicksPerFrame   ticks_per_frame);

  void move (double ticks, dsp::FramesPerTick frames_per_tick);
 
  void set_track_id (const TrackUuid &track_id) { track_id_ = track_id; }
  void set_track_id (std::optional<TrackUuid> track_id)
  {
    track_id_ = track_id;
  }
  void unset_track_id () { track_id_ = std::nullopt; }

  void update_positions (
    bool               from_ticks,
    bool               bpm_change,
    dsp::FramesPerTick frames_per_tick);

  [[gnu::hot]] auto get_track () const
  {
    assert (track_id_);
    return track_resolver_ (*track_id_);
  }
 
  std::optional<TrackUuid> get_track_id () const { return track_id_; }

  virtual bool
  validate (bool is_project, dsp::FramesPerTick frames_per_tick) const = 0;

  virtual ArrangerObjectPtrVariant
  add_clone_to_project (bool fire_events) const = 0;

  virtual ArrangerObjectPtrVariant insert_clone_to_project () const = 0;

  std::optional<ArrangerObjectPtrVariant>
  remove_from_project (bool free_obj, bool fire_events = false);
 
  void set_selection_status_getter (SelectionStatusGetter getter)
  {
    selection_status_getter_ = getter;
  }
  void unset_selection_status_getter () { selection_status_getter_.reset (); }

  virtual bool is_deletable () const { return true; };
 
  friend bool operator== (const ArrangerObject &lhs, const ArrangerObject &rhs)
  {
    return lhs.type_ == rhs.type_ && *lhs.pos_ == *rhs.pos_
           && lhs.track_id_ == rhs.track_id_;
  }
 
protected:
  ArrangerObject (Type type, TrackResolver track_resolver) noexcept;
 
  void
  copy_members_from (const ArrangerObject &other, ObjectCloneType clone_type);

  bool
  are_members_valid (bool is_project, dsp::FramesPerTick frames_per_tick) const;
 
private:
  dsp::Position * get_position_ptr (PositionType type);
 
  friend void to_json (nlohmann::json &j, const ArrangerObject &arranger_object)
  {
    to_json (j, static_cast<const UuidIdentifiableObject &> (arranger_object));
    j["type"] = arranger_object.type_;
    j["flags"] = arranger_object.flags_;
    j["trackId"] = arranger_object.track_id_;
    j["pos"] = arranger_object.pos_;
  }
  friend void
  from_json (const nlohmann::json &j, ArrangerObject &arranger_object)
  {
    j.at ("type").get_to (arranger_object.type_);
    j.at ("flags").get_to (arranger_object.flags_);
    j.at ("trackId").get_to (arranger_object.track_id_);
    j.at ("pos").get_to (*arranger_object.pos_);
  }
 
protected:
  TrackResolver track_resolver_;

  PositionProxy * pos_ = nullptr;
 
private:
  Type type_{};
 
protected:
  std::optional<TrackUuid> track_id_;

  // OptionalTrackPtrVariant track_;

  // bool deleted_temporarily_ = false;
 
public:
  Flags flags_{};
 
protected:
  // bool is_auditioner_ = false;
 
  std::optional<SelectionStatusGetter> selection_status_getter_;
};
 
using ArrangerObjectRegistry =
  utils::OwningObjectRegistry<ArrangerObjectPtrVariant, ArrangerObject>;
using ArrangerObjectUuidReference = utils::UuidReference<ArrangerObjectRegistry>;
using ArrangerObjectSelectionManager =
  utils::UuidIdentifiableObjectSelectionManager<ArrangerObjectRegistry>;
 
template <typename T>
concept ArrangerObjectSubclass = std::derived_from<T, ArrangerObject>;
 
template <typename T>
concept FinalArrangerObjectSubclass =
  std::derived_from<T, ArrangerObject> && FinalClass<T> && CompleteType<T>;
 
DEFINE_ENUM_FORMATTER (
  ArrangerObject::Type,
  ArrangerObject_Type,
  QT_TR_NOOP ("None"),
  QT_TR_NOOP ("All"),
  QT_TR_NOOP ("Region"),
  QT_TR_NOOP ("Midi Note"),
  QT_TR_NOOP ("Chord Object"),
  QT_TR_NOOP ("Scale Object"),
  QT_TR_NOOP ("Marker"),
  QT_TR_NOOP ("Automation Point"));
 
#endif