mixer_selections_action.h

// SPDX-FileCopyrightText: © 2019-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __UNDO_MIXER_SELECTIONS_ACTION_H__
#define __UNDO_MIXER_SELECTIONS_ACTION_H__
 
#include "dsp/port_connections_manager.h"
#include "gui/backend/backend/actions/undoable_action.h"
#include "gui/dsp/plugin_span.h"
#include "plugins/plugin.h"
#include "structure/tracks/automation_track.h"
#include "structure/tracks/track.h"
 
namespace zrythm::gui::actions
{

class MixerSelectionsAction : public QObject, public UndoableAction
{
  Q_OBJECT
  QML_ELEMENT
  DEFINE_UNDOABLE_ACTION_QML_PROPERTIES (MixerSelectionsAction)
 
  using Track = structure::tracks::Track;
  using AutomationTrack = structure::tracks::AutomationTrack;
 
public:
  enum class Type
  {
    Copy,
    Paste,
    Create,
    Delete,
    Move,
    ChangeStatus,
    ChangeLoadBehavior,
  };
 
  using PluginSlotType = plugins::PluginSlotType;
  using Plugin = plugins::Plugin;
  using PluginUuid = Plugin::Uuid;
  using PluginPtrVariant = plugins::PluginPtrVariant;
  using PluginConfiguration = plugins::PluginConfiguration;
 
  MixerSelectionsAction (QObject * parent = nullptr);

  MixerSelectionsAction (
    std::optional<PluginSpan>           ms,
    const dsp::PortConnectionsManager * connections_mgr,
    Type                                type,
    std::optional<Track::Uuid>          to_track_id,
    std::optional<plugins::PluginSlot>  to_slot,
    const PluginConfiguration *         setting,
    int                                 num_plugins,
    int                                 new_val,
    zrythm::plugins::BridgeMode         new_bridge_mode,
    QObject *                           parent = nullptr);
 
  QString to_string () const override;
 
  void get_plugins (std::vector<Plugin *> &plugins) override
  {
// TODO
#if 0
    if (ms_before_)
      PluginSpan{ *ms_before_ }.get_plugins (plugins);
    if (deleted_ms_)
      PluginSpan{ *deleted_ms_ }.get_plugins (plugins);
#endif
  }
 
  friend void init_from (
    MixerSelectionsAction       &obj,
    const MixerSelectionsAction &other,
    utils::ObjectCloneType       clone_type);
 
private:
  void init_loaded_impl () override;
  void perform_impl () override;
  void undo_impl () override;

  void clone_ats (PluginSpan plugins, bool deleted, int start_slot);
 
  void copy_at_regions (AutomationTrack &dest, const AutomationTrack &src);
 
#if 0
  void revert_automation (
    structure::tracks::AutomatableTrack &track,
    plugins::PluginSlot                  slot,
    bool                                 deleted);
#endif

  void save_existing_plugin (
    std::vector<PluginPtrVariant> tmp_plugins,
    Track *                       from_tr,
    plugins::PluginSlot           from_slot,
    Track *                       to_tr,
    plugins::PluginSlot           to_slot);
 
  void revert_deleted_plugin (Track &to_tr, plugins::PluginSlot to_slot);
 
  void do_or_undo_create_or_delete (bool do_it, bool create);
  void do_or_undo_change_status (bool do_it);
  void do_or_undo_change_load_behavior (bool do_it);
  void do_or_undo_move_or_copy (bool do_it, bool copy);
  void do_or_undo (bool do_it);
 
public:
  Type mixer_selections_action_type_ = Type ();

  std::optional<plugins::PluginSlot> to_slot_;

  std::optional<Track::Uuid> to_track_uuid_;

  bool new_channel_ = false;

  int num_plugins_ = 0;

  int new_val_ = 0;

  zrythm::plugins::BridgeMode new_bridge_mode_ =
    zrythm::plugins::BridgeMode::None;

  std::unique_ptr<PluginConfiguration> setting_;

  std::optional<std::vector<PluginPtrVariant>> ms_before_;
 
  std::optional<std::vector<PluginUuid>> ms_before_simple_;

  std::optional<std::vector<PluginPtrVariant>> deleted_ms_;

  std::vector<std::unique_ptr<AutomationTrack>> deleted_ats_;

