arranger_selections_action.h

// SPDX-FileCopyrightText: © 2019-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "gui/backend/backend/actions/undoable_action.h"
#include "gui/dsp/quantize_options.h"
#include "structure/arrangement/arranger_object_span.h"
#include "structure/arrangement/audio_function.h"
#include "structure/arrangement/automation_function.h"
#include "structure/arrangement/midi_function.h"
 
namespace zrythm::gui::actions
{

class ArrangerSelectionsAction : public QObject, public UndoableAction
{
  Q_OBJECT
  QML_ELEMENT
  DEFINE_UNDOABLE_ACTION_QML_PROPERTIES (ArrangerSelectionsAction)
 
  using ArrangerObjectRegistry = structure::arrangement::ArrangerObjectRegistry;
  using ArrangerObjectPtrVariant =
    structure::arrangement::ArrangerObjectPtrVariant;
  using ArrangerObjectSpan = structure::arrangement::ArrangerObjectSpan;
  using ArrangerObject = structure::arrangement::ArrangerObject;
  using MidiFunction = structure::arrangement::MidiFunction;
  using AutomationFunction = structure::arrangement::AutomationFunction;
 
public:
  enum class Type
  {
    AutomationFill,
    Create,
    Delete,
    Duplicate,
    Edit,
    Link,
    Merge,
    Move,
    Quantize,
    Record,
    Resize,
    Split,
  };

  enum class ResizeType
  {
    L, //< Resize the left side of the `ArrangerObject`s in the selection.
    R, //< Resize the right side of the `ArrangerObject`s in the selection.
    LLoop,
    RLoop,
    LFade,
    RFade,
    LStretch,
    RStretch,
  };

  enum class EditType
  {
    Name,

    Position,

    Primitive,

    Scale,

    Fades,

    Mute,

    // ARRANGER_SELECTIONS_ACTION_EDIT_RAMP,

    EditorFunction,
  };
 
  using Position = zrythm::dsp::Position;
 
public:
  ArrangerSelectionsAction ();
  ~ArrangerSelectionsAction () override = default;
 
  class RecordAction;
  class MoveOrDuplicateAction;
  class MoveOrDuplicateTimelineAction;
  class MoveOrDuplicateMidiAction;
  class MoveOrDuplicateAutomationAction;
  class MoveOrDuplicateChordAction;
  // class MoveByTicksAction;
  class MoveMidiAction;
  class MoveChordAction;
  class LinkAction;
  class AutomationFillAction;
  class SplitAction;
  class MergeAction;
  class ResizeAction;
  class QuantizeAction;
 
  ArrangerObjectRegistry &get_arranger_object_registry () const;
 
  friend void init_from (
    ArrangerSelectionsAction       &obj,
    const ArrangerSelectionsAction &other,
    utils::ObjectCloneType          clone_type);
 
  bool needs_transport_total_bar_update (bool perform) const override;
 
  bool needs_pause () const override
  {
    /* always needs a pause to update the track playback snapshots */
    return true;
  }
 
  [[nodiscard]] QString to_string () const final;
 
protected:
  ArrangerSelectionsAction (ArrangerObjectSpan before_sel, Type type)
      : UndoableAction (UndoableAction::Type::ArrangerSelections), type_ (type),
        first_run_ (true)
  {
    set_before_selections (before_sel);
  }

  void set_before_selections (ArrangerObjectSpan src_var);

  void set_after_selections (ArrangerObjectSpan src_var);
 
private:
  void do_or_undo (bool do_it);
 
  void do_or_undo_duplicate_or_link (bool link, bool do_it);
  void do_or_undo_move (bool do_it);
  void do_or_undo_create_or_delete (bool do_it, bool create);
  void do_or_undo_record (bool do_it);
  void do_or_undo_edit (bool do_it);
  void do_or_undo_automation_fill (bool do_it);
  void do_or_undo_split (bool do_it);
  void do_or_undo_merge (bool do_it);
  void do_or_undo_resize (bool do_it);
  void do_or_undo_quantize (bool do_it);

  void update_region_link_groups (const auto &objects);

  void move_obj_by_tracks_and_lanes (
    ArrangerObjectPtrVariant obj_var,
    int                      tracks_diff,
    int                      lanes_diff,
    bool                     use_index_in_prev_lane,
    int                      index_in_prev_lane);
 
  std::vector<ArrangerObjectPtrVariant> get_project_arranger_objects () const;
 
  void init_loaded_impl () final;
  void perform_impl () final;
  void undo_impl () final;
 
public:
  Type type_{};

  std::optional<std::vector<ArrangerObjectPtrVariant>> sel_;

