daniel
fad2544256
Mirrors capture: when membership is non-empty and the project has no .rpp, Main_SaveProject(proj, true) prompts Save-As before persisting; cancel leaves the in-session tag state intact and warns via console.
275 lines
13 KiB
C++
275 lines
13 KiB
C++
// actions.cpp — the Design View action family (Phase D4). See actions.h.
|
|
//
|
|
// Compiled into the reaper_reasampler MODULE. Includes reaper_plugin_functions.h
|
|
// WITHOUT REAPERAPI_IMPLEMENT — main.cpp is the one TU that defines the API pointers
|
|
// (CLAUDE.md §contract). The action ids are minted from FOREVER-STABLE strings (the
|
|
// same CEREBELLUM_REASAMPLER_ family prefix main.cpp uses); user keybindings key off
|
|
// them, so they must never change after ship.
|
|
//
|
|
// Each action:
|
|
// 1. mutates the session's ViewModeModel (membership tag/untag/show-both, or the
|
|
// active mode via toggle/activate) — the pure D1 state,
|
|
// 2. reapplies the active mode through the D2 view shell (applyMode) so the change
|
|
// takes visible effect immediately (tagging a track into Design while in Arrange
|
|
// parks it right away; a mode change re-partitions and re-parks in one step).
|
|
//
|
|
// Selection-driven mutations iterate the CURRENT REAPER track selection
|
|
// (CountSelectedTracks/GetSelectedTrack — both ignore the master, which is correct:
|
|
// the master is never tagged) and resolve each track to its canonical GUID key via
|
|
// the shared guidString helper, so the keys match exactly what the D2 shell / view
|
|
// tree key on (the cross-module key contract).
|
|
|
|
#include "actions.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "persist.h" // ReaSamplerSession (owns view() model)
|
|
#include "track_guid.h" // shared MediaTrack* -> canonical GUID key
|
|
#include "view.h" // applyMode (D2 shell)
|
|
#include "view_mode_model.h"
|
|
|
|
#include "reaper_plugin.h" // reaper_plugin_info_t, gaccel_register_t (full defs)
|
|
|
|
#define REAPERAPI_MINIMAL
|
|
#define REAPERAPI_WANT_CountSelectedTracks
|
|
#define REAPERAPI_WANT_GetSelectedTrack
|
|
#define REAPERAPI_WANT_EnumProjects
|
|
#define REAPERAPI_WANT_Main_SaveProject
|
|
#define REAPERAPI_WANT_ShowConsoleMsg
|
|
#include "reaper_plugin_functions.h"
|
|
|
|
namespace reasampler {
|
|
|
|
namespace {
|
|
|
|
// FOREVER-STABLE action-id strings. Same family prefix as main.cpp's capture/panel
|
|
// actions; each full string is minted into a persistent command id and user
|
|
// keybindings key off it — NEVER change these after ship.
|
|
constexpr const char* kIdToggleMode = "CEREBELLUM_REASAMPLER_VIEW_TOGGLE_MODE";
|
|
constexpr const char* kIdActivateArrange = "CEREBELLUM_REASAMPLER_VIEW_ACTIVATE_ARRANGE";
|
|
constexpr const char* kIdActivateDesign = "CEREBELLUM_REASAMPLER_VIEW_ACTIVATE_DESIGN";
|
|
constexpr const char* kIdTagDesign = "CEREBELLUM_REASAMPLER_VIEW_TAG_DESIGN";
|
|
constexpr const char* kIdTagArrange = "CEREBELLUM_REASAMPLER_VIEW_TAG_ARRANGE";
|
|
constexpr const char* kIdUntag = "CEREBELLUM_REASAMPLER_VIEW_UNTAG";
|
|
constexpr const char* kIdShowBoth = "CEREBELLUM_REASAMPLER_VIEW_SHOW_BOTH";
|
|
|
|
// The live session the actions mutate. Set once by designViewRegisterActions and
|
|
// read by the hookcommand handler. Not owned here (main.cpp owns g_session).
|
|
ReaSamplerSession* g_session = nullptr;
|
|
|
|
// Minted command ids (0 until registration succeeds). Compared in the handler.
|
|
int g_cmdToggleMode = 0;
|
|
int g_cmdActivateArrange = 0;
|
|
int g_cmdActivateDesign = 0;
|
|
int g_cmdTagDesign = 0;
|
|
int g_cmdTagArrange = 0;
|
|
int g_cmdUntag = 0;
|
|
int g_cmdShowBoth = 0;
|
|
|
|
// gaccel storage must outlive registration — REAPER holds each pointer until we
|
|
// mirror-unregister it. One per action.
|
|
gaccel_register_t g_accelToggleMode{};
|
|
gaccel_register_t g_accelActivateArrange{};
|
|
gaccel_register_t g_accelActivateDesign{};
|
|
gaccel_register_t g_accelTagDesign{};
|
|
gaccel_register_t g_accelTagArrange{};
|
|
gaccel_register_t g_accelUntag{};
|
|
gaccel_register_t g_accelShowBoth{};
|
|
|
|
// Mints a command id from a stable string and registers its gaccel (Actions-list
|
|
// entry with `desc`). Returns the command id (0 on failure). The gaccel storage is
|
|
// caller-owned and must outlive the module (the file-scope g_accel* above).
|
|
int registerAction(reaper_plugin_info_t* rec, const char* stableId,
|
|
gaccel_register_t& accel, const char* desc) {
|
|
const int cmd = rec->Register("command_id", (void*)stableId);
|
|
if (cmd) {
|
|
accel.accel.cmd = cmd;
|
|
accel.desc = desc;
|
|
rec->Register("gaccel", (void*)&accel);
|
|
}
|
|
return cmd;
|
|
}
|
|
|
|
// Collects the canonical GUID keys of the current track selection. Empty if nothing
|
|
// is selected. CountSelectedTracks/GetSelectedTrack ignore the master (SDK), which is
|
|
// exactly right — the master is never a tagged leaf.
|
|
std::vector<std::string> selectedTrackGuids() {
|
|
std::vector<std::string> guids;
|
|
const int n = CountSelectedTracks(nullptr); // nullptr = active project
|
|
guids.reserve(static_cast<std::size_t>(n < 0 ? 0 : n));
|
|
for (int i = 0; i < n; ++i) {
|
|
MediaTrack* tr = GetSelectedTrack(nullptr, i);
|
|
if (!tr) continue;
|
|
std::string g = guidString(tr);
|
|
if (!g.empty()) guids.push_back(std::move(g));
|
|
}
|
|
return guids;
|
|
}
|
|
|
|
// Reapplies the model's CURRENT active mode to the active project so a membership
|
|
// mutation takes visible effect immediately (park/unpark/re-derive parents). Called
|
|
// after every tag/untag/show-both. `proj = nullptr` -> REAPER's active project.
|
|
void reapplyActiveMode() {
|
|
applyMode(g_session->view(), g_session->view().activeModeId(), nullptr);
|
|
}
|
|
|
|
// Persists both the bank and the Design-View model to the active project's ext
|
|
// state. Called after every state-changing Design View action so the view model
|
|
// is not lost across save/close/reopen. Marking the project dirty is correct —
|
|
// a Design View mutation is a project-level change the user should be prompted
|
|
// to save.
|
|
//
|
|
// When the membership index is non-empty AND the project is unsaved, we prompt
|
|
// the user to Save-As before persisting — mirroring the flow capture uses.
|
|
// Gate: if membership is empty (no tracks tagged), skip the prompt entirely;
|
|
// saveToActiveProject will no-op for an unsaved project, which is correct.
|
|
//
|
|
// DAW-ONLY ASSUMPTION: Main_SaveProject(proj, true) opens a Save-As dialog and
|
|
// blocks until the user dismisses it. The blocking behaviour and dialog
|
|
// appearance can only be confirmed in a running REAPER (same caveat as capture).
|
|
void persistViewState() {
|
|
if (!g_session->view().membership().empty()) {
|
|
// At least one track is tagged — worth persisting. Check whether the
|
|
// project is saved and, if not, prompt Save-As so saveToActiveProject
|
|
// can write ext state. Mirrors capture's readRppPath idiom exactly.
|
|
ReaProject* proj = EnumProjects(-1, nullptr, 0);
|
|
if (proj) {
|
|
auto readRppPath = [&]() -> std::string {
|
|
std::vector<char> buf(4096, '\0');
|
|
EnumProjects(-1, buf.data(), static_cast<int>(buf.size()));
|
|
return std::string(buf.data());
|
|
};
|
|
|
|
if (readRppPath().empty()) {
|
|
// Project is unsaved — prompt Save-As.
|
|
Main_SaveProject(proj, true);
|
|
// Re-read: still empty means the user cancelled.
|
|
if (readRppPath().empty()) {
|
|
ShowConsoleMsg(
|
|
"ReaSampler: Design View state will not persist until "
|
|
"the project is saved.\n");
|
|
// The in-session tag state is left as-is — the mode change
|
|
// already applied and remains valid for this session.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
g_session->saveToActiveProject();
|
|
}
|
|
|
|
// -- Action bodies ---------------------------------------------------------
|
|
|
|
// Toggle: cycle to the next mode in ordinal order (Arrange <-> Design with two
|
|
// seeds; scales to cycle-through-all for >2 modes with no change here). applyMode
|
|
// itself sets the model's active mode, so we only compute the target and apply.
|
|
void doToggleMode() {
|
|
const std::string target =
|
|
nextModeId(g_session->view().modes(), g_session->view().activeModeId());
|
|
if (target.empty()) return; // no modes to cycle to (degenerate)
|
|
applyMode(g_session->view(), target, nullptr);
|
|
persistViewState();
|
|
}
|
|
|
|
// Direct jump to a named mode. applyMode is a no-op (returns false, no mutation) if
|
|
// the id is unregistered, so an absent mode fails safe.
|
|
void doActivateMode(const std::string& modeId) {
|
|
applyMode(g_session->view(), modeId, nullptr);
|
|
persistViewState();
|
|
}
|
|
|
|
// Tag the selection's leaves into `modeId`, then reapply so the change is immediate.
|
|
// tag() replaces any prior single-mode membership (a leaf lives in one mode; the
|
|
// cross-mode case is show-both), matching the D1 contract.
|
|
void doTag(const std::string& modeId) {
|
|
for (const std::string& g : selectedTrackGuids())
|
|
g_session->view().membership().tag(g, modeId);
|
|
reapplyActiveMode();
|
|
persistViewState();
|
|
}
|
|
|
|
// Untag the selection entirely (return each to the Arrange default). This is the
|
|
// shared body behind both "Untag selected" and "Tag -> Arrange" (Arrange = the
|
|
// absence of a tag), so the two actions are the same act by definition.
|
|
void doUntag() {
|
|
for (const std::string& g : selectedTrackGuids())
|
|
g_session->view().membership().untag(g);
|
|
reapplyActiveMode();
|
|
persistViewState();
|
|
}
|
|
|
|
// Toggle the per-track show-both pin for the selection. Read the CURRENT pin of each
|
|
// track and flip it independently (a mixed selection converges toward "all on" then
|
|
// "all off" only if uniform; per-track flip is the honest semantics of a toggle on a
|
|
// multi-selection). show-both leaves are never parked (D1), so reapply reflects the
|
|
// change immediately.
|
|
void doShowBoth() {
|
|
MembershipIndex& m = g_session->view().membership();
|
|
for (const std::string& g : selectedTrackGuids())
|
|
m.setShowBoth(g, !m.isShowBoth(g));
|
|
reapplyActiveMode();
|
|
persistViewState();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void designViewRegisterActions(reaper_plugin_info_t* rec, ReaSamplerSession* session) {
|
|
g_session = session;
|
|
|
|
// command_id -> gaccel for each. The single hookcommand that routes these lives
|
|
// in main.cpp (one hook per extension); designViewHandleCommand services them.
|
|
g_cmdToggleMode = registerAction(rec, kIdToggleMode, g_accelToggleMode,
|
|
"ReaSampler: toggle Design View mode");
|
|
g_cmdActivateArrange = registerAction(rec, kIdActivateArrange, g_accelActivateArrange,
|
|
"ReaSampler: activate mode Arrange");
|
|
g_cmdActivateDesign = registerAction(rec, kIdActivateDesign, g_accelActivateDesign,
|
|
"ReaSampler: activate mode Design");
|
|
g_cmdTagDesign = registerAction(rec, kIdTagDesign, g_accelTagDesign,
|
|
"ReaSampler: tag selected tracks -> Design");
|
|
g_cmdTagArrange = registerAction(rec, kIdTagArrange, g_accelTagArrange,
|
|
"ReaSampler: tag selected tracks -> Arrange");
|
|
g_cmdUntag = registerAction(rec, kIdUntag, g_accelUntag,
|
|
"ReaSampler: untag selected tracks");
|
|
g_cmdShowBoth = registerAction(rec, kIdShowBoth, g_accelShowBoth,
|
|
"ReaSampler: show both for selected tracks");
|
|
}
|
|
|
|
bool designViewHandleCommand(int command) {
|
|
if (command == 0 || !g_session) return false;
|
|
|
|
if (command == g_cmdToggleMode) { doToggleMode(); return true; }
|
|
if (command == g_cmdActivateArrange) { doActivateMode(kArrangeModeId); return true; }
|
|
if (command == g_cmdActivateDesign) { doActivateMode(kDesignModeId); return true; }
|
|
if (command == g_cmdTagDesign) { doTag(kDesignModeId); return true; }
|
|
// Tag -> Arrange and Untag are the same act (Arrange = the absence of a tag).
|
|
if (command == g_cmdTagArrange) { doUntag(); return true; }
|
|
if (command == g_cmdUntag) { doUntag(); return true; }
|
|
if (command == g_cmdShowBoth) { doShowBoth(); return true; }
|
|
|
|
return false; // not ours — caller's hookcommand keeps looking
|
|
}
|
|
|
|
void designViewUnregisterActions(reaper_plugin_info_t* rec) {
|
|
// Mirror-unregister with '-'-prefixed strings, per the contract's unload rule.
|
|
// gaccel first, then the command_id string (reverse of registration order).
|
|
rec->Register("-gaccel", (void*)&g_accelShowBoth);
|
|
rec->Register("-command_id", (void*)kIdShowBoth);
|
|
rec->Register("-gaccel", (void*)&g_accelUntag);
|
|
rec->Register("-command_id", (void*)kIdUntag);
|
|
rec->Register("-gaccel", (void*)&g_accelTagArrange);
|
|
rec->Register("-command_id", (void*)kIdTagArrange);
|
|
rec->Register("-gaccel", (void*)&g_accelTagDesign);
|
|
rec->Register("-command_id", (void*)kIdTagDesign);
|
|
rec->Register("-gaccel", (void*)&g_accelActivateDesign);
|
|
rec->Register("-command_id", (void*)kIdActivateDesign);
|
|
rec->Register("-gaccel", (void*)&g_accelActivateArrange);
|
|
rec->Register("-command_id", (void*)kIdActivateArrange);
|
|
rec->Register("-gaccel", (void*)&g_accelToggleMode);
|
|
rec->Register("-command_id", (void*)kIdToggleMode);
|
|
|
|
g_session = nullptr;
|
|
}
|
|
|
|
} // namespace reasampler
|