menu_item.h

/*
 * Copyright © 2014-2023 Synthstrom Audible Limited
 *
 * This file is part of The Synthstrom Audible Deluge Firmware.
 *
 * The Synthstrom Audible Deluge Firmware is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "definitions_cxx.hpp"
#include "deluge/model/settings/runtime_feature_settings.h"
#include "gui/l10n/l10n.h"
#include "gui/l10n/strings.h"
#include "hid/buttons.h"
#include "model/mod_controllable/mod_controllable_audio.h"
#include <cstdint>
#include <span>
 
enum class MenuPermission {
    NO,
    YES,
    MUST_SELECT_RANGE,
};
 
class Sound;
class MultiRange;
class MIDICable;

class MenuItem {
public:
    MenuItem() : name(deluge::l10n::String::EMPTY_STRING), title(deluge::l10n::String::EMPTY_STRING) {}
    MenuItem(deluge::l10n::String newName, deluge::l10n::String newTitle = deluge::l10n::String::EMPTY_STRING)
        : name(newName), title(newTitle) {
        if (newTitle == deluge::l10n::String::EMPTY_STRING) {
            title = newName;
        }
    }
 
    MenuItem(const MenuItem& other) = delete;
    MenuItem(const MenuItem&& other) = delete;
    MenuItem& operator=(const MenuItem& other) = delete;
    MenuItem& operator=(const MenuItem&& other) = delete;
 
    virtual ~MenuItem() = default;


    virtual ActionResult buttonAction(deluge::hid::Button b, bool on, bool inCardRoutine) {
        return ActionResult::NOT_DEALT_WITH;
    }

    virtual void horizontalEncoderAction(int32_t offset) {}
    virtual void verticalEncoderAction(int32_t offset) {}
    virtual void selectEncoderAction(int32_t offset) {}
    virtual bool selectEncoderActionEditsInstrument() { return false; }
    virtual MenuItem* selectButtonPress() { return nullptr; }

    virtual ActionResult timerCallback() { return ActionResult::DEALT_WITH; }

    virtual bool usesAffectEntire() { return false; }


    virtual MenuPermission checkPermissionToBeginSession(ModControllableAudio* modControllable, int32_t whichThing,
                                                         MultiRange** currentRange);
    virtual void beginSession(MenuItem* navigatedBackwardFrom = nullptr) {};

    virtual void endSession();

    virtual void readValueAgain() {}
    virtual void readCurrentValue() {}


    virtual uint8_t getIndexOfPatchedParamToBlink() { return 255; }
    virtual deluge::modulation::params::Kind getParamKind() { return deluge::modulation::params::Kind::NONE; }
    virtual uint32_t getParamIndex() { return 255; }

    virtual uint8_t shouldBlinkPatchingSourceShortcut(PatchSource s, uint8_t* colour) { return 255; }

    virtual MenuItem* patchingSourceShortcutPress(PatchSource s, bool previousPressStillActive = false) {
        return nullptr;
    }


    virtual void learnKnob(MIDICable* cable, int32_t whichKnob, int32_t modKnobMode, int32_t midiChannel) {}

    virtual bool allowsLearnMode() { return false; }
    virtual bool learnNoteOn(MIDICable& cable, int32_t channel, int32_t noteCode) { return false; }
 
    virtual void learnProgramChange(MIDICable& cable, int32_t channel, int32_t programNumber) {}
    virtual void learnCC(MIDICable& cable, int32_t channel, int32_t ccNumber, int32_t value);

    virtual bool shouldBlinkLearnLed() { return false; }

    virtual void unlearnAction() {}

    virtual bool isRangeDependent() { return false; }


    virtual void renderOLED();
    virtual void drawPixelsForOled() {}


    deluge::l10n::String title;

    [[nodiscard]] virtual std::string_view getTitle() const { return deluge::l10n::getView(title); }

    virtual uint8_t shouldDrawDotOnName() { return 255; }

    virtual void drawName();

    const deluge::l10n::String name;
    [[nodiscard]] virtual std::string_view getName() const { return deluge::l10n::getView(name); }

    virtual bool isRelevant(ModControllableAudio* modControllable, int32_t whichThing) { return true; }

    static void drawItemsForOled(std::span<std::string_view> options, int32_t selectedOption, int32_t offset = 0);

    virtual bool shouldEnterSubmenu() { return true; }

    // length = spacing before (4 pixels)
    //          + width of icon (7 pixels)
    //          + spacing after (3 pixels)
    // spacing before is to ensure that menu item text doesn't overlap and can scroll
    virtual int32_t getSubmenuItemTypeRenderLength() { return (4 + kSubmenuIconSpacingX + 3); }
    // icon is rendered 10 pixels from right edge of the display (7px icon width + 3px from edge)
    virtual int32_t getSubmenuItemTypeRenderIconStart() { return (OLED_MAIN_WIDTH_PIXELS - kSubmenuIconSpacingX - 3); }
    // render the submenu item type (icon or value)
    virtual void renderSubmenuItemTypeForOled(int32_t yPixel);
    virtual bool isSubmenu() { return false; }
    virtual void setupNumberEditor() {}
    virtual void updatePadLights();
    virtual void updateAutomationViewParameter() { return; }

    virtual void getColumnLabel(StringBuf& label) { label.append(getName().data()); }

    [[nodiscard]] virtual bool showColumnLabel() const { return true; }

    [[nodiscard]] virtual int32_t getColumnSpan() const { return 1; };

    [[nodiscard]] virtual bool showPopup() const { return true; }

    [[nodiscard]] virtual bool showValueInPopup() const { return true; }

    virtual void getValueForPopup(StringBuf& valueBuf) {};
 
    virtual void renderInHorizontalMenu(int32_t startX, int32_t width, int32_t startY, int32_t height) {};

};
 
#define NO_NAVIGATION ((MenuItem*)0xFFFFFFFF)

bool isItemRelevant(MenuItem* item);