undoable_action.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/port_connections_manager.h"
#include "plugins/plugin.h"
#include "utils/types.h"
 
namespace zrythm::gui::actions
{
 
#define DEFINE_UNDOABLE_ACTION_QML_PROPERTIES(ClassType) \
public: \
  /* ================================================================ */ \
  /* helpers */ \
  /* ================================================================ */ \
  Q_INVOKABLE QString getDescription () const \
  { \
    return to_string (); \
  }

class UndoableAction
{
public:
  using PortConnectionsManager = dsp::PortConnectionsManager;

  enum class Type
  {
    /* ---- Track/Channel ---- */
    TracklistSelections,
 
    ChannelSend,
 
    /* ---- end ---- */
 
    MixerSelections,
    ArrangerSelections,
 
    /* ---- connections ---- */
 
    MidiMapping,
    PortConnection,
    Port,
 
    /* ---- end ---- */
 
    /* ---- range ---- */
 
    Range,
 
    /* ---- end ---- */
 
    Transport,
 
    Chord,
  };
 
  UndoableAction () = default;
  UndoableAction (Type type);
  UndoableAction (
    Type                 type,
    dsp::FramesPerTick   frames_per_tick,
    units::sample_rate_t sample_rate);
  virtual ~UndoableAction () = default;

  void init_loaded (sample_rate_t engine_sample_rate);

  virtual bool needs_pause () const { return true; };

  virtual bool needs_transport_total_bar_update (bool perform) const
  {
    return true;
  };

  virtual bool affects_audio_region_internal_positions () const { return true; }

  virtual void get_plugins (std::vector<plugins::Plugin *> &plugins) { };
 
  auto get_frames_per_tick () const { return frames_per_tick_; }
  auto get_ticks_per_frame () const
  {
    return to_ticks_per_frame (get_frames_per_tick ());
  }

  void set_num_actions (int num_actions);

  void save_or_load_port_connections (bool performing);

  void perform ();

  void undo ();

  virtual QString to_string () const = 0;
 
protected:
  friend void init_from (
    UndoableAction        &obj,
    const UndoableAction  &other,
    utils::ObjectCloneType clone_type);
 
private:
  virtual void init_loaded_impl () = 0;
  virtual void perform_impl () = 0;
  virtual void undo_impl () = 0;

  void do_or_undo (bool perform);
 
public:
  Type undoable_action_type_{};

  dsp::FramesPerTick frames_per_tick_;

  units::sample_rate_t sample_rate_ = 0;

  int num_actions_ = 1;

  std::unique_ptr<dsp::PortConnectionsManager> port_connections_before_;

  std::unique_ptr<dsp::PortConnectionsManager> port_connections_after_;
};
 
class ArrangerSelectionsAction;
class ChannelSendAction;
class ChordAction;
class MidiMappingAction;
class MixerSelectionsAction;
class PortAction;
class PortConnectionAction;
class RangeAction;
class TracklistSelectionsAction;
class TransportAction;
using UndoableActionVariant = std::variant<
  ArrangerSelectionsAction,
  ChannelSendAction,
  ChordAction,
  MidiMappingAction,
  MixerSelectionsAction,
  PortAction,
  PortConnectionAction,
  RangeAction,
  TracklistSelectionsAction,
  TransportAction>;
using UndoableActionPtrVariant = to_pointer_variant<UndoableActionVariant>;
 
template <typename T>
concept UndoableActionSubclass =
  std::derived_from<T, UndoableAction> && !std::is_same_v<T, UndoableAction>;
 
}; // namespace zrythm::gui::actions