LooperView.hpp

#pragma once
#include <Process/Drop/ClipMetadata.hpp>
 
#include <Fx/Looper/Transport.hpp>
 
#include <halp/custom_widgets.hpp>
#include <halp/layout.hpp>
 
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <functional>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
namespace Nodes::Looper
{
struct rgba
{
  uint8_t r, g, b, a;
};
 
struct view_note
{
  float start;
  float end;
  uint8_t pitch;
  uint8_t lane;
  uint8_t velocity;
  uint8_t heard;
};
 
enum class TakeFiles
{
  Mix,
  Layers,
  Both
};
 
struct erase_request
{
  int pass;
  int layers;
  bool mute{};
  int take{};
  int last{-1};
};
 
struct view_message
{
  static constexpr int max_lanes = 32;
  static constexpr int bins = 192;
  static constexpr int max_notes = 768;
 
  int mode;
  int requested;
  int wanted;
  int layers;
  int redo;
  int lanes;
  int take;
  int notes;
  bool empty;
  bool full;
  bool writing;
  bool midi;
  bool values;
  float position;
  float length_seconds;
  float max_seconds;
  float tempo;
  double take_date;
  std::array<float, max_lanes * bins> peaks;
  std::array<view_note, max_notes> note;
  enum value_flag : uint8_t
  {
    flag_number = 1,     
    flag_other = 2,      
    flag_heard = 4,      
    flag_impulse = 8,    
    flag_mark = 16,      
    flag_heard_mark = 32 
  };
  std::array<uint8_t, max_lanes * bins> value_flags;
  std::array<char, 512> take_base;
  std::array<char, 8> take_ext;
  bool take_mix;
  int take_layers;
  bool take_placeable;
  halp::clip_stretch take_stretch;
  bool reverse;
  float speed;
  std::array<uint8_t, max_lanes> muted;
  int selected;
  bool restart_pending;
  bool new_pass_pending;
  int answered;
  int version;
  int take_version;
  std::array<char, 512> part_base;
  int part_answered;
  int part_first;
  int part_last;
  int part_answer;
  bool part_placeable;
  halp::clip_stretch part_stretch;
  bool stopped;
  uint64_t looper;
  int stops;
 
  void set_take(
      std::string_view base, std::string_view ext, bool mix, int layers,
      halp::clip_stretch stretch = halp::clip_stretch::automatic,
      bool placeable = true) noexcept
  {
    take_placeable = placeable;
    const auto n = std::min(base.size(), take_base.size() - 1);
    std::copy_n(base.data(), n, take_base.data());
    take_base[n] = 0;
    const auto e = std::min(ext.size(), take_ext.size() - 1);
    std::copy_n(ext.data(), e, take_ext.data());
    take_ext[e] = 0;
    take_mix = mix;
    take_layers = layers;
    take_stretch = stretch;
  }
 
  void set_part(
      std::string_view base, int first, int last, int request, halp::clip_stretch stretch,
      bool placeable) noexcept
  {
    const auto n = std::min(base.size(), part_base.size() - 1);
    std::copy_n(base.data(), n, part_base.data());
    part_base[n] = 0;
    part_first = first;
    part_last = last;
    part_answer = request;
    part_stretch = stretch;
    part_placeable = placeable;
  }
 
  std::vector<std::string> layer_files(const char* base_chars, int first, int last) const
  {
    std::vector<std::string> files;
    const std::string base{base_chars}, ext{take_ext.data()};
    if(base.empty())
      return files;
    for(int k = first; k <= last; k++)
      files.push_back(base + "-layer" + std::to_string(k + 1) + "." + ext);
    return files;
  }
 
  std::vector<std::string> take_files() const
  {
    std::vector<std::string> files;
    const std::string base{take_base.data()}, ext{take_ext.data()};
    if(base.empty())
      return files;
    if(take_mix)
      files.push_back(base + "." + ext);
    auto layers = layer_files(take_base.data(), 0, take_layers - 1);
    files.insert(files.end(), layers.begin(), layers.end());
    return files;
  }
 
  std::vector<std::string> part_files() const
  {
    return layer_files(part_base.data(), part_first, part_last);
  }
};
 
struct looper_view
{
  static constexpr double width() { return 360.; }
  static constexpr double height() { return 238.; }
  static constexpr double header = 26.;
  static constexpr double send_w = 56.;
 
