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_
 
// Standard library includes
#include <algorithm>
#include <iterator>
#include <list>
#include <memory>
#include <queue>
#include <string>
#include <vector>
 
// Platform config include
#include "fifechan/platform.hpp"
 
// Project headers (subdirs before local)
#include "fifechan/events/keyevent.hpp"
#include "fifechan/events/mouseevent.hpp"
#include "fifechan/mouseinput.hpp"
 
namespace fcn
{
    class FocusHandler;
    class Font;
    class GuiDeathListener;
    class Graphics;
    class Input;
    class KeyListener;
    class VisibilityEventHandler;
    class Widget;
    class DragHandler;
 
    // The following comment will appear in the doxygen main page.

    class FIFEGUI_API Gui
    {
        public:
            friend class DragHandler;
            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 addHiddenWidget(Widget* widget);

            void addShownWidget(Widget* widget);

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

            virtual void handleKeyInput();

            virtual void handleTextInput();

            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);

            void captureMouse(Widget* widget);

            void releaseMouse(Widget* widget);

            virtual Widget* getKeyEventSource();

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

            Widget* mTop;

            std::vector<Widget*> mHiddenWidgets;

            std::vector<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_