scripted_ui_host.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
 
#include <pulp/timeline_editor/sequencer_ui_host.hpp>

namespace pulp::timeline_editor {

struct ScriptedProgram {
    timebase::TickPosition position{};
    std::uint64_t continuity_epoch = 0;
    timebase::LoopRegion loop{};
    UiTransportState state = UiTransportState::Stopped;
    double tempo_bpm = 120.0;
};
 
template <class Intent>
class ScriptedUiHost final : public SequencerUiHostT<Intent> {
  public:
    struct AuditionRecord {
        AuditionRequest request{};
        AuditionResult result{};
    };
 
    ScriptedUiHost() : program_(std::make_unique<ScriptedProgram>()) {}
 
    // ── Scripting (caller side) ──────────────────────────────────────────────

    void set_program(const ScriptedProgram& program) {
        *program_ = program;
        ++sequence_;
    }

    void swap_program(const ScriptedProgram& program) {
        program_.reset();
        program_ = std::make_unique<ScriptedProgram>(program);
        ++generation_;
        ++sequence_;
    }
 
    std::uint64_t program_generation() const { return generation_; }

    void set_audition_status(AuditionStatus status) { audition_status_ = status; }

    void set_intent_status(IntentStatus status) { intent_status_ = status; }
 
    // ── What the view emitted (test side) ────────────────────────────────────
 
    const std::vector<AuditionRecord>& auditions() const { return auditions_; }
    const std::vector<AuditionHandle>& ended_auditions() const { return ended_; }
    const std::vector<Intent>& intents() const { return intents_; }
 
    void clear_emissions() {
        auditions_.clear();
        ended_.clear();
        intents_.clear();
    }
 
    // ── SequencerUiHost ──────────────────────────────────────────────────────
 
    UiPlayhead playhead() const noexcept override {
        const ScriptedProgram& current = *program_;
        UiPlayhead reading;
        reading.program_generation = generation_;
        reading.sequence = sequence_;
        reading.continuity_epoch = current.continuity_epoch;
        reading.position = current.position;
        reading.loop = current.loop;
        reading.state = current.state;
        reading.tempo_bpm = current.tempo_bpm;
        return reading;
    }
 
    AuditionResult begin_audition(const AuditionRequest& request) noexcept override {
        // The recording vectors allocate, which is why this host belongs on the
        // UI side of a real implementation's queue and never on an audio thread.
        AuditionResult result;
        result.status = audition_status_;
        if (audition_status_ == AuditionStatus::Started && request.duration.value == 0)
            result.handle = AuditionHandle{++next_handle_};
        auditions_.push_back(AuditionRecord{request, result});
        return result;
    }
 
    void end_audition(AuditionHandle handle) noexcept override {
        ended_.push_back(handle);
    }
 
    IntentResult submit_intent(const Intent& intent) noexcept override {
        intents_.push_back(intent);
        IntentResult result;
        result.status = intent_status_;
        if (intent_status_ == IntentStatus::Accepted)
            result.sequence = ++next_intent_sequence_;
        return result;
    }
 
  private:
    std::unique_ptr<ScriptedProgram> program_;
    std::uint64_t generation_ = 1;
    std::uint64_t sequence_ = 1;
    std::uint64_t next_handle_ = 0;
    std::uint64_t next_intent_sequence_ = 0;
    AuditionStatus audition_status_ = AuditionStatus::Started;
    IntentStatus intent_status_ = IntentStatus::Accepted;
 
    std::vector<AuditionRecord> auditions_;
    std::vector<AuditionHandle> ended_;
    std::vector<Intent> intents_;
};
 
} // namespace pulp::timeline_editor