  view_message state{};
  bool has_state{};
 
  std::function<void()> update;
  std::function<void(halp::timeline_clip)> send_to_timeline;
  std::function<void(erase_request)> erase;
 
  int m_requests{};
  int m_waiting{};
  bool m_send_waiting{};
 
  TakeFiles m_export{TakeFiles::Mix};
  void watch(const auto& exported)
  {
    const auto files = TakeFiles(exported.value);
    if(files == m_export)
      return;
    m_export = files;
    if(update)
      update();
  }
 
  uint64_t m_stopped_looper{};
  int m_stopped_stops{-1};
 
  using clock = std::chrono::steady_clock;
  static constexpr auto silent_after = std::chrono::milliseconds(300);
  clock::time_point m_last_message{};
  bool live() const noexcept
  {
    return has_state && clock::now() - m_last_message < silent_after;
  }
  bool waiting() const noexcept { return m_waiting > 0 && live(); }
 
  void receive(const view_message& m) noexcept
  {
    if(m.looper == m_stopped_looper && m.stops < m_stopped_stops)
      return;
    if(m.stopped)
    {
      // The looper does not run any more: nothing asked of it will come.
      m_stopped_looper = m.looper;
      m_stopped_stops = m.stops;
      m_last_message = {};
      m_waiting = 0;
      m_send_waiting = false;
      m_part_waiting = 0;
      state = m;
      has_state = true;
      if(update)
        update();
      return;
    }
    // After a silence the looper may be another one, made when the score
    // played again, which knows nothing of what was asked before.
    if(!live())
    {
      m_waiting = 0;
      m_send_waiting = false;
      m_part_waiting = 0;
    }
    m_last_message = clock::now();
    state = m;
    has_state = true;
    if(m_waiting > 0 && m.answered >= m_waiting)
    {
      m_waiting = 0;
      if(std::exchange(m_send_waiting, false))
        send_now();
    }
    if(m_part_waiting > 0 && m.part_answered >= m_part_waiting)
    {
      // Answered with the files, or with nothing when the loop changed.
      if(m.part_answer == m_part_waiting)
      {
        m_part_files = m.part_files();
        m_part_placeable = m.part_placeable;
        m_part_stretch = m.part_stretch;
      }
      else
        m_part_files.clear();
      m_part_waiting = 0;
    }
    if(update)
      update();
  }
 
  int m_part_waiting{};
  int m_part_lane{-1};
  int m_part_first{-1};
  int m_part_last{-1};
  std::vector<std::string> m_part_files;
  bool m_part_placeable{};
  halp::clip_stretch m_part_stretch{};
  bool m_button_pressed{};
  mutable bool m_dragged{};
 
  std::pair<int, int> lane_passes(int lane) const noexcept
  {
    const auto& s = state;
    if(!has_state || s.empty || lane < 0 || lane >= s.lanes)
      return {-1, -1};
    const int merged = s.layers - s.lanes;
    if(merged > 0 && lane == 0)
      return {0, merged};
    return {lane + std::max(0, merged), lane + std::max(0, merged)};
  }
 
  bool take_has_layers() const noexcept
  {
    return placeable() && !taking_in() && state.take_layers >= state.layers
           && state.take_version == state.version && state.take_layers > 0;
  }
 
  std::vector<std::string> lane_files(int lane) const
  {
    const auto [first, last] = lane_passes(lane);
    if(first < 0)
      return {};
    if(take_has_layers())
      return state.layer_files(state.take_base.data(), first, last);
    // Written for the press that asked for them: the next press asks again.
    if(m_part_waiting == 0 && m_part_first == first && m_part_last == last
       && m_part_placeable)
      return m_part_files;
    return {};
  }
 
  void request_part(int lane)
  {
    const auto [first, last] = lane_passes(lane);
    if(first < 0 || !erase || !live() || m_part_waiting > 0)
      return;
    m_requests = std::max({m_requests, state.answered, state.part_answered}) + 1;
    m_part_waiting = m_requests;
    m_part_lane = lane;
    m_part_first = first;
    m_part_last = last;
    m_part_files.clear();
    erase(erase_request{
        .pass = first, .layers = state.layers, .mute = false, .take = m_part_waiting,
        .last = last});
    if(update)
      update();
  }
  bool preparing(int lane) const noexcept
  {
    return m_part_waiting > 0 && live() && m_part_lane == lane;
  }
 
