gui.cpp

// 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
 
// Corresponding header include
#include "fifechan/gui.hpp"
 
// Standard library includes
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <list>
#include <memory>
#include <queue>
#include <string>
#include <utility>
#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/events/textinputevent.hpp"
#include "fifechan/exception.hpp"
#include "fifechan/focushandler.hpp"
#include "fifechan/graphics.hpp"
#include "fifechan/input.hpp"
#include "fifechan/keyinput.hpp"
#include "fifechan/listeners/deathlistener.hpp"
#include "fifechan/listeners/keylistener.hpp"
#include "fifechan/listeners/mouselistener.hpp"
#include "fifechan/listeners/visibilityeventhandler.hpp"
#include "fifechan/mouseinput.hpp"
#include "fifechan/rectangle.hpp"
#include "fifechan/widget.hpp"
 
namespace fcn
{
    class GuiDeathListener : public DeathListener
    {
        public:
            explicit GuiDeathListener(Gui* gui) : mGui(gui)
            {
            }
            ~GuiDeathListener() override = default;
 
            void death(Event const & event) override
            {
                mGui->widgetDied(event.getSource());
            }
 
            GuiDeathListener(GuiDeathListener const &)            = delete;
            GuiDeathListener& operator=(GuiDeathListener const &) = delete;
            GuiDeathListener(GuiDeathListener&&)                  = delete;
            GuiDeathListener& operator=(GuiDeathListener&&)       = delete;
 
        private:
            Gui* mGui;
    };
 
    Gui::Gui() :
        mTop(nullptr),
        mGraphics(nullptr),
        mInput(nullptr),
        mTabbing(true),
        mFocusHandler(new FocusHandler()),
        mVisibilityEventHandler(new VisibilityEventHandler(this)),
        mShiftPressed(false),
        mMetaPressed(false),
        mControlPressed(false),
        mAltPressed(false),
        mLastMousePressButton(0),
        mLastMousePressTimeStamp(0),
        mLastMouseX(0),
        mLastMouseY(0),
        mClickCount(1),
        mLastMouseDragButton(0),
        mDeathListener(new GuiDeathListener(this))
    {
        assert("focus handler must be allocated" && mFocusHandler != nullptr);
        assert("visibility handler must be allocated" && mVisibilityEventHandler != nullptr);
        assert("death listener must be allocated" && mDeathListener != nullptr);
 
        Widget::_setVisibilityEventHandler(mVisibilityEventHandler);
 
        Widget::_setGuiDeathListener(mDeathListener);
    }
 
    Gui::~Gui()
    {
        if (Widget::widgetExists(mTop)) {
            if (mTop != nullptr) {
                mTop->_setFocusHandler(nullptr);
            }
            mTop = nullptr;
        }
        Widget::_setVisibilityEventHandler(nullptr);
        Widget::_setGuiDeathListener(nullptr);
 
        delete mFocusHandler;
        delete mVisibilityEventHandler;
        delete mDeathListener;
    }
 
    void Gui::setTop(Widget* top)
    {
        // `top` may be nullptr to clear the current top widget; no assertion needed.
 
        if (top != mOwnedTop.get()) {
            mOwnedTop.reset();
        }
 
        if (mTop != nullptr) {
            mTop->_setFocusHandler(nullptr);
        }
        if (top != nullptr) {
            top->_setFocusHandler(mFocusHandler);
        }
 
        mTop = top;
    }
 
    void Gui::setTop(std::unique_ptr<Widget> top)
    {
        mOwnedTop = std::move(top);
        setTop(mOwnedTop.get());
    }
 
    void Gui::setRoot(Widget* top)
    {
        setTop(top);
    }
 
    void Gui::setRoot(std::unique_ptr<Widget> top)
    {
        setTop(std::move(top));
    }
 
    Widget* Gui::getTop() const
    {
        return mTop;
    }
 
    void Gui::setGraphics(Graphics* graphics)
    {
        // `graphics` may be nullptr to clear the current graphics; no assertion needed.
 
        if (graphics != mOwnedGraphics.get()) {
            mOwnedGraphics.reset();
        }
        mGraphics = graphics;
    }
 
    void Gui::setGraphics(std::unique_ptr<Graphics> graphics)
    {
        mOwnedGraphics = std::move(graphics);
        setGraphics(mOwnedGraphics.get());
    }
 
    Graphics* Gui::getGraphics() const
    {
        return mGraphics;
    }
 
    void Gui::setInput(Input* input)
    {
        // `input` may be nullptr to clear the current input; no assertion needed.
 
        if (input != mOwnedInput.get()) {
            mOwnedInput.reset();
        }
        mInput = input;
    }
 
