midi_note.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include <cstdint>
#include <memory>
 
#include "dsp/position.h"
#include "gui/dsp/bounded_object.h"
#include "gui/dsp/muteable_object.h"
#include "gui/dsp/velocity.h"


class MidiNote final
    : public QObject,
      public MuteableObject,
      public RegionOwnedObject,
      public BoundedObject,
      public ICloneable<MidiNote>
{
  Q_OBJECT
  QML_ELEMENT
  DEFINE_ARRANGER_OBJECT_QML_PROPERTIES (MidiNote)
  DEFINE_BOUNDED_OBJECT_QML_PROPERTIES (MidiNote)
  Q_PROPERTY (int pitch READ getPitch WRITE setPitch NOTIFY pitchChanged)
 
public:
  using RegionT = MidiRegion;
 
  DECLARE_FINAL_ARRANGER_OBJECT_CONSTRUCTORS (MidiNote)
 
  Q_DISABLE_COPY_MOVE (MidiNote)
  ~MidiNote () override = default;
 
  enum class Notation
  {
    Musical,
    Pitch,
  };
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  int getPitch () const { return static_cast<int> (pitch_); }
 
  void setPitch (int ipitch)
  {
    const auto pitch = static_cast<midi_byte_t> (ipitch);
    if (pitch_ != pitch)
      {
        pitch_ = pitch;
        Q_EMIT pitchChanged ();
      }
  }
  Q_SIGNAL void pitchChanged ();
 
  // ========================================================================
 
  void set_cache_val (const uint8_t val) { cache_pitch_ = val; }

  utils::Utf8String
  get_val_as_string (Notation notation, bool use_markup) const;

  void listen (bool listen);

  void shift_pitch (int delta);
 
  void set_velocity (int vel) { vel_->setValue (vel); }

  void set_pitch (uint8_t val);
 
  ArrangerObjectPtrVariant
  add_clone_to_project (bool fire_events) const override;
 
  ArrangerObjectPtrVariant insert_clone_to_project () const override;
 
  // friend bool operator== (const MidiNote &lhs, const MidiNote &rhs);
 
  utils::Utf8String gen_human_friendly_name () const override;
 
  bool
  validate (bool is_project, dsp::FramesPerTick frames_per_tick) const override;
 
  void init_after_cloning (const MidiNote &other, ObjectCloneType clone_type)
    override;
 
private:
  static constexpr std::string_view kVelocityKey = "velocity";
  static constexpr std::string_view kPitchKey = "pitch";
  friend void to_json (nlohmann::json &j, const MidiNote &note)
  {
    to_json (j, static_cast<const ArrangerObject &> (note));
    to_json (j, static_cast<const BoundedObject &> (note));
    to_json (j, static_cast<const MuteableObject &> (note));
    to_json (j, static_cast<const RegionOwnedObject &> (note));
    j[kVelocityKey] = note.vel_;
    j[kPitchKey] = note.pitch_;
  }
  friend void from_json (const nlohmann::json &j, MidiNote &note)
  {
    from_json (j, static_cast<ArrangerObject &> (note));
    from_json (j, static_cast<BoundedObject &> (note));
    from_json (j, static_cast<MuteableObject &> (note));
    from_json (j, static_cast<RegionOwnedObject &> (note));
    j.at (kVelocityKey).get_to (*note.vel_);
    j.at (kPitchKey).get_to (note.pitch_);
  }
 
public:
  Velocity * vel_{};

  uint8_t pitch_{};

  uint8_t cache_pitch_{};

  bool currently_listened_{};

  uint8_t last_listened_pitch_{};
};
 
inline bool
operator== (const MidiNote &lhs, const MidiNote &rhs)
{
  return lhs.pitch_ == rhs.pitch_ && *lhs.vel_ == *rhs.vel_
         && static_cast<const MuteableObject &> (lhs)
              == static_cast<const MuteableObject &> (rhs)
         && static_cast<const RegionOwnedObject &> (lhs)
              == static_cast<const RegionOwnedObject &> (rhs)
         && static_cast<const BoundedObject &> (lhs)
              == static_cast<const BoundedObject &> (rhs)
         && static_cast<const ArrangerObject &> (lhs)
              == static_cast<const ArrangerObject &> (rhs);
}
 
DEFINE_OBJECT_FORMATTER (MidiNote, MidiNote, [] (const MidiNote &mn) {
  return fmt::format (
    "MidiNote [{} ~ {}]: note {}, vel {}", mn.get_position (),
    mn.get_end_position (), mn.pitch_, mn.vel_->vel_);
});