  bool has_take() const noexcept { return has_state && state.take > 0 && state.take_base[0]; }
  bool placeable() const noexcept { return has_take() && state.take_placeable; }
 
  bool taking_in() const noexcept
  {
    if(!live() || state.empty)
      return false;
    const auto m = LoopMode(state.mode);
    return m == LoopMode::Record || m == LoopMode::Overdub;
  }
  bool saving() const noexcept { return waiting() || (live() && state.writing); }
 
  bool take_has_export() const noexcept
  {
    return (m_export == TakeFiles::Layers || state.take_mix)
           && (m_export == TakeFiles::Mix || state.take_layers > 0);
  }
 
  bool needs_take() const noexcept
  {
    return erase && live() && !state.empty && (taking_in() || !take_has_export());
  }
 
  std::vector<std::string> send_files() const
  {
    if(!take_has_export())
      return state.take_files();
    std::vector<std::string> files;
    const std::string base{state.take_base.data()}, ext{state.take_ext.data()};
    if(base.empty())
      return files;
    if(m_export != TakeFiles::Layers)
      files.push_back(base + "." + ext);
    if(m_export != TakeFiles::Mix)
    {
      auto layers = state.layer_files(state.take_base.data(), 0, state.take_layers - 1);
      files.insert(files.end(), layers.begin(), layers.end());
    }
    return files;
  }
 
  void request_take()
  {
    if(waiting() || !erase)
      return;
    // Above what the looper answered already: another view of it may have
    // asked before.
    m_requests = std::max({m_requests, has_state ? state.answered : 0,
                           has_state ? state.part_answered : 0})
                 + 1;
    m_waiting = m_requests;
    erase(erase_request{.pass = -1, .layers = -1, .mute = false, .take = m_waiting});
    if(update)
      update();
  }
 
  void send()
  {
    if(needs_take())
    {
      m_send_waiting = true;
      request_take();
      return;
    }
    send_now();
  }
 
  void send_now()
  {
    if(!placeable() || !send_to_timeline)
      return;
    std::string_view base{state.take_base.data()};
    if(auto slash = base.find_last_of("/\\"); slash != std::string_view::npos)
      base.remove_prefix(slash + 1);
    send_to_timeline(halp::timeline_clip{
        .files = send_files(),
        .date = state.take_date,
        .name = std::string{base},
        .stretch = state.take_stretch});
  }
 
  static rgba mode_color(int mode, bool empty) noexcept
  {
    if(empty && mode != int(LoopMode::Record))
      return {110, 110, 116, 255};
    switch(LoopMode(mode))
    {
      case LoopMode::Record:
        return {232, 64, 60, 255};
      case LoopMode::Overdub:
        return {255, 150, 40, 255};
      case LoopMode::Play:
        return {88, 200, 112, 255};
      case LoopMode::Stop:
      default:
        return {150, 150, 156, 255};
    }
  }
 
  static const char* mode_name(int mode) noexcept
  {
    switch(LoopMode(mode))
    {
      case LoopMode::Record:
        return "Record";
      case LoopMode::Overdub:
        return "Overdub";
      case LoopMode::Play:
        return "Play";
      case LoopMode::Stop:
      default:
        return "Stop";
    }
  }
 
  static rgba dimmed(rgba c) noexcept
  {
    constexpr rgba bg{34, 34, 38, 255};
    return {
        uint8_t((c.r + 2 * bg.r) / 3), uint8_t((c.g + 2 * bg.g) / 3),
        uint8_t((c.b + 2 * bg.b) / 3), 255};
  }
 
  static rgba lane_color(int lane, int lanes) noexcept
  {
    static constexpr rgba palette[]{
        {74, 160, 220, 255}, {86, 190, 170, 255}, {150, 200, 90, 255},
        {220, 190, 70, 255}, {230, 140, 70, 255}, {210, 100, 130, 255},
        {160, 110, 210, 255}, {110, 130, 230, 255}};
    (void)lanes;
    return palette[lane % 8];
  }
 
