focushandler.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_FOCUSHANDLER_HPP_
#define INCLUDE_FIFECHAN_FOCUSHANDLER_HPP_
 
// Standard library includes
#include <cstdio>
#include <vector>
 
// Project headers (subdirs before local)
#include "fifechan/events/event.hpp"
 
namespace fcn
{
    class Widget;

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

            virtual void requestFocus(Widget* widget);

            virtual bool isFocused(Widget const * widget) const;

            virtual Widget* getMouseCaptureOwner() const;

            virtual bool hasModalFocus() const;

            virtual void pushModal(Widget* focusOwner, Widget* mouseOwner = nullptr);

            virtual void popModal() noexcept;

            virtual void clearModal();

            class ModalScope
            {
                public:
                    ModalScope(FocusHandler* handler, Widget* focusOwner, Widget* mouseOwner = nullptr) :
                        mHandler(handler)
                    {
                        if (mHandler != nullptr) {
                            mHandler->pushModal(focusOwner, mouseOwner);
                        }
                    }
 
                    ~ModalScope() noexcept
                    {
                        if (mHandler != nullptr && !mReleased) {
                            mWasPopped = true;
                            // cppcheck-suppress throwInNoexceptFunction
                            mHandler->popModal();
                        }
 
                        if (!mWasPopped && !mReleased) {
                            // ModalScope was destroyed without calling release() or popModal()
                            // This indicates a bug where the modal was not properly released
                            std::fprintf(
                                stderr,
                                "Warning: ModalScope destroyed without calling release() or popModal(). Did you forget "
                                "to call release()?\n");
                        }
                    }
 
                    ModalScope(ModalScope const &)            = delete;
                    ModalScope& operator=(ModalScope const &) = delete;
                    ModalScope(ModalScope&&)                  = delete;
                    ModalScope& operator=(ModalScope&&)       = delete;

                    void release()
                    {
                        mReleased  = true;
                        mWasPopped = true;
                    }
 
                private:
                    FocusHandler* mHandler{nullptr};
                    bool mReleased{false};
                    bool mWasPopped{false};
            };

            using InputModalScope [[deprecated("Use InputModalScope instead")]] = ModalScope;

            virtual Widget* getFocusOwner() const;

            virtual void releaseFocus(Widget* widget);

            virtual void setFocusedWidget(Widget* widget);

            virtual Widget* getFocused() const;

            virtual void focusNext();

            virtual void focusPrevious();

            virtual void add(Widget* widget);

            virtual void remove(Widget* widget);

            virtual void focusNone();

            virtual void tabNext();

            virtual void tabPrevious();

            virtual Widget* getDraggedWidget();

            virtual void setDraggedWidget(Widget* draggedWidget);

            virtual Widget* getLastWidgetWithMouse();

            virtual void setLastWidgetWithMouse(Widget* lastWidgetWithMouse);

            virtual Widget* getLastWidgetWithModalFocus();

            virtual void setLastWidgetWithModalFocus(Widget* lastWidgetWithModalFocus);

            virtual Widget* getLastWidgetWithModalMouseInputFocus();

            virtual void setLastWidgetWithModalMouseInputFocus(Widget* lastWidgetWithModalMouseInputFocus);

            virtual Widget* getLastWidgetPressed();

            virtual void setLastWidgetPressed(Widget* lastWidgetPressed);

            virtual void widgetHidden(Widget* widget);
 
        protected:
            virtual void distributeFocusLostEvent(Event const & focusEvent);

            virtual void distributeFocusGainedEvent(Event const & focusEvent);

            using WidgetVector = std::vector<Widget*>;

            using WidgetIterator = WidgetVector::iterator;

            struct ModalState
            {
                    Widget* focusOwner;

                    Widget* mouseOwner;
            };

            std::vector<ModalState> mModalStack;

            WidgetVector mWidgets;

            Widget* mFocusedWidget;

            Widget* mDraggedWidget;

            Widget* mLastWidgetWithMouse;

            Widget* mLastWidgetWithModalFocus;

            Widget* mLastWidgetWithModalMouseInputFocus;

            Widget* mLastWidgetPressed;
    };
} // namespace fcn
 
#endif // INCLUDE_FIFECHAN_FOCUSHANDLER_HPP_