    void Gui::setInput(std::unique_ptr<Input> input)
    {
        mOwnedInput = std::move(input);
        setInput(mOwnedInput.get());
    }
 
    Input* Gui::getInput() const
    {
        return mInput;
    }
 
    void Gui::initialize(std::unique_ptr<Graphics> graphics, std::unique_ptr<Input> input, int width, int height)
    {
        (void)width;
        (void)height;
        setGraphics(std::move(graphics));
        setInput(std::move(input));
    }
 
    FocusHandler* Gui::getFocusHandler() const
    {
        return mFocusHandler;
    }
 
    void Gui::setGlobalFont(std::string const & filename, int size)
    {
        if (mGraphics == nullptr) {
            throwException("No graphics set");
        }
 
        auto createdFont = mGraphics->createFont(filename, size);
        if (!createdFont) {
            throwException("Failed to create font using active graphics backend");
        }
 
        mGlobalFont = std::move(createdFont);
        Widget::setGlobalFont(mGlobalFont.get());
    }
 
    void Gui::logic()
    {
        assert("Top widget must be set" && mTop != nullptr);
 
        if (mTop == nullptr) {
            throwException("No top widget set");
        }
 
        handleModalFocus();
        handleModalMouseInputFocus();
 
        if (mInput != nullptr) {
            mInput->_pollInput();
 
            handleKeyInput();
            handleTextInput();
            handleMouseInput();
        }
 
        mTop->_logic();
 
        handleHiddenWidgets();
        handleShownWidgets();
    }
 
    void Gui::draw()
    {
        assert("Top widget must be set" && mTop != nullptr);
        assert("Graphics must be set" && mGraphics != nullptr);
 
        if (mTop == nullptr) {
            throwException("No top widget set");
        }
 
        if (mGraphics == nullptr) {
            throwException("No graphics set");
        }
 
        if (!mTop->isVisible()) {
            return;
        }
 
        mGraphics->_beginDraw();
        mTop->_draw(mGraphics);
        mGraphics->_endDraw();
    }
 
    void Gui::focusNone()
    {
        mFocusHandler->focusNone();
    }
 
    void Gui::setTabbingEnabled(bool tabbing)
    {
        mTabbing = tabbing;
    }
 
    bool Gui::isTabbingEnabled()
    {
        return mTabbing;
    }
 
    void Gui::addGlobalKeyListener(KeyListener* keyListener)
    {
        mKeyListeners.push_back(keyListener);
    }
 
    void Gui::removeGlobalKeyListener(KeyListener* keyListener)
    {
        mKeyListeners.remove(keyListener);
    }
 
    void Gui::addHiddenWidget(Widget* widget)
    {
        mHiddenWidgets.push_back(widget);
    }
 
    void Gui::addShownWidget(Widget* widget)
    {
        mShownWidgets.push_back(widget);
    }
 
    void Gui::widgetDied(Widget const * widget)
    {
        std::erase(mShownWidgets, widget);
        std::erase(mHiddenWidgets, widget);
    }
 
    void Gui::handleMouseInput()
    {
        while (!mInput->isMouseQueueEmpty()) {
            MouseInput const mouseInput = mInput->dequeueMouseInput();
 
            switch (mouseInput.getType()) {
            case MouseInput::Type::Pressed:
                handleMousePressed(mouseInput);
                break;
            case MouseInput::Type::Released:
                handleMouseReleased(mouseInput);
                break;
            case MouseInput::Type::Moved:
                handleMouseMoved(mouseInput);
                break;
            case MouseInput::Type::WheelMovedDown:
                handleMouseWheelMovedDown(mouseInput);
                break;
            case MouseInput::Type::WheelMovedUp:
                handleMouseWheelMovedUp(mouseInput);
                break;
            case MouseInput::Type::WheelMovedRight:
                handleMouseWheelMovedRight(mouseInput);
                break;
            case MouseInput::Type::WheelMovedLeft:
                handleMouseWheelMovedLeft(mouseInput);
                break;
            default:
                throwException("Unknown mouse input type.");
                break;
            }
 
            // Save the current mouse state. It's needed to send
            // mouse exited events and mouse entered events when
            // the mouse exits a widget and when a widget releases
            // modal mouse input focus.
            mLastMouseX = mouseInput.getX();
            mLastMouseY = mouseInput.getY();
        }
    }
 