  std::optional<std::vector<ArrangerObjectPtrVariant>> sel_after_;

  EditType edit_type_{};

  double ticks_{};
  int delta_tracks_{};
  int delta_lanes_{};
  int delta_chords_ = 0;
  int delta_pitch_ = 0;
  int delta_vel_ = 0;
  double delta_normalized_amount_ = 0.0;
 
  std::optional<std::pair<Position, Position>>
    selected_positions_in_audio_editor_;

  std::optional<ArrangerObject::Uuid> clip_editor_region_id_;

  std::optional<dsp::PortUuid> target_port_;

  utils::Utf8String str_;

  Position pos_;

  std::vector<ArrangerObject::Uuid> r1_;
  std::vector<ArrangerObject::Uuid> r2_;

  // size_t num_split_objs_ = 0;

  bool first_run_ = false;

  std::unique_ptr<gui::old_dsp::QuantizeOptions> opts_{};

  std::optional<ArrangerObjectPtrVariant> region_before_;
  std::optional<ArrangerObjectPtrVariant> region_after_;

  ResizeType resize_type_ = (ResizeType) 0;
};
 
class CreateOrDeleteArrangerSelectionsAction : public ArrangerSelectionsAction
{
public:
  ~CreateOrDeleteArrangerSelectionsAction () override = default;
 
protected:
  CreateOrDeleteArrangerSelectionsAction (
    ArrangerObjectSpan sel_var,
    bool               create);
};
 
class CreateArrangerSelectionsAction final
    : public CreateOrDeleteArrangerSelectionsAction
{
public:
  CreateArrangerSelectionsAction (ArrangerObjectSpan sel)
      : CreateOrDeleteArrangerSelectionsAction (sel, true) { };
};
 
class DeleteArrangerSelectionsAction final
    : public CreateOrDeleteArrangerSelectionsAction
{
public:
  DeleteArrangerSelectionsAction (ArrangerObjectSpan sel)
      : CreateOrDeleteArrangerSelectionsAction (sel, false) { };
};
 
class ArrangerSelectionsAction::RecordAction : public ArrangerSelectionsAction
{
public:
  RecordAction (
    ArrangerObjectSpan sel_before,
    ArrangerObjectSpan sel_after,
    bool               already_recorded);
};
 
class ArrangerSelectionsAction::MoveOrDuplicateAction
    : public ArrangerSelectionsAction
{
public:
  MoveOrDuplicateAction (
    ArrangerObjectSpan           sel_var,
    bool                         move,
    double                       ticks,
    int                          delta_chords,
    int                          delta_pitch,
    int                          delta_tracks,
    int                          delta_lanes,
    double                       delta_normalized_amount,
    std::optional<dsp::PortUuid> tgt_port_id,
    bool                         already_moved);
};
 
class ArrangerSelectionsAction::MoveOrDuplicateTimelineAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  MoveOrDuplicateTimelineAction (
    ArrangerObjectSpan           sel,
    bool                         move,
    double                       ticks,
    int                          delta_tracks,
    int                          delta_lanes,
    std::optional<dsp::PortUuid> tgt_port_id,
    bool                         already_moved)
      : MoveOrDuplicateAction (
          sel,
          move,
          ticks,
          0,
          0,
          delta_tracks,
          delta_lanes,
          0,
          tgt_port_id,
          already_moved) { };
};
 
class ArrangerSelectionsAction::MoveOrDuplicateMidiAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  MoveOrDuplicateMidiAction (
    ArrangerObjectSpan sel,
    bool               move,
    double             ticks,
    int                delta_pitch,
    bool               already_moved)
      : MoveOrDuplicateAction (
          sel,
          move,
          ticks,
          0,
          delta_pitch,
          0,
          0,
          0,
          std::nullopt,
          already_moved) { };
};
 
class ArrangerSelectionsAction::MoveOrDuplicateChordAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  MoveOrDuplicateChordAction (
    ArrangerObjectSpan sel,
    bool               move,
    double             ticks,
    int                delta_chords,
    bool               already_moved)
      : MoveOrDuplicateAction (
          sel,
          move,
          ticks,
          delta_chords,
          0,
          0,
          0,
          0,
          std::nullopt,
          already_moved) { };
};
 
class ArrangerSelectionsAction::MoveOrDuplicateAutomationAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  MoveOrDuplicateAutomationAction (
    ArrangerObjectSpan sel,
    bool               move,
    double             ticks,
    int                delta_normalized_amount,
    bool               already_moved)
      : MoveOrDuplicateAction (
          sel,
          move,
          ticks,
          0,
          0,
          0,
          0,
          delta_normalized_amount,
          std::nullopt,
          already_moved) { };
};
 
