Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <AH/STL/cstdint>
       4             : #include <Settings/NamespaceSettings.hpp>
       5             : 
       6             : BEGIN_CS_NAMESPACE
       7             : 
       8             : namespace Interfaces {
       9             : 
      10             : /// Abstract interface for MIDI input elements that receive and store a 7-bit
      11             : /// value.
      12             : class IValue {
      13             :   public:
      14             :     /// @name   Detecting changes
      15             :     /// @{
      16             : 
      17             :     /// Check if the value was updated since the last time the dirty flag was
      18             :     /// cleared.
      19          17 :     bool getDirty() const { return dirty; }
      20             :     /// Clear the dirty flag.
      21          11 :     void clearDirty() { dirty = false; }
      22             : 
      23             :     /// @}
      24             : 
      25             :     virtual uint8_t getValue() const = 0;
      26             : 
      27             :   protected:
      28             :     bool dirty = true;
      29             : };
      30             : 
      31             : /// Abstract interface for MIDI input elements that receive and store a 14-bit
      32             : /// value.
      33             : class IValue14 {
      34             :   public:
      35             :     /// @name   Detecting changes
      36             :     /// @{
      37             : 
      38             :     /// Check if the value was updated since the last time the dirty flag was
      39             :     /// cleared.
      40             :     bool getDirty() const { return dirty; }
      41             :     /// Clear the dirty flag.
      42             :     void clearDirty() { dirty = false; }
      43             : 
      44             :     /// @}
      45             : 
      46             :     virtual uint16_t getValue() const = 0;
      47             : 
      48             :   protected:
      49             :     bool dirty = true;
      50             : };
      51             : 
      52             : namespace MCU {
      53             : 
      54             : class IVPot {
      55             :   public:
      56             :     /// @name   Detecting changes
      57             :     /// @{
      58             : 
      59             :     /// Check if the value was updated since the last time the dirty flag was
      60             :     /// cleared.
      61             :     bool getDirty() const { return dirty; }
      62             :     /// Clear the dirty flag.
      63             :     void clearDirty() { dirty = false; }
      64             : 
      65             :     /// @}
      66             : 
      67             :     virtual bool getCenterLed() const = 0;
      68             :     virtual uint8_t getStartOn() const = 0;
      69             :     virtual uint8_t getStartOff() const = 0;
      70             : 
      71             :   protected:
      72             :     bool dirty = true;
      73             : };
      74             : 
      75             : /** 
      76             :  * @brief   An abstract interface for VU meters. To allow for both floating 
      77             :  *          point values and integers, all values are integers under the hood.
      78             :  * 
      79             :  * Using floats instead integers would be a strange choice as LED bar VU meters
      80             :  * have discrete levels.  
      81             :  * Continuous "analog" VU meters can use or override the `getFloatValue()` 
      82             :  * method.
      83             :  */
      84             : class IVU {
      85             :   public:
      86          12 :     IVU(uint8_t max, bool alwaysDirty = false)
      87          12 :         : max(max), alwaysDirty(alwaysDirty) {}
      88             : 
      89             :     /// @name   Detecting changes
      90             :     /// @{
      91             : 
      92             :     /// Check if the value was updated since the last time the dirty flag was
      93             :     /// cleared.
      94             :     bool getDirty() const { return dirty; }
      95             :     /// Clear the dirty flag.
      96             :     void clearDirty() { dirty = alwaysDirty; }
      97             : 
      98             :     /// @}
      99             : 
     100             :     /// Return the VU meter value as an integer.
     101             :     virtual uint8_t getValue() = 0;
     102             :     /// Return the overload status.
     103             :     virtual bool getOverload() = 0;
     104             :     /// Get the VU meter value as a floating point number.
     105           1 :     virtual float getFloatValue() { return (float)getValue() / getMax(); }
     106             :     /// Get the maximum value that this VU meter can return.
     107           1 :     uint8_t getMax() const { return max; }
     108             : 
     109             :   protected:
     110             :     uint8_t max;
     111             :     bool alwaysDirty;
     112             :     bool dirty = true;
     113             : };
     114             : 
     115             : } // namespace MCU
     116             : 
     117             : } // namespace Interfaces
     118             : 
     119             : END_CS_NAMESPACE