EventEncoderButton.h

/*
 *
 * GPLv2 Licence https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
 * 
 * Copyright (c) 2024 Philip Fletcher <philip.fletcher@stutchbury.com>
 * 
 */
 
#include "InputEvents.h"
 
 
#ifndef EXCLUDE_EVENT_ENCODER
 
#ifndef EVENT_ENCODER_BUTTON_H
#define EVENT_ENCODER_BUTTON_H
 
 
#include "Arduino.h"
#include "EventEncoder.h"
#include "EventButton.h"
 
class EventEncoderButton : public EventInputBase {
 
    protected:
 
    #if defined(FUNCTIONAL_SUPPORTED)
        typedef std::function<void(InputEventType et, EventEncoderButton &ie)> CallbackFunction;
    #else
        typedef void (*CallbackFunction)(InputEventType et, EventEncoderButton &);
    #endif
 
    CallbackFunction callbackFunction = nullptr;
 
public:
 
 
    EventEncoderButton(EncoderAdapter *encoderAdapter, byte buttonPin, bool useDefaultDebouncer=true);
 
    EventEncoderButton(EncoderAdapter *encoderAdapter, PinAdapter* _pinAdapter, bool useDefaultDebouncer=true);
 
    EventEncoderButton(EncoderAdapter *encoderAdapter, PinAdapter* _pinAdapter, DebounceAdapter* debounceAdapter);
 
 
 
    void begin();
 
    void setCallback(CallbackFunction f) {
        callbackFunction = f;
        callbackIsSet = true;
    }
 
    #if defined(FUNCTIONAL_SUPPORTED)
    // Method to set callback with instance and class method
    template <typename T>
    void setCallback(T* instance, void (T::*method)(InputEventType, EventEncoderButton&)) {
        // Wrap the method call in a lambda
        callbackFunction = [instance, method](InputEventType et, EventEncoderButton &ie) {
            (instance->*method)(et, ie); // Call the member function on the instance
        };
        callbackIsSet = true;
    }
    #endif
 
    void unsetCallback() override;
 
    void update();
 
    void resetState();
 
 
 
    int16_t increment() { return currentIncrement; }
 
    int32_t position() { return currentPosition; }
 
    int32_t pressedPosition() { return currentPressedPosition; }
 
    uint8_t clickCount();
 
 
    uint8_t longPressCount();
 
    bool isPressed();
 
    uint32_t currentDuration();
 
    uint32_t previousDuration();
 
 
 
    void setMinPosition(int32_t minPosition=0);
 
    void setMaxPosition(int32_t maxPosition=0);
 
    void wrapMinMaxPosition(bool wrap) { wrapMinMaxPos = wrap; }
 
    void setMinPressedPosition(int32_t minPressedPosition=0);
    void setMaxPressedPosition(int32_t maxPressedPosition=0);
 
    void wrapMinMaxPressedPosition(bool wrap) { wrapMinMaxPressedPos = wrap; }
 
 
    void setRateLimit(long ms);
 
    void setPositionDivider(uint8_t divider=4);
 
    uint8_t getPositionDivider();
 
 
    void resetPosition(int32_t pos = 0) { 
        currentPosition = pos; 
        previousPosition = currentPosition;
    }
 
    void resetPressedPosition(int32_t pos) { 
        currentPressedPosition = pos; 
        previousPressedPosition = currentPressedPosition;
    }
 
    void enableLongPressRepeat(bool repeat=true);
 
    void setLongClickDuration(uint16_t longDurationMs=750);
 
    void setLongPressInterval(uint16_t intervalMs=500);
 
    void setMultiClickInterval(uint16_t intervalMs=250);
 
    void setDebouncer(DebounceAdapter* debounceAdapter);
 
    bool setDebounceInterval(uint16_t intervalMs=10);
 
    void setPressedState(bool state = LOW);
 
protected:
    void invoke(InputEventType et) override;
    void onEnabled() override;
    void onDisabled() override;
    void onIdle() override {/* Do nothing. Fire idle callback from either encoder or button but only if both are idle.*/ }
 
    EventEncoder encoder; 
    EventButton button; 
    void onInputCallback(InputEventType et, EventInputBase & ie);
 
private:
    int16_t currentIncrement = 0;
 
    int32_t currentPosition  = 0;
    int32_t previousPosition  = 0;
 
    int32_t currentPressedPosition  = 0;
    int32_t previousPressedPosition  = 0;
 
    bool encodingPressed = false;
    uint16_t encodingPressedCount = 0;     
 
    int32_t minPos=0;
    int32_t maxPos=0;
    bool wrapMinMaxPos = false;
 
    int32_t minPressedPos=0;
    int32_t maxPressedPos=0;
    bool wrapMinMaxPressedPos = false;
 
    void setCallbacks();
    bool onEncoderChanged();
 
#ifndef FUNCTIONAL_SUPPORTED
private:
    static void encoderCallback(InputEventType et, EventEncoder &enc) {
        EventEncoderButton *instance = static_cast<EventEncoderButton *>(enc.getOwner());
        if (instance) instance->onInputCallback(et, enc);
    }
 
    static void buttonCallback(InputEventType et, EventButton &btn) {
        EventEncoderButton *instance = static_cast<EventEncoderButton *>(btn.getOwner());
        if (instance) instance->onInputCallback(et, btn);
    }
#endif
 
};
 
 
#endif
#endif