#if 0
class ArrangerSelectionsAction::MoveByTicksAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  template <FinalArrangerSelectionsSubclass T>
  MoveByTicksAction (const T &sel, double ticks, bool already_moved)
      : MoveOrDuplicateAction (sel, true, ticks, 0, 0, 0, 0, 0, nullptr, already_moved)
  {
  }
};
#endif
 
class ArrangerSelectionsAction::MoveMidiAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  MoveMidiAction (
    ArrangerObjectSpan sel,
    double             ticks,
    int                delta_pitch,
    bool               already_moved)
      : MoveOrDuplicateAction (sel, true, ticks, 0, delta_pitch, 0, 0, 0, std::nullopt, already_moved)
  {
  }
};
 
class ArrangerSelectionsAction::MoveChordAction
    : public ArrangerSelectionsAction::MoveOrDuplicateAction
{
public:
  MoveChordAction (
    ArrangerObjectSpan sel,
    double             ticks,
    int                delta_chords,
    bool               already_moved)
      : MoveOrDuplicateAction (sel, true, ticks, delta_chords, 0, 0, 0, 0, std::nullopt, already_moved)
  {
  }
};
 
class ArrangerSelectionsAction::LinkAction : public ArrangerSelectionsAction
{
public:
  LinkAction (
    ArrangerObjectSpan sel_before,
    ArrangerObjectSpan sel_after,
    double             ticks,
    int                delta_tracks,
    int                delta_lanes,
    bool               already_moved);
};
 
class EditArrangerSelectionsAction : public ArrangerSelectionsAction
{
public:
  EditArrangerSelectionsAction (
    ArrangerObjectSpan                sel_before,
    std::optional<ArrangerObjectSpan> sel_after,
    EditType                          type,
    bool                              already_edited);

  static std::unique_ptr<EditArrangerSelectionsAction> create (
    ArrangerObjectSpan sel_before,
    ArrangerObjectSpan sel_after,
    EditType           type,
    bool               already_edited);

  EditArrangerSelectionsAction (
    ArrangerObjectSpan    sel_before,
    MidiFunction::Type    midi_func_type,
    MidiFunction::Options opts);

  EditArrangerSelectionsAction (
    ArrangerObjectSpan       sel_before,
    AutomationFunction::Type automation_func_type);

  EditArrangerSelectionsAction (
    ArrangerObject::Uuid                      region_id,
    const dsp::Position                      &sel_start,
    const dsp::Position                      &sel_end,
    structure::arrangement::AudioFunctionType audio_func_type,
    structure::arrangement::AudioFunctionOpts opts,
    std::optional<utils::Utf8String>          uri);
};
 
class ArrangerSelectionsAction::AutomationFillAction
    : public ArrangerSelectionsAction
{
public:
  template <structure::arrangement::RegionObject RegionT>
  AutomationFillAction (
    const RegionT &region_before,
    const RegionT &region_after,
    bool           already_changed);
};
 
class ArrangerSelectionsAction::SplitAction : public ArrangerSelectionsAction
{
public:
  SplitAction (ArrangerObjectSpan sel, Position pos);
};
 
class ArrangerSelectionsAction::MergeAction : public ArrangerSelectionsAction
{
public:
  MergeAction (ArrangerObjectSpan sel)
      : ArrangerSelectionsAction (sel, Type::Merge)
  {
  }
};
 
class ArrangerSelectionsAction::ResizeAction : public ArrangerSelectionsAction
{
public:
  ResizeAction (
    ArrangerObjectSpan                sel_before,
    std::optional<ArrangerObjectSpan> sel_after,
    ResizeType                        type,
    double                            ticks);
};
 
class ArrangerSelectionsAction::QuantizeAction : public ArrangerSelectionsAction
{
public:
  QuantizeAction (ArrangerObjectSpan sel, const old_dsp::QuantizeOptions &opts)
      : ArrangerSelectionsAction (sel, Type::Quantize)
  {
    opts_ = std::make_unique<old_dsp::QuantizeOptions> (opts);
  }
};
 
}; // namespace zrythm::gui::actions
 
DEFINE_ENUM_FORMATTER (
  zrythm::gui::actions::ArrangerSelectionsAction::ResizeType,
  ArrangerSelectionsAction_ResizeType,
  "Resize L",
  "Resize R",
  "Resize L (loop)",
  "Resize R (loop)",
  "Resize L (fade)",
  "Resize R (fade)",
  "Stretch L",
  "Stretch R");