    void Gui::handleTextInput()
    {
        while (!mInput->isTextQueueEmpty()) {
            std::string const text = mInput->dequeueTextInput();
 
            Widget* focused = mFocusHandler->getFocused();
            if (focused == nullptr || !focused->isEnabled()) {
                continue;
            }
 
            TextInputEvent textEvent(
                focused,
                focused,
                mShiftPressed,
                mControlPressed,
                mAltPressed,
                mMetaPressed,
                text,
                TextInputEvent::Type::Input);
 
            focused->textInput(textEvent);
        }
    }
 
    void Gui::handleKeyInput()
    {
        while (!mInput->isKeyQueueEmpty()) {
            KeyInput const keyInput = mInput->dequeueKeyInput();
 
            // Save modifiers state
            mShiftPressed   = keyInput.isShiftPressed();
            mMetaPressed    = keyInput.isMetaPressed();
            mControlPressed = keyInput.isControlPressed();
            mAltPressed     = keyInput.isAltPressed();
 
            KeyEvent keyEventToGlobalKeyListeners(
                nullptr,
                nullptr,
                mShiftPressed,
                mControlPressed,
                mAltPressed,
                mMetaPressed,
                static_cast<KeyEvent::Type>(static_cast<std::uint8_t>(keyInput.getType())),
                keyInput.isNumericPad(),
                keyInput.getKey());
 
            distributeKeyEventToGlobalKeyListeners(keyEventToGlobalKeyListeners);
 
            // If a global key listener consumes the event it will not be
            // sent further to the source of the event.
            if (keyEventToGlobalKeyListeners.isConsumed()) {
                continue;
            }
 
            bool keyEventConsumed = false;
 
            // Send key inputs to the focused widgets
            if (mFocusHandler->getFocused() != nullptr) {
                Widget* source = getKeyEventSource();
                KeyEvent keyEvent(
                    source,
                    source,
                    mShiftPressed,
                    mControlPressed,
                    mAltPressed,
                    mMetaPressed,
                    static_cast<KeyEvent::Type>(static_cast<std::uint8_t>(keyInput.getType())),
                    keyInput.isNumericPad(),
                    keyInput.getKey());
 
                if (!mFocusHandler->getFocused()->isFocusable()) {
                    mFocusHandler->focusNone();
                } else {
                    distributeKeyEvent(keyEvent);
                }
 
                keyEventConsumed = keyEvent.isConsumed();
            }
 
            // If the key event hasn't been consumed and
            // tabbing is enable check for tab press and
            // change focus.
            if (!keyEventConsumed && mTabbing && keyInput.getKey().getValue() == fcn::Key::TAB &&
                keyInput.getType() == KeyInput::Type::Pressed) {
                if (keyInput.isShiftPressed()) {
                    mFocusHandler->tabPrevious();
                } else {
                    mFocusHandler->tabNext();
                }
            }
        }
    }
 