  void paint(auto ctx)
  {
    const double w = width(), h = height();
    ctx.set_fill_color({24, 24, 26, 255});
    ctx.begin_path();
    ctx.draw_rect(0., 0., w, h);
    ctx.fill();
 
    const auto& s = state;
    const auto col = mode_color(has_state ? s.mode : int(LoopMode::Stop), !has_state || s.empty);
 
    // Header: progress ring, mode, what it is waiting for, length and passes.
    {
      const double cx = 13., cy = header / 2., r = 8.;
      ctx.set_stroke_color({60, 60, 64, 255});
      ctx.set_stroke_width(3.);
      ctx.begin_path();
      ctx.draw_circle(cx, cy, r);
      ctx.stroke();
      if(has_state && !s.empty)
      {
        ctx.set_stroke_color({col.r, col.g, col.b, col.a});
        ctx.begin_path();
        ctx.move_to(cx, cy - r);
        ctx.arc_to(cx - r, cy - r, 2. * r, 2. * r, 90., -360. * s.position);
        ctx.stroke();
      }
      ctx.set_stroke_width(1.);
 
      char text[160];
      if(!has_state)
        std::snprintf(text, sizeof(text), "Play to start looping");
      else if(s.stopped)
        std::snprintf(text, sizeof(text), "Stopped with the score");
      else if(s.wanted != s.requested)
        std::snprintf(
            text, sizeof(text), "%s, then %s on the grid", mode_name(s.mode),
            mode_name(s.wanted));
      else if(s.new_pass_pending || s.restart_pending)
        std::snprintf(
            text, sizeof(text), "%s, then %s on the grid", mode_name(s.mode),
            s.new_pass_pending ? (s.restart_pending ? "new layer from the start" : "new layer")
                               : "from the start");
      else
        std::snprintf(
            text, sizeof(text), "%s%s%s%s", mode_name(s.mode),
            s.reverse ? ", reverse" : "", speed_name()[0] ? " " : "", speed_name());
 
      ctx.set_fill_color({col.r, col.g, col.b, col.a});
      ctx.begin_path();
      ctx.draw_text(28., cy + 4., text);
      ctx.fill();
 
      if(has_state)
      {
        // Against the Send button, whatever its length.
        char info[160];
        std::snprintf(
            info, sizeof(info), "%.1f s%s%s", s.length_seconds, s.full ? ", full" : "",
            s.redo > 0 ? "  (redo)" : "");
        double info_w = 6.5 * std::strlen(info);
        if constexpr(requires { ctx.text_width(std::string_view{}); })
          info_w = ctx.text_width(info);
        ctx.set_fill_color({170, 170, 176, 255});
        ctx.begin_path();
        ctx.draw_text(w - send_w - 10. - info_w, cy + 4., info);
        ctx.fill();
      }
 
      // Send to timeline. A take the timeline cannot play is a file only.
      const bool file_only = has_take() && !state.take_placeable && !taking_in();
      const bool enabled = (placeable() || taking_in()) && bool(send_to_timeline);
      const rgba button = enabled ? rgba{60, 110, 160, 255} : rgba{44, 44, 48, 255};
      ctx.set_fill_color({button.r, button.g, button.b, button.a});
      ctx.begin_path();
      ctx.draw_rounded_rect(w - send_w - 4., 4., send_w, header - 8., 3.);
      ctx.fill();
      const rgba label = enabled ? rgba{235, 240, 245, 255} : rgba{110, 110, 116, 255};
      ctx.set_fill_color({label.r, label.g, label.b, label.a});
      // A grip: the button is also where the whole take is dragged from.
      ctx.begin_path();
      for(int row = 0; row < 3; row++)
        for(int col = 0; col < 2; col++)
          ctx.draw_rect(w - send_w + 1. + col * 3., cy - 4. + row * 3.5, 1.5, 1.5);
      ctx.fill();
      ctx.begin_path();
      ctx.draw_text(
          w - send_w + 9., cy + 4., saving() ? "Saving" : (file_only ? "File" : "Send"));
      ctx.fill();
    }
 
    const double top = header, lanes_h = h - header - 4.;
    if(!has_state || s.empty)
    {
      if(has_take())
      {
        ctx.set_fill_color({120, 120, 126, 255});
        ctx.begin_path();
        ctx.draw_text(10., top + lanes_h / 2., "The last take can still be sent.");
        ctx.fill();
      }
      return;
    }
 
    if(s.midi)
      paint_notes(ctx, top, lanes_h);
    else if(s.values)
      paint_values(ctx, top, lanes_h);
    else
      paint_lanes(ctx, top, lanes_h);
 
    // Playhead, with an arrow the way it goes.
    const double x = 4. + s.position * (w - 8.);
    ctx.set_stroke_color({col.r, col.g, col.b, col.a});
    ctx.set_stroke_width(2.);
    ctx.begin_path();
    ctx.move_to(x, top);
    ctx.line_to(x, top + lane_count() * lane_height());
    ctx.stroke();
    ctx.set_stroke_width(1.);
    {
      const double dir = s.reverse ? -1. : 1.;
      ctx.set_fill_color({col.r, col.g, col.b, col.a});
      ctx.begin_path();
      ctx.move_to(x, top);
      ctx.line_to(x + dir * 7., top + 4.);
      ctx.line_to(x, top + 8.);
      ctx.close_path();
      ctx.fill();
    }
 
    paint_erase_boxes(ctx);
    paint_preparing(ctx);
  }
 
