piano_roll.h

// SPDX-FileCopyrightText: © 2019-2021, 2023-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/arrangement/editor_settings.h"
#include "utils/icloneable.h"
 
namespace zrythm::structure::arrangement
{
enum class MidiModifier
{
  Velocity,
  PitchWheel,
  ModWheel,
  Aftertouch,
};

class MidiNoteDescriptor
{
public:
  auto get_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 PianoRoll : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (
    zrythm::structure::arrangement::EditorSettings * editorSettings READ
      getEditorSettings CONSTANT FINAL)
  Q_PROPERTY (int keyHeight READ getKeyHeight NOTIFY keyHeightChanged)
  QML_UNCREATABLE ("")
 
public:
   * Highlighting for the piano roll.
   */
  enum class Highlighting : std::uint8_t
  {
    None,
    Chord,
    Scale,
    Both,
  };
 
  PianoRoll (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
  // ============================================================================
 
  auto getEditorSettings () const { return editor_settings_.get (); }
 
  int getKeyHeight () const { return note_height_; }
 
  Q_SIGNAL void keyHeightChanged ();
 
  Q_INVOKABLE int getKeyAtY (double y) const;
   * Returns if the key is black.
   */
  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_highlighting (Highlighting highlighting);

  void set_midi_modifier (MidiModifier modifier);

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

  void init ();
 
  friend void init_from (
    PianoRoll             &obj,
    const PianoRoll       &other,
    utils::ObjectCloneType clone_type)
  {
    obj.editor_settings_ =
      utils::clone_unique_qobject (*other.editor_settings_, &obj);
  }
 
private:
  static constexpr auto kEditorSettingsKey = "editorSettings"sv;
  static constexpr auto kNotesZoomKey = "notesZoom"sv;
  static constexpr auto kMidiModifierKey = "midiModifier"sv;
  friend void           to_json (nlohmann::json &j, const PianoRoll &piano_roll)
  {
    j[kEditorSettingsKey] = piano_roll.editor_settings_;
    j[kNotesZoomKey] = piano_roll.notes_zoom_;
    j[kMidiModifierKey] = piano_roll.midi_modifier_;
  }
  friend void from_json (const nlohmann::json &j, PianoRoll &piano_roll)
  {
    j.at (kEditorSettingsKey).get_to (piano_roll.editor_settings_);
    j.at (kNotesZoomKey).get_to (piano_roll.notes_zoom_);
    j.at (kMidiModifierKey).get_to (piano_roll.midi_modifier_);
  }

  void init_descriptors ();
 
public:
  utils::QObjectUniquePtr<EditorSettings> editor_settings_;

  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);

  Highlighting highlighting_ = Highlighting::None;

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