display.h

#pragma once
#include "definitions_cxx.hpp"
#include "util/string.h"
#include <array>
#include <optional>
#include <string_view>
#include <vector>
 
extern "C" {
#include "util/cfunctions.h"
}
 
class NumericLayer;
class NumericLayerScrollingText;
 
enum class PopupType {
    NONE,
    GENERAL,
    LOADING,
    PROBABILITY,
    ITERANCE,
    FILL,
    SWING,
    TEMPO,
    QUANTIZE,
    THRESHOLD_RECORDING_MODE,
    NOTIFICATION,
    // Note: Add here more popup types
};
 
namespace deluge::hid {
 
enum struct DisplayType { OLED, SEVENSEG };
 
class Display {
public:
    Display(DisplayType displayType) : displayType(displayType) {}
 
    virtual ~Display() = default;
 
    constexpr virtual size_t getNumBrowserAndMenuLines() = 0;
 
    virtual void setText(std::string_view newText, bool alignRight = false, uint8_t drawDot = 255, bool doBlink = false,
                         uint8_t* newBlinkMask = nullptr, bool blinkImmediately = false, bool shouldBlinkFast = false,
                         int32_t scrollPos = 0, uint8_t* blinkAddition = nullptr,
                         bool justReplaceBottomLayer = false) {};
 
    virtual void displayPopup(char const* newText, int8_t numFlashes = 3, bool alignRight = false,
                              uint8_t drawDot = 255, int32_t blinkSpeed = 1, PopupType type = PopupType::GENERAL) = 0;
 
    virtual void displayPopup(uint8_t val, int8_t numFlashes = 3, bool alignRight = false, uint8_t drawDot = 255,
                              int32_t blinkSpeed = 1, PopupType type = PopupType::GENERAL) {
        char valStr[4] = {0};
        intToString(val, valStr, 1);
        displayPopup(valStr, numFlashes, alignRight, drawDot, blinkSpeed, type);
    }
 
    virtual void displayPopup(char const* shortLong[2], int8_t numFlashes = 3, bool alignRight = false,
                              uint8_t drawDot = 255, int32_t blinkSpeed = 1, PopupType type = PopupType::GENERAL) {
        displayPopup(have7SEG() ? shortLong[0] : shortLong[1], numFlashes, alignRight, drawDot, blinkSpeed, type);
    }
 
    virtual void popupText(char const* text, PopupType type = PopupType::GENERAL) = 0;
    virtual void popupTextTemporary(char const* text, PopupType type = PopupType::GENERAL) = 0;
 
    virtual void setNextTransitionDirection(int8_t thisDirection) {};
 
    virtual void cancelPopup() = 0;
    virtual void freezeWithError(char const* text) = 0;
    virtual bool isLayerCurrentlyOnTop(NumericLayer* layer) = 0;
    virtual void displayError(Error error) = 0;
 
    virtual void removeWorkingAnimation() = 0;
 
    // Loading animations
    virtual void displayLoadingAnimation() {};
    virtual void displayLoadingAnimationText(char const* text, bool delayed = false, bool transparent = false) = 0;
    virtual void removeLoadingAnimation() = 0;
 
    virtual void displayNotification(std::string_view paramTitle, std::optional<std::string_view> paramValue) {}
 
    virtual bool hasPopup() = 0;
    virtual bool hasPopupOfType(PopupType type) = 0;
 
    virtual void consoleText(char const* text) = 0;
 
    virtual void timerRoutine() = 0;
 
    virtual void setTextAsNumber(int16_t number, uint8_t drawDot = 255, bool doBlink = false) {}
    virtual int32_t getEncodedPosFromLeft(int32_t textPos, char const* text, bool* andAHalf) { return 0; }
    virtual void setTextAsSlot(int16_t currentSlot, int8_t currentSubSlot, bool currentSlotExists, bool doBlink = false,
                               int32_t blinkPos = -1, bool blinkImmediately = false) {}
    virtual void setTextWithMultipleDots(std::string_view newText, std::vector<uint8_t> dotPositions,
                                         bool alignRight = false, bool doBlink = false, uint8_t* newBlinkMask = nullptr,
                                         bool blinkImmediately = false) {}
    virtual NumericLayerScrollingText* setScrollingText(char const* newText, int32_t startAtPos = 0,
                                                        int32_t initialDelay = 600, int count = -1,
                                                        uint8_t fixedDot = 255) {
        return nullptr;
    }
 
    virtual std::array<uint8_t, kNumericDisplayLength> getLast() { return {0}; }; // to match SevenSegment
 
    bool haveOLED() { return displayType == DisplayType::OLED; }
    bool have7SEG() { return displayType == DisplayType::SEVENSEG; }
 
private:
    DisplayType displayType;
};
 
} // namespace deluge::hid
 
extern deluge::hid::Display* display;
 
namespace deluge::hid::display {
void swapDisplayType();
// physical screen is oled
extern bool have_oled_screen;
} // namespace deluge::hid::display
 
extern "C" void consoleTextIfAllBootedUp(char const* text);