midi_editor.h

// SPDX-FileCopyrightText: © 2019-2021, 2023-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/project/editor_settings.h"
#include "utils/utf8_string.h"
 
#include <QtQmlIntegration/qqmlintegration.h>
 
#include <nlohmann/json_fwd.hpp>
 
namespace zrythm::structure::project
{

enum class MidiModifier
{
  Velocity,
  PitchWheel,
  ModWheel,
  Aftertouch,
};

class MidiNoteDescriptor
{
public:
  auto custom_name () const { return custom_name_; }
 
  void set_custom_name (const utils::Utf8String &str) { custom_name_ = str; }
 
public:
  int index_ = 0;

  int value_ = 0;

  bool visible_ = true;

  utils::Utf8String custom_name_;

  utils::Utf8String note_name_;

  utils::Utf8String note_name_pango_;

  bool marked_ = false;
};

class MidiEditor : public EditorSettings
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (int keyHeight READ keyHeight NOTIFY keyHeightChanged)
  QML_UNCREATABLE ("")
 
public:
  enum class Highlighting : std::uint8_t
  {
    None,
    Chord,
    Scale,
    Both,
  };
  Q_ENUM (Highlighting)
 
  MidiEditor (QObject * parent = nullptr);
 
private:
  static constexpr std::array<bool, 12> BLACK_NOTES = {
    false, true,  false, true,  false, false,
    true,  false, true,  false, true,  false
  };
 
public:
  // ============================================================================
  // QML Interface
  // ============================================================================
 
  int keyHeight () const { return note_height_; }
 
  Q_SIGNAL void keyHeightChanged ();
 
  Q_INVOKABLE int getKeyAtY (double y) const;
  Q_INVOKABLE static constexpr bool isBlackKey (int note)
  {
    note = std::clamp (note, 0, 127);
    return BLACK_NOTES.at (static_cast<size_t> (note) % 12);
  }
  Q_INVOKABLE static constexpr bool isWhiteKey (int note)
  {
    return !isBlackKey (note);
  }
 
  Q_INVOKABLE static constexpr bool isNextKeyBlack (int note)
  {
    return isBlackKey (note + 1);
  }
  Q_INVOKABLE static constexpr bool isNextKeyWhite (int note)
  {
    return isWhiteKey (note + 1);
  }
 
  Q_INVOKABLE static constexpr bool isPrevKeyBlack (int note)
  {
    return isBlackKey (note - 1);
  }
  Q_INVOKABLE static constexpr bool isPrevKeyWhite (int note)
  {
    return isWhiteKey (note - 1);
  }
 
  // ============================================================================

  void add_current_note (int note);

  void remove_current_note (int note);

  bool contains_current_note (int note);
 
  void set_notes_zoom (float notes_zoom, bool fire_events);

  const MidiNoteDescriptor *
  find_midi_note_descriptor_by_val (bool drum_mode, uint8_t val);

  void set_midi_modifier (MidiModifier modifier);

  void get_visible_notes (bool drum_mode, std::vector<MidiNoteDescriptor> &vec)
  {
    vec.clear ();
 
    for (const auto i : std::views::iota (0zu, 128zu))
      {
        MidiNoteDescriptor * descr;
        if (drum_mode)
          descr = &drum_descriptors_[i];
        else
          descr = &piano_descriptors_[i];
 
        if (descr->visible_)
          {
            vec.push_back (*descr);
          }
      }
  }

  void init ();
 
private:
  friend void init_from (
    MidiEditor            &obj,
    const MidiEditor      &other,
    utils::ObjectCloneType clone_type);
  friend void to_json (nlohmann::json &j, const MidiEditor &midi_editor);
  friend void from_json (const nlohmann::json &j, MidiEditor &midi_editor);
 
private:
  static constexpr auto kNotesZoomKey = "notesZoom"sv;
  static constexpr auto kMidiModifierKey = "midiModifier"sv;

  void init_descriptors ();
 
public:
  float notes_zoom_ = 1.0f;

  int note_height_{ 16 };

  MidiModifier midi_modifier_ = MidiModifier::Velocity;

  std::vector<int> current_notes_;

  std::vector<MidiNoteDescriptor> piano_descriptors_ =
    std::vector<MidiNoteDescriptor> (128);

  std::vector<MidiNoteDescriptor> drum_descriptors_ =
    std::vector<MidiNoteDescriptor> (128);
};
 
}