  void paint_preparing(auto& ctx)
  {
    if(m_part_waiting <= 0 || !live() || m_part_lane < 0 || m_part_lane >= lane_count())
      return;
    const double lh = lane_height();
    const double y = lanes_top + m_part_lane * lh;
    ctx.set_fill_color({24, 24, 26, 170});
    ctx.begin_path();
    ctx.draw_rect(lanes_x, y + 1., lanes_width(), lh - 2.);
    ctx.fill();
    ctx.set_fill_color({235, 240, 245, 255});
    ctx.begin_path();
    ctx.draw_text(lanes_x + 8., y + lh / 2. + 4., "Preparing");
    ctx.fill();
  }
 
  const char* speed_name() const noexcept
  {
    for(auto& [name, value] : speeds)
      if(value != 1.f && std::abs(value - state.speed) < 1e-4f)
        return name;
    return "";
  }
 
  // The lanes: one per pass, the oldest passes all in the first one when
  // there are more passes than lanes.
  static constexpr double lanes_top = header;
  static constexpr double lanes_x = 4.;
  static double lanes_height() noexcept { return height() - header - 4.; }
  static double lanes_width() noexcept { return width() - 8.; }
  int lane_count() const noexcept { return std::max(1, state.lanes); }
  static constexpr double max_lane_height = 72.;
  static constexpr double min_lane_height = 6.;
  double lane_height() const noexcept
  {
    return std::clamp(lanes_height() / lane_count(), min_lane_height, max_lane_height);
  }
 
  int pass_of_lane(int lane) const noexcept
  {
    const auto& s = state;
    if(!has_state || s.empty || lane < 0 || lane >= s.lanes)
      return -1;
    const int merged = s.layers - s.lanes;
    if(merged > 0 && lane == 0)
      return -1;
    return lane + merged;
  }
 
  struct box
  {
    double x, y, size;
    bool contains(double px, double py) const noexcept
    {
      return px >= x - 1. && px <= x + size + 1. && py >= y - 1. && py <= y + size + 1.;
    }
  };
 
  box erase_box(int lane) const noexcept
  {
    const double lh = lane_height();
    const double size = std::clamp(lh - 3., 5., 12.);
    const double y = lanes_top + lane * lh + (lh - size) / 2.;
    return {lanes_x + lanes_width() - size - 3., y, size};
  }
 
  box mute_box(int lane) const noexcept
  {
    const auto e = erase_box(lane);
    return {e.x - e.size - 4., e.y, e.size};
  }
 
  bool lane_muted(int lane) const noexcept
  {
    return lane >= 0 && lane < view_message::max_lanes && state.muted[lane];
  }
 
  int selected_lane() const noexcept
  {
    const int lane = state.selected - (state.layers - state.lanes);
    return pass_of_lane(lane) >= 0 && pass_of_lane(lane) == state.selected ? lane : -1;
  }
 
  static constexpr rgba lane_bg{34, 34, 38, 255};
  static constexpr rgba selected_bg{46, 46, 54, 255};
  rgba lane_background(int lane) const noexcept
  {
    return lane == selected_lane() ? selected_bg : lane_bg;
  }
  void outline_selected(auto& ctx, double top, double lh) const
  {
    const int l = selected_lane();
    if(l < 0)
      return;
    ctx.set_stroke_color({190, 190, 200, 150});
    ctx.set_stroke_width(1.);
    ctx.begin_path();
    ctx.draw_rect(4.5, top + l * lh + 1.5, width() - 9., lh - 3.);
    ctx.stroke();
  }
 