  std::vector<std::unique_ptr<AutomationTrack>> ats_;
};
 
class MixerSelectionsCreateAction : public MixerSelectionsAction
{
public:
  MixerSelectionsCreateAction (
    const Track               &to_track,
    plugins::PluginSlot        to_slot,
    const PluginConfiguration &setting,
    int                        num_plugins = 1)
      : MixerSelectionsAction (
          std::nullopt,
          nullptr,
          MixerSelectionsAction::Type::Create,
          to_track.get_uuid (),
          to_slot,
          &setting,
          num_plugins,
          0,
          zrythm::plugins::BridgeMode::None)
  {
  }
};
 
class MixerSelectionsTargetedAction : public MixerSelectionsAction
{
public:
  MixerSelectionsTargetedAction (
    PluginSpan                         plugins,
    const dsp::PortConnectionsManager &connections_mgr,
    MixerSelectionsAction::Type        type,
    const Track *                      to_track,
    plugins::PluginSlot                to_slot)
      : MixerSelectionsAction (
          plugins,
          &connections_mgr,
          type,
          (to_track != nullptr)
            ? std::make_optional (to_track->get_uuid ())
            : std::nullopt,
          to_slot,
          nullptr,
          0,
          0,
          zrythm::plugins::BridgeMode::None)
  {
  }
};
 
class MixerSelectionsCopyAction : public MixerSelectionsTargetedAction
{
public:
  MixerSelectionsCopyAction (
    PluginSpan                         plugins,
    const dsp::PortConnectionsManager &connections_mgr,
    const Track *                      to_track,
    plugins::PluginSlot                to_slot)
      : MixerSelectionsTargetedAction (
          plugins,
          connections_mgr,
          MixerSelectionsAction::Type::Copy,
          to_track,
          to_slot)
  {
  }
};
 
class MixerSelectionsPasteAction : public MixerSelectionsTargetedAction
{
public:
  MixerSelectionsPasteAction (
    PluginSpan                         plugins,
    const dsp::PortConnectionsManager &connections_mgr,
    const Track *                      to_track,
    plugins::PluginSlot                to_slot)
      : MixerSelectionsTargetedAction (
          plugins,
          connections_mgr,
          MixerSelectionsAction::Type::Paste,
          to_track,
          to_slot)
  {
  }
};
 
class MixerSelectionsMoveAction : public MixerSelectionsTargetedAction
{
public:
  MixerSelectionsMoveAction (
    PluginSpan                         plugins,
    const dsp::PortConnectionsManager &connections_mgr,
    const Track *                      to_track,
    plugins::PluginSlot                to_slot)
      : MixerSelectionsTargetedAction (
          plugins,
          connections_mgr,
          MixerSelectionsAction::Type::Move,
          to_track,
          to_slot)
  {
  }
};
 
class MixerSelectionsDeleteAction : public MixerSelectionsAction
{
public:
  MixerSelectionsDeleteAction (
    PluginSpan                         plugins,
    const dsp::PortConnectionsManager &connections_mgr)
      : MixerSelectionsAction (
          plugins,
          &connections_mgr,
          MixerSelectionsAction::Type::Delete,
          std::nullopt,
          std::nullopt,
          nullptr,
          0,
          0,
          zrythm::plugins::BridgeMode::None)
  {
  }
};
 
class MixerSelectionsChangeStatusAction : public MixerSelectionsAction
{
public:
  MixerSelectionsChangeStatusAction (PluginSpan plugins, int new_val)
      : MixerSelectionsAction (
          plugins,
          nullptr,
          MixerSelectionsAction::Type::ChangeStatus,
          std::nullopt,
          std::nullopt,
          nullptr,
          0,
          new_val,
          zrythm::plugins::BridgeMode::None)
  {
  }
};
 
class MixerSelectionsChangeLoadBehaviorAction : public MixerSelectionsAction
{
public:
  MixerSelectionsChangeLoadBehaviorAction (
    PluginSpan                  plugins,
    zrythm::plugins::BridgeMode new_bridge_mode)
      : MixerSelectionsAction (
          plugins,
          nullptr,
          MixerSelectionsAction::Type::ChangeLoadBehavior,
          std::nullopt,
          std::nullopt,
          nullptr,
          0,
          0,
          new_bridge_mode)
  {
  }
};
 
}; // namespace zrythm::actions
 
#endif