BindDialog.hpp

#ifndef __BINDDIALOG_HPP
#define __BINDDIALOG_HPP
#include "BindView.hpp"
#include "BindUtils.hpp"
#define DIALOG_TEXT_BUFFER_SIZE 64
#if defined(__AVR__)
#include <avr/pgmspace.h>
const char DEFAULT_TITLE[] PROGMEM = "Confirmation";
const char DEFAULT_MESSAGE[] PROGMEM = "Are you sure?";
const char DEFAULT_OK[] PROGMEM = "OK";
const char DEFAULT_CANCEL[] PROGMEM = "Cancel";
#else
const char DEFAULT_TITLE[] = "Confirmation";
const char DEFAULT_MESSAGE[] = "Are you sure?";
const char DEFAULT_OK[] = "OK";
const char DEFAULT_CANCEL[] = "Cancel";
#endif
enum DialogType {
    TEXT_INPUT,
    PASSWORD_INPUT,
    NO_INPUT_TEXT,
};
 
class BindDialog : public BindView
{
public:
 
    BindDialog(DialogType type = NO_INPUT_TEXT)
    : dialogType(type), title(nullptr), message(nullptr), primaryButton("OK"), secondaryButton("Cancel")
    {
        this->tag = tagIndex++;
        #if defined(__AVR__)
        char buffer[16];
        strcpy_P(buffer, DEFAULT_TITLE);
        setTitle(buffer);
        strcpy_P(buffer, DEFAULT_MESSAGE);
        setMessage(buffer);
        strcpy_P(buffer, DEFAULT_OK);
        setPrimaryButton(buffer);
        strcpy_P(buffer, DEFAULT_CANCEL);
        setSecondaryButton(buffer);
        #else
        setTitle(DEFAULT_TITLE);
        setMessage(DEFAULT_MESSAGE);
        setPrimaryButton(DEFAULT_OK);
        setSecondaryButton(DEFAULT_CANCEL);
        #endif
    }
 
    void setTitle(const char *cstr)
    {
        title = cstr;
    }
 
    void setMessage(const char *cstr)
    {
        message = cstr;
    }
 
    void setPrimaryButton(const char *cstr)
    {
        primaryButton = cstr;
    }
 
    void setSecondaryButton(const char *cstr)
    {
        secondaryButton = cstr;
    }
 
    void setCallback(void (*callback)(bool))
    {
        this->callback.simple = callback;
        isTextCallback = false;
    }
 
    void setCallback(void (*callback)(bool, const char *))
    {
        this->callback.withText = callback;
        isTextCallback = true;
    }
 
    void invokeCallback(bool result, const char *text)
    {
        this->hasResult = true;
        this->accepted = result;
 
        if ((dialogType == TEXT_INPUT || dialogType == PASSWORD_INPUT) && isTextCallback){
            setTextResult(text, strlen(text));
            if (callback.withText != nullptr)
            {
                callback.withText(result, text);
                return;
            }
        }else{
            if (callback.simple != nullptr)
            {
                callback.simple(result);
            }
        }
        
    }
 
    void invokeCallback(bool result)
    {
        this->hasResult = true;
        this->accepted = result;
        if (dialogType == NO_INPUT_TEXT && callback.simple != nullptr){
            callback.simple(result);
        }
    }
 
    const char* getResultText() const {
        return resultTextBuffer; // Always return the buffer
    }
 
    uint16_t getBytes(uint8_t *out) override
    {
        offset = 0;
        uint8_t dialogTypeU = (uint8_t)dialogType;
        copyAndOffset(out, &offset, &objID, sizeof(objID));
        copyAndOffset(out, &offset, &tag, sizeof(tag));
        copyAndOffset(out, &offset, &cmdId, sizeof(cmdId));
        copyAndOffset(out, &offset, &dialogTypeU, sizeof(dialogTypeU));
        copyAndOffset(out, &offset, &singleButton, sizeof(singleButton));
 
        copyStringWithLength(out, &offset, title);
        copyStringWithLength(out, &offset, message);
        copyStringWithLength(out, &offset, primaryButton);
        copyStringWithLength(out, &offset, secondaryButton);
        
        return offset;
    }
 
    uint8_t cmdId = 0; 
    bool accepted = false; 
    bool hasResult = false; 
    bool singleButton = false; 
 
private:
    char resultTextBuffer[DIALOG_TEXT_BUFFER_SIZE];
    uint8_t objID = BIND_ID_DIALOG;
    uint16_t offset = 0; 
    int strLength = 0; 
    const char *title; 
    const char *message; 
    const char *primaryButton = "OK"; 
    const char *secondaryButton = "Cancel"; 
    DialogType dialogType; 
    static int16_t tagIndex; 
    typedef union {
        void (*simple)(bool);
        void (*withText)(bool, const char *);
    } DialogCallback;
    DialogCallback callback;
    bool isTextCallback = false;
 
    void setTextResult(const char *cstr, int length) {
        length = min(length, DIALOG_TEXT_BUFFER_SIZE - 1);
        strncpy(resultTextBuffer, cstr, length);
        resultTextBuffer[length] = '\0';
    }
};
 
#endif // __BINDDIALOG_HPP