piano_roll_view.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/timeline/model.hpp>
#include <pulp/timeline_editor/edit_intent.hpp>
#include <pulp/timeline_editor/viewport_projection.hpp>
#include <pulp/view/hit_metrics.hpp>
#include <pulp/view/midi_keyboard.hpp>
#include <pulp/view/view.hpp>
 
#include <cstddef>
#include <functional>
#include <optional>
#include <span>
#include <vector>
 
namespace pulp::timeline_view {


struct PianoRollLayout {
    timeline_editor::TickProjection time;
    timeline_editor::PitchProjection pitch;
    timebase::TickDuration snap{};
};

class PianoRollPitchRuler final : public view::MidiKeyboard {
  public:
    PianoRollPitchRuler();

    void set_pitch_projection(const timeline_editor::PitchProjection& projection);
};

enum class PianoRollRefusal : std::uint8_t {
    InvalidNote,
    OutsideClip,
};

class PianoRollView : public view::View {
  public:
    using NoteFactory = std::function<std::optional<timeline::NoteEvent>(
        timebase::TickPosition start, std::uint8_t pitch)>;
 
    PianoRollView();

    void set_clip(const timeline::Project* project, timeline::ItemId sequence_id,
                  timeline::ItemId track_id, timeline::ItemId clip_id);
    void set_layout(const PianoRollLayout& layout);
    void set_host(timeline_editor::NoteEditIntentHost* host);
    void set_hit_metrics(const view::HitMetrics& metrics);
    void set_note_factory(NoteFactory factory);
    void set_continuous_gestures(bool enabled) noexcept { continuous_gestures_ = enabled; }

    std::span<const timeline::NoteEvent> notes() const;

    std::optional<view::Rect> note_rect(timeline::ItemId note_id) const;

    std::size_t painted_note_count() const noexcept { return painted_note_count_; }

    std::size_t visited_candidate_count() const noexcept { return visited_candidate_count_; }

    const std::vector<PianoRollRefusal>& refusals() const noexcept { return refusals_; }
    void clear_refusals() { refusals_.clear(); }

    bool gesture_open() const noexcept { return drag_.has_value(); }
 
    // ── View ─────────────────────────────────────────────────────────────
 
    void paint(canvas::Canvas& canvas) override;
    bool wants_mouse_input() const override { return true; }
    void on_mouse_down(view::Point position) override;
    void on_mouse_drag(view::Point position) override;
    void on_mouse_up(view::Point position) override;
    void on_mouse_cancel(view::Point position) override;
    void on_mouse_event(const view::MouseEvent& event) override;
 
  private:
    enum class DragKind : std::uint8_t {
        Insert, 
        Move,   
        Resize, 
        SetVelocity, 
    };

    struct Drag {
        DragKind kind = DragKind::Move;
        std::optional<timeline::NoteEvent> grabbed;
        std::int64_t grab_offset_ticks = 0;
        timebase::TickPosition press_tick{};
        std::uint8_t press_pitch = 60;
        float press_y = 0.0f;
        std::optional<timeline::NoteEvent> pending;
        std::optional<timeline::NoteEvent> last_emitted;
        std::optional<timeline::NoteEvent> last_refused;
        bool release_only = false;
    };
 
    const timeline::MidiContent* content() const;
    const timeline::NoteEvent* note_at(view::Point position) const;
    bool on_trailing_edge(const timeline::NoteEvent& note, view::Point position) const;

    timebase::TickPosition snapped(timebase::TickPosition tick) const;
    bool admissible(const timeline::NoteEvent& note);
    std::optional<timeline::NoteEvent> replacement_at(const Drag& drag,
                                                       view::Point position) const;
 
    bool emit(timeline_editor::NoteEditIntentKind kind, timeline::GesturePhase phase,
              std::optional<timeline::NoteEvent> expected,
              std::optional<timeline::NoteEvent> replacement);
 
    const timeline::Project* project_ = nullptr;
    timeline::ItemId sequence_id_{};
    timeline::ItemId track_id_{};
    timeline::ItemId clip_id_{};
    std::optional<PianoRollLayout> layout_;
    timeline_editor::NoteEditIntentHost* host_ = nullptr;
    view::HitMetrics metrics_ = view::HitMetrics::for_pointer(view::PointerType::mouse);
    NoteFactory note_factory_;
    std::optional<Drag> drag_;
    std::uint16_t current_modifiers_ = view::kModNone;
    bool continuous_gestures_ = false;
    std::vector<PianoRollRefusal> refusals_;
    std::vector<timebase::TickPosition> note_interval_max_end_;
    std::size_t painted_note_count_ = 0;
    std::size_t visited_candidate_count_ = 0;
};

 
} // namespace pulp::timeline_view