  int erase_lane_at(double x, double y) const noexcept
  {
    if(!erase)
      return -1;
    for(int l = 0; l < lane_count(); l++)
      if(pass_of_lane(l) >= 0 && erase_box(l).contains(x, y))
        return l;
    return -1;
  }
 
  int mute_lane_at(double x, double y) const noexcept
  {
    if(!erase)
      return -1;
    for(int l = 0; l < lane_count(); l++)
      if(pass_of_lane(l) >= 0 && mute_box(l).contains(x, y))
        return l;
    return -1;
  }
 
  void paint_erase_boxes(auto& ctx)
  {
    if(!erase)
      return;
    for(int l = 0; l < lane_count(); l++)
    {
      if(pass_of_lane(l) < 0)
        continue;
      {
        const auto b = mute_box(l);
        const bool muted = lane_muted(l);
        const rgba fill = muted ? rgba{230, 160, 60, 255} : rgba{44, 44, 50, 230};
        const rgba ink = muted ? rgba{24, 24, 26, 255} : rgba{210, 210, 216, 255};
        ctx.set_fill_color({fill.r, fill.g, fill.b, fill.a});
        ctx.begin_path();
        ctx.draw_rounded_rect(b.x, b.y, b.size, b.size, 2.);
        ctx.fill();
        // An m: two arches.
        const double m = std::max(2., b.size * 0.25);
        const double x0 = b.x + m, x1 = b.x + b.size - m, xm = (x0 + x1) / 2.;
        const double y0 = b.y + m, y1 = b.y + b.size - m;
        ctx.set_stroke_color({ink.r, ink.g, ink.b, ink.a});
        ctx.set_stroke_width(1.5);
        ctx.begin_path();
        ctx.move_to(x0, y1);
        ctx.line_to(x0, y0);
        ctx.line_to(xm, (y0 + y1) / 2.);
        ctx.line_to(x1, y0);
        ctx.line_to(x1, y1);
        ctx.stroke();
        ctx.set_stroke_width(1.);
      }
      const auto b = erase_box(l);
      ctx.set_fill_color({44, 44, 50, 230});
      ctx.begin_path();
      ctx.draw_rounded_rect(b.x, b.y, b.size, b.size, 2.);
      ctx.fill();
      const double m = std::max(2., b.size * 0.28);
      ctx.set_stroke_color({210, 210, 216, 255});
      ctx.set_stroke_width(1.5);
      ctx.begin_path();
      ctx.move_to(b.x + m, b.y + m);
      ctx.line_to(b.x + b.size - m, b.y + b.size - m);
      ctx.move_to(b.x + b.size - m, b.y + m);
      ctx.line_to(b.x + m, b.y + b.size - m);
      ctx.stroke();
      ctx.set_stroke_width(1.);
    }
  }
 
  void paint_lanes(auto& ctx, double top, double)
  {
    const auto& s = state;
    const int lanes = std::max(1, s.lanes);
    const double lh = lane_height();
    const double x0 = 4., lw = width() - 8.;
    const double bw = lw / view_message::bins;
    for(int l = 0; l < lanes; l++)
    {
      const double y = top + l * lh;
      const double mid = y + lh / 2.;
      const auto bg = lane_background(l);
      ctx.set_fill_color({bg.r, bg.g, bg.b, bg.a});
      ctx.begin_path();
      ctx.draw_rect(x0, y + 1., lw, lh - 2.);
      ctx.fill();
 
      auto c = lane_color(l, lanes);
      if(lane_muted(l))
        c = dimmed(c);
      ctx.set_fill_color({c.r, c.g, c.b, c.a});
      ctx.begin_path();
      const float* p = s.peaks.data() + l * view_message::bins;
      for(int b = 0; b < view_message::bins; b++)
      {
        const double a = std::min(1.f, p[b]) * (lh / 2. - 1.5);
        if(a > 0.25)
          ctx.draw_rect(x0 + b * bw, mid - a, std::max(1., bw - 0.5), 2. * a);
      }
      ctx.fill();
    }
    outline_selected(ctx, top, lh);
  }
 
