BindDialog.hpp

#ifndef __BINDDIALOG_HPP
#define __BINDDIALOG_HPP
#include "BindView.hpp"
#include "BindUtils.hpp"
 
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"), resultText(nullptr)
    {
        this->tag = tagIndex++;
        setTitle("Confirmation");
        setMessage("Are you sure?");
        setPrimaryButton("OK");
        setSecondaryButton("Cancel");
        setTextResult("", 0);
    }
 
    ~BindDialog()
    {
        if (resultText != nullptr) {
            delete[] resultText;
        }
    }
 
    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 = callback;
    }
 
    void setCallback(void (*callback)(bool, const char *))
    {
        this->callbackWithText = callback;
    }
 
    void invokeCallback(bool result, const char *text)
    {
        this->hasResult = true;
        this->accepted = result;
 
        if (dialogType == TEXT_INPUT || dialogType == PASSWORD_INPUT){
            setTextResult(text, strlen(text));
            if (callbackWithText != nullptr)
            {
                callbackWithText(result, text);
            }
        }
 
        if (callback != nullptr)
        {
            callback(result);
        }
        
    }
 
    void invokeCallback(bool result)
    {
        this->hasResult = true;
        this->accepted = result;
        if (callback != nullptr)
        {
            callback(result);
        }
    }
 
    const char* getResultText() const
    {
        if (resultText != nullptr) {
            return resultText;
        }else{
            return "";
        }
    }
 
    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:
    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; 
    void (*callback)(bool) = nullptr;
    void (*callbackWithText)(bool, const char *) = nullptr;
    char *resultText = nullptr;
 
    void setTextResult(const char *cstr, int length)
    {
        if (cstr == resultText || length < 0) {
            return; // Handle self-assignment
        }
        
        // Allocate memory for the new text
        if (resultText != nullptr) {
            delete[] resultText;
        }
        resultText = new char[length + 1];
        strncpy(resultText, cstr, length);
        resultText[length] = '\0'; // Null-terminate the string
    }
};
 
#endif // __BINDDIALOG_HPP