gui.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later OR BSD-3-Clause
// SPDX-FileCopyrightText: 2004 - 2008 Olof Naessén and Per Larsson
// SPDX-FileCopyrightText: 2013 - 2026 Fifengine contributors
 
#ifndef INCLUDE_FIFECHAN_GUI_HPP_
#define INCLUDE_FIFECHAN_GUI_HPP_
 
#include <algorithm>
#include <iterator>
#include <list>
#include <memory>
#include <queue>
#include <set>
#include <string>
 
#include "fifechan/keyevent.hpp"
#include "fifechan/mouseevent.hpp"
#include "fifechan/mouseinput.hpp"
#include "fifechan/platform.hpp"
 
namespace fcn
{
    class FocusHandler;
    class Font;
    class GuiDeathListener;
    class Graphics;
    class Input;
    class KeyListener;
    class VisibilityEventHandler;
    class Widget;
 
    // The following comment will appear in the doxygen main page.

    class FIFEGUI_API Gui
    {
    public:
        Gui();
 
        virtual ~Gui();
 
        Gui(Gui const &)            = delete;
        Gui& operator=(Gui const &) = delete;
        Gui(Gui&&)                  = delete;
        Gui& operator=(Gui&&)       = delete;

        virtual void setTop(Widget* top);

        virtual void setTop(std::unique_ptr<Widget> top);

        virtual void setRoot(Widget* top);

        virtual void setRoot(std::unique_ptr<Widget> top);

        virtual Widget* getTop() const;

        virtual void setGraphics(Graphics* graphics);

        virtual void setGraphics(std::unique_ptr<Graphics> graphics);

        virtual Graphics* getGraphics() const;

        virtual void setInput(Input* input);

        virtual void setInput(std::unique_ptr<Input> input);

        virtual Input* getInput() const;

        virtual void initialize(
            std::unique_ptr<Graphics> graphics, std::unique_ptr<Input> input, int width, int height);

        virtual FocusHandler* getFocusHandler() const;

        virtual void setGlobalFont(std::string const & filename, int size);

        virtual void logic();

        virtual void draw();

        virtual void focusNone();

        virtual void setTabbingEnabled(bool tabbing);

        virtual bool isTabbingEnabled();

        virtual void addGlobalKeyListener(KeyListener* keyListener);

        virtual void removeGlobalKeyListener(KeyListener* keyListener);

        void enqueueHiddenWidget(Widget* widget);

        void enqueueShownWidget(Widget* widget);

        void widgetDied(Widget const * widget);
 
    protected:
        virtual void handleMouseInput();

        virtual void handleKeyInput();

        virtual void handleMouseMoved(MouseInput const & mouseInput);

        virtual void handleMousePressed(MouseInput const & mouseInput);

        virtual void handleMouseWheelMovedDown(MouseInput const & mouseInput);

        virtual void handleMouseWheelMovedUp(MouseInput const & mouseInput);

        virtual void handleMouseWheelMovedRight(MouseInput const & mouseInput);

        virtual void handleMouseWheelMovedLeft(MouseInput const & mouseInput);

        virtual void handleMouseReleased(MouseInput const & mouseInput);

        virtual void handleModalFocus();

        virtual void handleModalMouseInputFocus();

        virtual void handleModalFocusGained();

        virtual void handleModalFocusReleased();

        virtual void handleModalMouseInputFocusGained();

        virtual void handleModalMouseInputFocusReleased();

        virtual void handleHiddenWidgets();

        virtual void handleShownWidgets();

        void distributeMouseEvent(Widget* source, MouseEvent::Type type, MouseEvent::Button button, int x, int y)
        {
            distributeMouseEvent(source, type, button, x, y, false, false);
        }

        void distributeMouseEvent(
            Widget* source, MouseEvent::Type type, MouseEvent::Button button, int x, int y, bool force)
        {
            distributeMouseEvent(source, type, button, x, y, force, false);
        }

        virtual void distributeMouseEvent(
            Widget* source,
            MouseEvent::Type type,
            MouseEvent::Button button,
            int x,
            int y,
            bool force,
            bool toSourceOnly);

        virtual void distributeKeyEvent(KeyEvent& keyEvent);

        virtual void distributeKeyEventToGlobalKeyListeners(KeyEvent& keyEvent);

        Widget* getWidgetAt(int x, int y)
        {
            return getWidgetAt(x, y, nullptr);
        }

        virtual Widget* getWidgetAt(int x, int y, Widget* exclude);

        virtual Widget* getMouseEventSource(int x, int y);

        virtual Widget* getKeyEventSource();

        virtual std::set<Widget*> getWidgetsAt(int x, int y);

        Widget* mTop;

        std::queue<Widget*> mHiddenWidgets;

        std::queue<Widget*> mShownWidgets;

        Graphics* mGraphics;

        Input* mInput;

        FocusHandler* mFocusHandler;

        VisibilityEventHandler* mVisibilityEventHandler;

        bool mTabbing;

        using KeyListenerList = std::list<KeyListener*>;

        using KeyListenerListIterator = KeyListenerList::iterator;

        KeyListenerList mKeyListeners;

        bool mShiftPressed;

        bool mMetaPressed;

        bool mControlPressed;

        bool mAltPressed;

        unsigned int mLastMousePressButton;

        int mLastMousePressTimeStamp;

        int mLastMouseX;

        int mLastMouseY;

        int mClickCount;

        int mLastMouseDragButton;

        GuiDeathListener* mDeathListener;

        std::unique_ptr<Widget> mOwnedTop;

        std::unique_ptr<Graphics> mOwnedGraphics;

        std::unique_ptr<Input> mOwnedInput;

        std::shared_ptr<Font> mGlobalFont;
    };
} // namespace fcn
 
#endif // INCLUDE_FIFECHAN_GUI_HPP_