  void paint_notes(auto& ctx, double top, double)
  {
    const auto& s = state;
    const int lanes = std::max(1, s.lanes);
    const double lh = lane_height();
    const double x0 = 4., lw = width() - 8.;
 
    std::array<int, view_message::max_lanes> lo, hi;
    lo.fill(127);
    hi.fill(0);
    for(int i = 0; i < s.notes; i++)
    {
      const auto& n = s.note[i];
      const int l = std::min<int>(n.lane, view_message::max_lanes - 1);
      lo[l] = std::min<int>(lo[l], n.pitch);
      hi[l] = std::max<int>(hi[l], n.pitch);
    }
 
    for(int l = 0; l < lanes; l++)
    {
      const double y = top + l * lh;
      const auto lbg = lane_background(l);
      ctx.set_fill_color({lbg.r, lbg.g, lbg.b, lbg.a});
      ctx.begin_path();
      ctx.draw_rect(x0, y + 1., lw, lh - 2.);
      ctx.fill();
      if(lo[l] > hi[l])
        continue;
      lo[l] = std::max(0, lo[l] - 1);
      hi[l] = std::min(127, hi[l] + 1);
    }
 
    // The notes not heard first, so that the ones heard are drawn over them.
    for(int heard = 0; heard < 2; heard++)
    {
      for(int i = 0; i < s.notes; i++)
      {
        const auto& n = s.note[i];
        if(bool(n.heard) != bool(heard))
          continue;
        const int l = std::min<int>(n.lane, lanes - 1);
        const double rh = (lh - 3.) / (hi[l] - lo[l] + 1);
        const double y = top + l * lh + 1.5 + (hi[l] - n.pitch) * rh;
        const double nh = std::clamp(rh - 0.5, 2., 6.);
        auto c = lane_color(l, lanes);
        if(!heard)
          c = dimmed(c);
        ctx.set_fill_color({c.r, c.g, c.b, c.a});
        ctx.begin_path();
        const double a = x0 + n.start * lw;
        const double yc = std::round(y + (rh - nh) / 2.);
        if(n.end >= n.start)
          ctx.draw_rect(a, yc, std::max(2., (n.end - n.start) * lw), nh);
        else
        {
          ctx.draw_rect(a, yc, std::max(2., (1. - n.start) * lw), nh);
          ctx.draw_rect(x0, yc, std::max(2., n.end * lw), nh);
        }
        ctx.fill();
      }
    }
    outline_selected(ctx, top, lh);
  }
 
  void paint_values(auto& ctx, double top, double)
  {
    const auto& s = state;
    const int lanes = std::max(1, s.lanes);
    const double lh = lane_height();
    const double x0 = 4., lw = width() - 8.;
    const double bw = lw / view_message::bins;
    for(int l = 0; l < lanes; l++)
    {
      const double y = top + l * lh;
      const auto bg = lane_background(l);
      ctx.set_fill_color({bg.r, bg.g, bg.b, bg.a});
      ctx.begin_path();
      ctx.draw_rect(x0, y + 1., lw, lh - 2.);
      ctx.fill();
 
      const float* p = s.peaks.data() + l * view_message::bins;
      const uint8_t* f = s.value_flags.data() + l * view_message::bins;
      const auto base = lane_color(l, lanes);
      const auto quiet = dimmed(base);
      const double inner = std::max(2., lh - 8.);
      auto height = [&](int b) {
        if(f[b] & view_message::flag_number)
          return y + 4. + (1. - std::clamp(double(p[b]), 0., 1.)) * inner;
        return y + lh / 2.;
      };
      // The heard parts over the others.
      for(int heard = 0; heard < 2; heard++)
      {
        auto c = heard ? base : quiet;
        if(lane_muted(l))
          c = dimmed(c);
        ctx.set_stroke_color({c.r, c.g, c.b, c.a});
        ctx.set_stroke_width(heard ? 1.5 : 1.);
        ctx.begin_path();
        for(int b = 0; b < view_message::bins; b++)
        {
          const bool held = f[b] & (view_message::flag_number | view_message::flag_other);
          if(!held || bool(f[b] & view_message::flag_heard) != bool(heard))
            continue;
          const double xa = x0 + b * bw, ya = height(b);
          ctx.move_to(xa, ya);
          ctx.line_to(xa + bw, ya);
          // The step to the next bin's value.
          if(b + 1 < view_message::bins
             && (f[b + 1] & (view_message::flag_number | view_message::flag_other)))
          {
            const double yb = height(b + 1);
            if(std::abs(yb - ya) > 0.5)
            {
              ctx.move_to(xa + bw, ya);
              ctx.line_to(xa + bw, yb);
            }
          }
        }
        ctx.stroke();
      }
      ctx.set_stroke_width(1.);
 
      // Impulses and values that are not numbers: ticks.
      for(int b = 0; b < view_message::bins; b++)
      {
        if(!(f[b] & (view_message::flag_impulse | view_message::flag_mark)))
          continue;
        const bool heard = (f[b] & view_message::flag_heard_mark)
                           || ((f[b] & view_message::flag_mark) && !lane_muted(l));
        auto c = heard ? base : quiet;
        ctx.set_fill_color({c.r, c.g, c.b, c.a});
        ctx.begin_path();
        const double xa = x0 + b * bw;
        if(f[b] & view_message::flag_impulse)
          ctx.draw_rect(xa, y + 2., std::max(1.5, bw), lh - 4.);
        else
          ctx.draw_rect(xa, y + lh / 2. - 3., std::max(2., bw), 6.);
        ctx.fill();
      }
    }
    outline_selected(ctx, top, lh);
  }
 