    void Gui::handleMouseMoved(MouseInput const & mouseInput)
    {
        // Get the last widgets with the mouse using the last known mouse position.
        std::vector<Widget*> const mLastWidgetsWithMouse = getWidgetsAt(mLastMouseX, mLastMouseY);
 
        // Check if the mouse has left the application window.
        if (mouseInput.getX() < 0 || mouseInput.getY() < 0 ||
            !mTop->getDimension().isContaining(mouseInput.getX(), mouseInput.getY())) {
            for (auto const & w : mLastWidgetsWithMouse) {
                distributeMouseEvent(
                    w,
                    MouseEvent::Type::Exited,
                    static_cast<MouseEvent::Button>(mouseInput.getButton()),
                    mouseInput.getX(),
                    mouseInput.getY(),
                    true,
                    true);
            }
        } else {
            // The mouse is in the application window.
 
            // Calculate which widgets should receive a mouse exited event
            // and which should receive a mouse entered event by using the
            // last known mouse position and the latest mouse position.
            std::vector<Widget*> const mWidgetsWithMouse = getWidgetsAt(mouseInput.getX(), mouseInput.getY());
            std::vector<Widget*> mWidgetsWithMouseExited;
            std::vector<Widget*> mWidgetsWithMouseEntered;
 
            // compute difference: last - current => exited
            std::ranges::copy_if(
                mLastWidgetsWithMouse,
 
                std::back_inserter(mWidgetsWithMouseExited),
                [&](Widget* w) {
                    return std::ranges::find(mWidgetsWithMouse, w) == mWidgetsWithMouse.end();
                });
            // compute difference: current - last => entered
            std::ranges::copy_if(
                mWidgetsWithMouse,
 
                std::back_inserter(mWidgetsWithMouseEntered),
                [&](Widget* w) {
                    return std::ranges::find(mLastWidgetsWithMouse, w) == mLastWidgetsWithMouse.end();
                });
 
            for (auto const & w : mWidgetsWithMouseExited) {
                distributeMouseEvent(
                    w,
                    MouseEvent::Type::Exited,
                    static_cast<MouseEvent::Button>(mouseInput.getButton()),
                    mouseInput.getX(),
                    mouseInput.getY(),
                    true,
                    true);
                // As the mouse has exited a widget we need
                // to reset the click count and the last mouse
                // press time stamp.
                mClickCount              = 1;
                mLastMousePressTimeStamp = 0;
            }
            for (auto const & widget : mWidgetsWithMouseEntered) {
                // If a widget has modal mouse input focus we
                // only want to send entered events to that widget
                // and the widget's parents.
                if (!mFocusHandler->hasModalFocus() || widget->isUnderMouseModal()) {
                    distributeMouseEvent(
                        widget,
                        MouseEvent::Type::Entered,
                        static_cast<MouseEvent::Button>(mouseInput.getButton()),
                        mouseInput.getX(),
                        mouseInput.getY(),
                        true,
                        true);
                }
            }
        }
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            distributeMouseEvent(
                mFocusHandler->getDraggedWidget(),
                MouseEvent::Type::Dragged,
                static_cast<MouseEvent::Button>(mLastMouseDragButton),
                mouseInput.getX(),
                mouseInput.getY());
        } else {
            Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
            distributeMouseEvent(
                sourceWidget,
                MouseEvent::Type::Moved,
                static_cast<MouseEvent::Button>(mouseInput.getButton()),
                mouseInput.getX(),
                mouseInput.getY());
        }
    }
 
    void Gui::handleMousePressed(MouseInput const & mouseInput)
    {
        Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            sourceWidget = mFocusHandler->getDraggedWidget();
        }
 
        int sourceWidgetX = 0;
        int sourceWidgetY = 0;
        sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
 
        if (mouseInput.getTimeStamp() - mLastMousePressTimeStamp < 250 &&
            mLastMousePressButton == static_cast<unsigned int>(mouseInput.getButton())) {
            mClickCount++;
        } else {
            mClickCount = 1;
        }
 
        distributeMouseEvent(
            sourceWidget,
            MouseEvent::Type::Pressed,
            static_cast<MouseEvent::Button>(mouseInput.getButton()),
            mouseInput.getX(),
            mouseInput.getY());
 
        if (!mFocusHandler->hasModalFocus() || sourceWidget->isModalFocused()) {
            sourceWidget->requestFocus();
        }
 
        mFocusHandler->setLastWidgetPressed(sourceWidget);
 
        mFocusHandler->setDraggedWidget(sourceWidget);
        mLastMouseDragButton = static_cast<unsigned int>(mouseInput.getButton());
 
        mLastMousePressButton    = static_cast<unsigned int>(mouseInput.getButton());
        mLastMousePressTimeStamp = mouseInput.getTimeStamp();
    }
 
    void Gui::handleMouseWheelMovedDown(MouseInput const & mouseInput)
    {
        Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            sourceWidget = mFocusHandler->getDraggedWidget();
        }
 
        int sourceWidgetX = 0;
        int sourceWidgetY = 0;
        sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
 
        distributeMouseEvent(
            sourceWidget,
            MouseEvent::Type::WheelMovedDown,
            static_cast<MouseEvent::Button>(mouseInput.getButton()),
            mouseInput.getX(),
            mouseInput.getY());
    }
 
    void Gui::handleMouseWheelMovedUp(MouseInput const & mouseInput)
    {
        Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            sourceWidget = mFocusHandler->getDraggedWidget();
        }
 
        int sourceWidgetX = 0;
        int sourceWidgetY = 0;
        sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
 
        distributeMouseEvent(
            sourceWidget,
            MouseEvent::Type::WheelMovedUp,
            static_cast<MouseEvent::Button>(mouseInput.getButton()),
            mouseInput.getX(),
            mouseInput.getY());
    }
 
    void Gui::handleMouseWheelMovedRight(MouseInput const & mouseInput)
    {
        Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            sourceWidget = mFocusHandler->getDraggedWidget();
        }
 
        int sourceWidgetX = 0;
        int sourceWidgetY = 0;
        sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
 
        distributeMouseEvent(
            sourceWidget,
            MouseEvent::Type::WheelMovedRight,
            static_cast<MouseEvent::Button>(mouseInput.getButton()),
            mouseInput.getX(),
            mouseInput.getY());
    }
 
    void Gui::handleMouseWheelMovedLeft(MouseInput const & mouseInput)
    {
        Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            sourceWidget = mFocusHandler->getDraggedWidget();
        }
 
        int sourceWidgetX = 0;
        int sourceWidgetY = 0;
        sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
 
        distributeMouseEvent(
            sourceWidget,
            MouseEvent::Type::WheelMovedLeft,
            static_cast<MouseEvent::Button>(mouseInput.getButton()),
            mouseInput.getX(),
            mouseInput.getY());
    }
 
    void Gui::handleMouseReleased(MouseInput const & mouseInput)
    {
        Widget* sourceWidget = getMouseEventSource(mouseInput.getX(), mouseInput.getY());
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            if (sourceWidget != mFocusHandler->getLastWidgetPressed()) {
                mFocusHandler->setLastWidgetPressed(nullptr);
            }
 
            sourceWidget = mFocusHandler->getDraggedWidget();
        }
 
        int sourceWidgetX = 0;
        int sourceWidgetY = 0;
        sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
 
        distributeMouseEvent(
            sourceWidget,
            MouseEvent::Type::Released,
            static_cast<MouseEvent::Button>(mouseInput.getButton()),
            mouseInput.getX(),
            mouseInput.getY());
 
        if (static_cast<unsigned int>(mouseInput.getButton()) == mLastMousePressButton &&
            mFocusHandler->getLastWidgetPressed() == sourceWidget) {
            distributeMouseEvent(
                sourceWidget,
                MouseEvent::Type::Clicked,
                static_cast<MouseEvent::Button>(mouseInput.getButton()),
                mouseInput.getX(),
                mouseInput.getY());
 
            mFocusHandler->setLastWidgetPressed(nullptr);
        } else {
            mLastMousePressButton = 0;
            mClickCount           = 0;
        }
 
        if (mFocusHandler->getDraggedWidget() != nullptr) {
            mFocusHandler->setDraggedWidget(nullptr);
        }
    }
 
    Widget* Gui::getWidgetAt(int x, int y, Widget* exclude)
    {
        assert("Top widget must be set" && mTop != nullptr);
 
        // If the widget's parent has no child then we have found the widget..
        Widget* parent = mTop;
        Widget* child  = mTop;
 
        while (child != nullptr) {
            Widget* swap = child;
            int parentX  = 0;
            int parentY  = 0;
            parent->getAbsolutePosition(parentX, parentY);
            child  = parent->getWidgetAt(x - parentX, y - parentY, exclude);
            parent = swap;
        }
 
        return parent;
    }
 
    std::vector<Widget*> Gui::getWidgetsAt(int x, int y)
    {
        assert("Top widget must be set" && mTop != nullptr);
 
        std::vector<Widget*> result;
 
        Widget* widget = mTop;
 
        while (widget != nullptr) {
            result.push_back(widget);
            int absoluteX = 0;
            int absoluteY = 0;
            widget->getAbsolutePosition(absoluteX, absoluteY);
            widget = widget->getWidgetAt(x - absoluteX, y - absoluteY);
        }
 
        return result;
    }
 
    // =========================================================================
    // Helper functions for mouse event source routing
    // =========================================================================
 
    namespace
    {
        bool isDescendantOf(fcn::Widget const * child, fcn::Widget const * ancestor) noexcept
        {
            if (child == nullptr || ancestor == nullptr) {
                return false;
            }
 
            fcn::Widget const * current = child;
            while (current != nullptr) {
                if (current == ancestor) {
                    return true;
                }
                current = current->getParent();
            }
            return false;
        }

        fcn::Widget* getMouseCapture()
        {
            return fcn::Widget::getMouseCapture();
        }
    } // anonymous namespace
 
    // =========================================================================
    // Public API for explicit mouse capture (can be called from application code)
    // =========================================================================
 
    void Gui::captureMouse(Widget* widget)
    {
        if (widget != nullptr) {
            widget->captureMouse();
        }
    }
 
    void Gui::releaseMouse(Widget* widget)
    {
        if (widget != nullptr) {
            widget->releaseMouse();
        }
    }
 
    // =========================================================================
    // Gui::getMouseEventSource - Main implementation
    // =========================================================================
 
    Widget* Gui::getMouseEventSource(int x, int y)
    {
        Widget* leaf = getWidgetAt(x, y);
        if (leaf == nullptr) {
            return nullptr;
        }
 
        // 1. Check explicit capture first (platform-level) - HIGHEST PRECEDENCE
        if (Widget* explicitCapture = getMouseCapture()) {
            if (isDescendantOf(leaf, explicitCapture)) {
                return leaf;
            }
            return explicitCapture;
        }
 
        // 2. Fallback to modal stack's mouse owner
        Widget* modalRoot = mFocusHandler->getMouseCaptureOwner();
        if (modalRoot == nullptr) {
            return leaf;
        }
 
        // 3. If leaf is inside modal tree, let it receive events
        if (isDescendantOf(leaf, modalRoot)) {
            return leaf;
        }
 
        // 4. Outside modal tree -> block interaction by returning modal root
        return modalRoot;
    }
 
    Widget* Gui::getKeyEventSource()
    {
        Widget* widget = mFocusHandler->getFocused();
 
        while (widget->_getInternalFocusHandler() != nullptr &&
               widget->_getInternalFocusHandler()->getFocused() != nullptr) {
            widget = widget->_getInternalFocusHandler()->getFocused();
        }
 
        return widget;
    }
 
    void Gui::distributeMouseEvent(
        Widget* source,
        MouseEvent::Type type,
        MouseEvent::Button button,
        int x,
        int y,
        bool force,
        bool /*toSourceOnly*/)
    {
        Widget* parent = source;
        Widget* widget = source;
 
        Widget const * modalFocus = mFocusHandler->getFocusOwner();
        if (modalFocus != nullptr && !widget->isModalFocused() && !force) {
            return;
        }
 
        Widget const * modalMouse = mFocusHandler->getMouseCaptureOwner();
        if (modalMouse != nullptr && !widget->isUnderMouseModal() && !force) {
            return;
        }
 
        MouseEvent mouseEvent(
            source, source, mShiftPressed, mControlPressed, mAltPressed, mMetaPressed, type, button, x, y, mClickCount);
 
        while (parent != nullptr) {
            // If the widget has been removed due to input
            // cancel the distribution.
            if (!Widget::widgetExists(widget)) {
                break;
            }
 
            parent = widget->getParent();
 
            if (widget->isEnabled() || force) {
                int widgetX = 0;
                int widgetY = 0;
                widget->getAbsolutePosition(widgetX, widgetY);
 
                mouseEvent.mX                            = x - widgetX;
                mouseEvent.mY                            = y - widgetY;
                mouseEvent.mDistributor                  = widget;
                std::list<MouseListener*> mouseListeners = widget->_getMouseListeners();
 
                // Send the event to all mouse listeners of the widget.
                for (auto& mouseListener : mouseListeners) {
                    switch (mouseEvent.getType()) {
                    case MouseEvent::Type::Entered:
                        mouseListener->mouseEntered(mouseEvent);
                        break;
                    case MouseEvent::Type::Exited:
                        mouseListener->mouseExited(mouseEvent);
                        break;
                    case MouseEvent::Type::Moved:
                        mouseListener->mouseMoved(mouseEvent);
                        break;
                    case MouseEvent::Type::Pressed:
                        mouseListener->mousePressed(mouseEvent);
                        break;
                    case MouseEvent::Type::Released:
                        mouseListener->mouseReleased(mouseEvent);
                        break;
                    case MouseEvent::Type::WheelMovedUp:
                        mouseListener->mouseWheelMovedUp(mouseEvent);
                        break;
                    case MouseEvent::Type::WheelMovedDown:
                        mouseListener->mouseWheelMovedDown(mouseEvent);
                        break;
                    case MouseEvent::Type::WheelMovedRight:
                        mouseListener->mouseWheelMovedRight(mouseEvent);
                        break;
                    case MouseEvent::Type::WheelMovedLeft:
                        mouseListener->mouseWheelMovedLeft(mouseEvent);
                        break;
                    case MouseEvent::Type::Dragged:
                        mouseListener->mouseDragged(mouseEvent);
                        break;
                    case MouseEvent::Type::Clicked:
                        mouseListener->mouseClicked(mouseEvent);
                        break;
                    }
                }
            }
 
            Widget const * swap = widget;
            widget              = parent;
            parent              = swap->getParent();
 
            // If a non-modal focused widget has been reached
            // and we have modal focus cancel the distribution.
            Widget const * modalFocusLoop = mFocusHandler->getFocusOwner();
            if (modalFocusLoop != nullptr && widget != nullptr && !widget->isModalFocused()) {
                break;
            }
 
            // If a non-modal mouse input focused widget has been reached
            // and we have modal mouse input focus cancel the distribution.
            Widget const * modalMouseLoop = mFocusHandler->getMouseCaptureOwner();
            if (modalMouseLoop != nullptr && widget != nullptr && !widget->isUnderMouseModal()) {
                break;
            }
        }
    }
 
    void Gui::distributeKeyEvent(KeyEvent& keyEvent)
    {
        Widget* parent = keyEvent.getSource();
        Widget* widget = keyEvent.getSource();
 
        Widget const * modalFocus = mFocusHandler->getFocusOwner();
        if (modalFocus != nullptr && !widget->isModalFocused()) {
            return;
        }
 
        while (parent != nullptr) {
            // If the widget has been removed due to input
            // cancel the distribution.
            if (!Widget::widgetExists(widget)) {
                break;
            }
 
            parent = widget->getParent();
 
            if (widget->isEnabled()) {
                keyEvent.mDistributor                = widget;
                std::list<KeyListener*> keyListeners = widget->_getKeyListeners();
 
                // Send the event to all key listeners of the source widget.
                for (auto& keyListener : keyListeners) {
                    switch (keyEvent.getType()) {
                    case KeyEvent::Type::Pressed:
                        keyListener->keyPressed(keyEvent);
                        break;
                    case KeyEvent::Type::Released:
                        keyListener->keyReleased(keyEvent);
                        break;
                    default:
                        throwException("Unknown key event type.");
                    }
                }
            }
 
            Widget const * swap = widget;
            widget              = parent;
            parent              = swap->getParent();
 
            // If a non-modal focused widget has been reached
            // and we have modal focus cancel the distribution.
            Widget const * modalFocusLoop = mFocusHandler->getFocusOwner();
            if (modalFocusLoop != nullptr && !widget->isModalFocused()) {
                break;
            }
        }
    }
 
    void Gui::distributeKeyEventToGlobalKeyListeners(KeyEvent& keyEvent)
    {
        KeyListenerListIterator it;
 
        for (it = mKeyListeners.begin(); it != mKeyListeners.end(); ++it) {
            switch (keyEvent.getType()) {
            case KeyEvent::Type::Pressed:
                (*it)->keyPressed(keyEvent);
                break;
            case KeyEvent::Type::Released:
                (*it)->keyReleased(keyEvent);
                break;
            default:
                throwException("Unknown key event type.");
            }
 
            if (keyEvent.isConsumed()) {
                break;
            }
        }
    }
 
    void Gui::handleModalMouseInputFocus()
    {
        // Check if modal mouse input focus has been gained by a widget.
        if ((mFocusHandler->getLastWidgetWithModalMouseInputFocus() != mFocusHandler->getMouseCaptureOwner()) &&
            (mFocusHandler->getLastWidgetWithModalMouseInputFocus() == nullptr)) {
            handleModalMouseInputFocusGained();
        } else if (
            // Check if modal mouse input focus has been released.
            (mFocusHandler->getLastWidgetWithModalMouseInputFocus() != mFocusHandler->getMouseCaptureOwner()) &&
            (mFocusHandler->getLastWidgetWithModalMouseInputFocus() != nullptr)) {
            handleModalMouseInputFocusReleased();
        }
    }
 
    void Gui::handleModalFocus()
    {
        // Check if modal focus has been gained by a widget.
        if ((mFocusHandler->getLastWidgetWithModalFocus() != mFocusHandler->getFocusOwner()) &&
            (mFocusHandler->getLastWidgetWithModalFocus() == nullptr)) {
            handleModalFocusGained();
        } else if (
            // Check if modal focus has been released.
            (mFocusHandler->getLastWidgetWithModalFocus() != mFocusHandler->getFocusOwner()) &&
            (mFocusHandler->getLastWidgetWithModalFocus() != nullptr)) {
            handleModalFocusReleased();
        }
    }
 
    void Gui::handleModalFocusGained()
    {
        // Get all widgets at the last known mouse position
        // and send them a mouse exited event.
        std::vector<Widget*> const mWidgetsWithMouse = getWidgetsAt(mLastMouseX, mLastMouseY);
 
        for (auto const & w : mWidgetsWithMouse) {
            if (w->isModalFocused() || w->isUnderMouseModal()) {
                continue;
            }
            distributeMouseEvent(
                w,
                MouseEvent::Type::Exited,
                static_cast<MouseEvent::Button>(mLastMousePressButton),
                mLastMouseX,
                mLastMouseY,
                true,
                true);
        }
        mFocusHandler->setLastWidgetWithModalFocus(mFocusHandler->getFocusOwner());
    }
 
    void Gui::handleModalFocusReleased()
    {
        // Get all widgets at the last known mouse position
        // and send them a mouse entered event.
        std::vector<Widget*> const mWidgetsWithMouse = getWidgetsAt(mLastMouseX, mLastMouseY);
 
        for (auto const & w : mWidgetsWithMouse) {
            distributeMouseEvent(
                w,
                MouseEvent::Type::Entered,
                static_cast<MouseEvent::Button>(mLastMousePressButton),
                mLastMouseX,
                mLastMouseY,
                false,
                true);
        }
        mFocusHandler->setLastWidgetWithModalFocus(nullptr);
    }
 
    void Gui::handleModalMouseInputFocusGained()
    {
        // Get all widgets at the last known mouse position
        // and send them a mouse exited event.
        std::vector<Widget*> const mWidgetsWithMouse = getWidgetsAt(mLastMouseX, mLastMouseY);
 
        for (auto const & w : mWidgetsWithMouse) {
            if (w->isUnderMouseModal()) {
                continue;
            }
            distributeMouseEvent(
                w,
                MouseEvent::Type::Exited,
                static_cast<MouseEvent::Button>(mLastMousePressButton),
                mLastMouseX,
                mLastMouseY,
                true,
                true);
        }
        mFocusHandler->setLastWidgetWithModalMouseInputFocus(mFocusHandler->getMouseCaptureOwner());
    }
 
    void Gui::handleModalMouseInputFocusReleased()
    {
        // Get all widgets at the last known mouse position
        // and send them a mouse entered event.
        std::vector<Widget*> const mWidgetsWithMouse = getWidgetsAt(mLastMouseX, mLastMouseY);
 
        for (auto const & w : mWidgetsWithMouse) {
            distributeMouseEvent(
                w,
                MouseEvent::Type::Entered,
                static_cast<MouseEvent::Button>(mLastMousePressButton),
                mLastMouseX,
                mLastMouseY,
                false,
                true);
        }
        mFocusHandler->setLastWidgetWithModalMouseInputFocus(nullptr);
    }
 
    void Gui::handleHiddenWidgets()
    {
        // process snapshot of hidden widgets and clear the vector
        std::vector<Widget*> const pending = std::move(mHiddenWidgets);
        mHiddenWidgets.clear();
 
        for (auto* const hiddenWidget : pending) {
            // make sure that the widget wasn't freed after hiding
            if (Widget::widgetExists(hiddenWidget) && hiddenWidget->isEnabled()) {
                int hiddenWidgetX = 0;
                int hiddenWidgetY = 0;
                hiddenWidget->getAbsolutePosition(hiddenWidgetX, hiddenWidgetY);
 
                Rectangle const r(hiddenWidgetX, hiddenWidgetY, hiddenWidget->getWidth(), hiddenWidget->getHeight());
 
                if (r.isContaining(mLastMouseX, mLastMouseY)) {
                    // get the widget that has the cursor now and distribute that the mouse entered it
                    Widget* underMouseCursor = getWidgetAt(mLastMouseX, mLastMouseY);
 
                    distributeMouseEvent(
                        underMouseCursor,
                        MouseEvent::Type::Entered,
                        MouseEvent::Button::Empty,
                        mLastMouseX,
                        mLastMouseY,
                        true,
                        true);
                }
            }
        }
    }
 
    void Gui::handleShownWidgets()
    {
        // process snapshot of shown widgets and clear the vector
        std::vector<Widget*> const pending = std::move(mShownWidgets);
        mShownWidgets.clear();
 
        for (auto* shownWidget : pending) {
            // if the shown widget has the mouse cursor inside it
            int shownWidgetX = 0;
            int shownWidgetY = 0;
            shownWidget->getAbsolutePosition(shownWidgetX, shownWidgetY);
 
            Rectangle const r(shownWidgetX, shownWidgetY, shownWidget->getWidth(), shownWidget->getHeight());
 
            if (r.isContaining(mLastMouseX, mLastMouseY) && shownWidget->isEnabled()) {
                // find which widget had the mouse before and distribute that the mouse exited it
                Widget* underMouseCursorBefore = getWidgetAt(mLastMouseX, mLastMouseY, shownWidget);
 
                distributeMouseEvent(
                    underMouseCursorBefore,
                    MouseEvent::Type::Exited,
                    MouseEvent::Button::Empty,
                    mLastMouseX,
                    mLastMouseY,
                    true,
                    true);
 
                // find which specific widget in the shown widget had the mouse before
                // and distribute that the mouse exited it
                Widget* underMouseCursorNow = getWidgetAt(mLastMouseX, mLastMouseY);
 
                distributeMouseEvent(
                    underMouseCursorNow,
                    MouseEvent::Type::Entered,
                    MouseEvent::Button::Empty,
                    mLastMouseX,
                    mLastMouseY,
                    true,
                    true);
            }
        }
    }
} // namespace fcn