PopupWindow.h

Go to the documentation of this file.

#pragma once

#include "Button.h"
#include "Container.h"
#include "Frame.h"
#include "Label.h"
#include "Signals.h"

namespace rose {

    struct DialogActionButton {
        ActionButtonType mActionButton{};
        SignalToken mSignalToken{};
    };

    class Popup : public Window {
    protected:
        Size mMinimumSize;               
        std::shared_ptr<Frame> mFrame;      
        std::shared_ptr<Column> mColumn;    

        std::shared_ptr<Slot<Button::SignalType>> mActionButtonRx{};    
        std::shared_ptr<Slot<Button::SignalType>> mDismissButtonRx{};      

    public:
        Popup() = delete;
        ~Popup() override = default;
        Popup(Popup &&) = delete;
        Popup(const Popup &) = delete;
        Popup& operator=(Popup &&) = delete;
        Popup& operator=(const Popup &) = delete;

        explicit Popup(const shared_ptr <Rose>& parent);

        Popup(const shared_ptr <Rose>& parent, const Position &position);

        Popup(const shared_ptr <Rose>& parent, const Position &pos, const Size &minimumSize);

        void initializeComposite() override;

        Rectangle widgetLayout(sdl::Renderer &renderer, Rectangle available, uint layoutStage) override;

        void draw(sdl::Renderer &renderer, Rectangle parentRect) override;

        void addChild(const std::shared_ptr<Widget>& widget) override {
            mColumn->addChild(widget);
        }

        template<class C>
        void setActionButtons(C actionButtonList) {
            std::for_each(actionButtonList.begin(), actionButtonList.end(),
                          [this](const DialogActionButton &dialogActionButton){
                              createActionButton(dialogActionButton);
                          });
        }

        virtual void createActionButton(const DialogActionButton &dialogActionButton) {}

        virtual void setButtonSlot(shared_ptr <Slot<Button::SignalType>> &buttonSlot, bool dismissAll) {
            mActionButtonRx = buttonSlot;
        }
    };

    class PopupWindow : public Popup {
    protected:
        std::string mWindowTitle{};         
        std::shared_ptr<Label> mTitle;      

    public:
        PopupWindow() = delete;
        ~PopupWindow() override = default;
        PopupWindow(PopupWindow &&) = delete;
        PopupWindow(const PopupWindow &) = delete;
        PopupWindow& operator=(PopupWindow &&) = delete;
        PopupWindow& operator=(const PopupWindow &) = delete;

        explicit PopupWindow(shared_ptr <Rose> parent);

        PopupWindow(shared_ptr <Rose> parent, const Position &position);

        PopupWindow(shared_ptr <Rose> parent, const Position &pos, const Size &size);

        void initializeComposite() override;

        Rectangle widgetLayout(sdl::Renderer &renderer, Rectangle available, uint layoutStage) override;

        void setTitle(const std::string &text) override {
            mTitle->setText(text);
            setNeedsDrawing();
        }

        bool mouseDragEvent(const Position &mousePos, const Position &rel, int button, int modifiers) override;
    };

    class Dialog : public PopupWindow {
    protected:
        ImageId mBadgeId{};                 
        std::shared_ptr<Row> mMessageRow;   
        std::shared_ptr<Row> mButtonRow;    

    public:
        Dialog() = delete;
        ~Dialog() override = default;
        Dialog(Dialog &&) = delete;
        Dialog(const Dialog &) = delete;
        Dialog& operator=(Dialog &&) = delete;
        Dialog& operator=(const Dialog &) = delete;

        explicit Dialog(shared_ptr <Rose> parent);

        Dialog(shared_ptr <Rose> parent, const Position &position);

        Dialog(shared_ptr <Rose> parent, const Position &pos, const Size &size);

        void initializeComposite() override;

        void createActionButton(const DialogActionButton &dialogActionButton) override;

        void setButtonSlot(shared_ptr <Slot<Button::SignalType>> &buttonSlot, bool dismissAll) override;
    };

    class ExitDialog : public Dialog {
    protected:
        static constexpr std::string_view mExitTitle = "Exit?";
        static constexpr std::string_view mExitMessage = "Exit the program?";
        static constexpr std::array<DialogActionButton,2> mActionButtons = {
                DialogActionButton{ActionButtonOk, ExitDialogOk },
                DialogActionButton{ActionButtonCancel, ExitDialogCancel }
        };

    public:
        ExitDialog() = delete;
        ~ExitDialog() override = default;
        ExitDialog(ExitDialog &&) = delete;
        ExitDialog(const ExitDialog &) = delete;
        ExitDialog& operator=(ExitDialog &&) = delete;
        ExitDialog& operator=(const ExitDialog &) = delete;

        explicit ExitDialog(shared_ptr <Rose> parent);

        ExitDialog(shared_ptr <Rose> parent, const Position &position);

        ExitDialog(shared_ptr <Rose> parent, const Position &pos, const Size &size);

        void initializeComposite() override;

    };

    class UnsavedDialog : public Dialog {
    protected:
        static constexpr std::string_view mTitle = "Discard Changes?";
        static constexpr std::string_view mMessage = "You have unsaved changes, discard them?";
        static constexpr std::array<DialogActionButton,2> mActionButtons = {
                DialogActionButton{ActionButtonOk, DialogOk },
                DialogActionButton{ActionButtonCancel, DialogCancel }
        };

    public:
        UnsavedDialog() = delete;
        ~UnsavedDialog() override = default;
        UnsavedDialog(UnsavedDialog &&) = delete;
        UnsavedDialog(const UnsavedDialog &) = delete;
        UnsavedDialog& operator=(UnsavedDialog &&) = delete;
        UnsavedDialog& operator=(const UnsavedDialog &) = delete;

        explicit UnsavedDialog(shared_ptr <Rose> parent);

        UnsavedDialog(shared_ptr <Rose> parent, const Position &position);

        UnsavedDialog(shared_ptr <Rose> parent, const Position &pos, const Size &size);

        void initializeComposite() override;

    };
}

template<class WidgetType, size_t N>
inline std::shared_ptr<WidgetType> operator << (std::shared_ptr<WidgetType> &widget,
        std::array<rose::DialogActionButton,N> &container) {
    static_assert(std::is_base_of_v<rose::Popup, WidgetType>,
            "Dialog action buttons are only created on classes derived from rose::Popup." );
    widget->setActionbuttons(container);
    return widget;
}

template<class WidgetType>
inline std::shared_ptr<WidgetType> operator << (std::shared_ptr<WidgetType> &widget,
                                                std::vector<rose::DialogActionButton> &container) {
    static_assert(std::is_base_of_v<rose::Popup, WidgetType>,
                  "Dialog action buttons are only created on classes derived from rose::Popup." );
    widget->setActionbuttons(container);
    return widget;
}

template<class WidgetType>
inline std::shared_ptr<WidgetType> operator << (std::shared_ptr<WidgetType> &widget,
        std::shared_ptr<rose::Slot<rose::Button::SignalType>> &rxSlot) {
    static_assert(std::is_base_of_v<rose::Popup, WidgetType>,
            "Button Slot can only be set on objects derived from rose::Popup." );
    widget->setButtonSlot(rxSlot, true);
    return widget;
}