  bool in_send(double x, double y) const noexcept
  {
    return x >= width() - send_w - 4. && x <= width() - 4. && y >= 4. && y <= header - 4.;
  }
 
  int lane_at(double x, double y) const noexcept
  {
    if(!has_state || state.empty || x < lanes_x || x > lanes_x + lanes_width())
      return -1;
    const double lh = lane_height();
    if(y < lanes_top || y >= lanes_top + lane_count() * lh)
      return -1;
    return std::min(lane_count() - 1, int((y - lanes_top) / lh));
  }
 
  bool mouse_press(double x, double y)
  {
    m_dragged = false;
    m_button_pressed = false;
    if(m_part_waiting == 0)
    {
      m_part_files.clear();
      m_part_first = m_part_last = -1;
    }
    if(in_send(x, y))
    {
      // The take is asked for at once: a drag waits for it, a click sends it.
      m_button_pressed = true;
      if(needs_take())
        request_take();
      return true;
    }
    if(const int lane = erase_lane_at(x, y); lane >= 0)
    {
      erase(erase_request{.pass = pass_of_lane(lane), .layers = state.layers, .mute = false});
      return true;
    }
    if(const int lane = mute_lane_at(x, y); lane >= 0)
    {
      erase(erase_request{.pass = pass_of_lane(lane), .layers = state.layers, .mute = true});
      return true;
    }
    // A press on a lane is the start of a drag of its passes.
    const int lane = lane_at(x, y);
    if(lane < 0)
      return false;
    if(!lane_files(lane).empty())
      return true;
    if(live() && erase)
    {
      request_part(lane);
      return true;
    }
    return false;
  }
  void mouse_move(double, double) { }
  void mouse_release(double x, double y)
  {
    if(std::exchange(m_button_pressed, false) && !m_dragged && in_send(x, y))
      send();
  }
 
  halp::drag_payload drag_payload(double x, double y) const
  {
    halp::drag_payload p;
    halp::clip_stretch stretch = state.take_stretch;
    if(in_send(x, y))
    {
      // The take, as Send places it.
      if(waiting() || !placeable())
        return p;
      p.files = send_files();
    }
    else if(const int lane = lane_at(x, y);
            lane >= 0 && erase_lane_at(x, y) < 0 && mute_lane_at(x, y) < 0)
    {
      if(preparing(lane))
        return p;
      p.files = lane_files(lane);
      if(!take_has_layers())
        stretch = m_part_stretch;
    }
    if(p.files.empty())
      return p;
    m_dragged = true;
    // A take is a loop wherever it is dropped.
    p.data = Process::encode_clip_metadata(p.files, stretch, true);
    if(!p.data.empty())
      p.mime = Process::clip_metadata_mime;
    return p;
  }
};
 
template <typename Inputs>
struct looper_view_item : halp::custom_actions_item<looper_view>
{
  static constexpr auto watched() { return std::tuple{&Inputs::exported}; }
};
 
static_assert(
    view_message::max_lanes * looper_view::min_lane_height
    <= looper_view::height() - looper_view::header - 4.);
}