DialogManager.h

Go to the documentation of this file.

/*
    MetaImGUI
    Copyright (C) 2026  A P Nicholson
 
    This program 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 <coroutine>
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace MetaImGUI {
 
enum class MessageBoxButtons {
    OK,          
    OKCancel,    
    YesNo,       
    YesNoCancel, 
    RetryCancel  
};
 
enum class MessageBoxIcon {
    Info,    
    Warning, 
    Error,   
    Question 
};
 
enum class MessageBoxResult { OK, Cancel, Yes, No, Retry, None };
 
class DialogManager {
public:
    DialogManager();
    ~DialogManager();
 
    // Prevent copying and moving
    DialogManager(const DialogManager&) = delete;
    DialogManager& operator=(const DialogManager&) = delete;
    DialogManager(DialogManager&&) = delete;
    DialogManager& operator=(DialogManager&&) = delete;
 
    void Render();
 
    // Message Box
    void ShowMessageBox(const std::string& title, const std::string& message,
                        MessageBoxButtons buttons = MessageBoxButtons::OK, MessageBoxIcon icon = MessageBoxIcon::Info,
                        std::function<void(MessageBoxResult)> callback = nullptr);
 
    // Input Dialog
    void ShowInputDialog(const std::string& title, const std::string& prompt, const std::string& defaultValue = "",
                         std::function<void(const std::string&)> callback = nullptr);
 
    // Progress Dialog
    int ShowProgressDialog(const std::string& title, const std::string& message = "");
 
    void UpdateProgress(int dialogId, float progress, const std::string& message = "");
 
    void CloseProgress(int dialogId);
 
    // List Selection Dialog
    void ShowListDialog(const std::string& title, const std::vector<std::string>& items,
                        std::function<void(int)> callback = nullptr);
 
    // Confirmation Dialog (convenience wrapper)
    void ShowConfirmation(const std::string& title, const std::string& message,
                          std::function<void(bool)> callback = nullptr);
 
    [[nodiscard]] auto AwaitConfirmation(std::string title, std::string message) {
        struct Awaiter {
        private:
            DialogManager* manager;
            std::string title;
            std::string message;
            bool result = false;
 
        public:
            Awaiter(DialogManager* mgr, std::string dialogTitle, std::string dialogMessage)
                : manager(mgr), title(std::move(dialogTitle)), message(std::move(dialogMessage)) {}
 
            [[nodiscard]] bool await_ready() const noexcept {
                return false;
            }
            void await_suspend(std::coroutine_handle<> handle) {
                manager->ShowConfirmation(title, message, [this, handle](bool confirmed) mutable {
                    result = confirmed;
                    handle.resume();
                });
            }
            [[nodiscard]] bool await_resume() const noexcept {
                return result;
            }
        };
        return Awaiter{this, std::move(title), std::move(message)};
    }
 
    [[nodiscard]] auto AwaitInput(std::string title, std::string prompt, std::string defaultValue = "") {
        struct Awaiter {
        private:
            DialogManager* manager;
            std::string title;
            std::string prompt;
            std::string defaultValue;
            std::string result;
 
        public:
            Awaiter(DialogManager* mgr, std::string dialogTitle, std::string dialogPrompt, std::string dialogDefault)
                : manager(mgr), title(std::move(dialogTitle)), prompt(std::move(dialogPrompt)),
                  defaultValue(std::move(dialogDefault)) {}
 
            [[nodiscard]] bool await_ready() const noexcept {
                return false;
            }
            void await_suspend(std::coroutine_handle<> handle) {
                manager->ShowInputDialog(title, prompt, defaultValue, [this, handle](const std::string& value) mutable {
                    result = value;
                    handle.resume();
                });
            }
            [[nodiscard]] std::string await_resume() {
                return std::move(result);
            }
        };
        return Awaiter{this, std::move(title), std::move(prompt), std::move(defaultValue)};
    }
 
    [[nodiscard]] bool HasOpenDialog() const;
 
    void CloseAll();
 
private:
    struct Impl;
    std::unique_ptr<Impl> m_impl;
 
    void RenderMessageBox();
    void RenderInputDialog();
    void RenderProgressDialogs();
    void RenderListDialog();
};
 
} // namespace MetaImGUI