BackendGui.hpp

//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2026 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
#ifndef TGUI_BACKEND_GUI_HPP
#define TGUI_BACKEND_GUI_HPP
 
#include <TGUI/Container.hpp>
#include <TGUI/Cursor.hpp>
#include <TGUI/Event.hpp>
#include <TGUI/RelFloatRect.hpp>
#include <TGUI/TwoFingerScrollDetect.hpp>
 
#include <chrono>
#include <stack>

 
namespace tgui
{
    class TGUI_API BackendGui
    {
    public:
        BackendGui();

        // Deleted copy constructor
        BackendGui(const BackendGui& copy) = delete;

        // Deleted assignment operator overload
        BackendGui& operator=(const BackendGui& right) = delete;

        // Virtual destructor
        virtual ~BackendGui();

        void setAbsoluteViewport(const FloatRect& viewport);

        void setRelativeViewport(const FloatRect& viewport);

        [[nodiscard]] RelFloatRect getViewport() const;

        void setAbsoluteView(const FloatRect& view);

        void setRelativeView(const FloatRect& view);

        [[nodiscard]] RelFloatRect getView() const;

        bool handleEvent(Event event);

        void setTabKeyUsageEnabled(bool enabled);

        [[nodiscard]] bool isTabKeyUsageEnabled() const;

        // TGUI_NEXT: Remove from base class, as some backends require parameters. Each Gui class should declare its own
        //            draw function with the parameters that its renderer needs, and mainLoop should render via functions
        //            in the render target to start and present a frame instead of relying on draw() and presentScreen().
        virtual void draw();

        [[nodiscard]] RootContainer::Ptr getContainer() const;

        [[nodiscard]] std::shared_ptr<BackendRenderTarget> getBackendRenderTarget() const;

        void setFont(const Font& font);

        [[nodiscard]] Font getFont() const;

        [[nodiscard]] const std::vector<Widget::Ptr>& getWidgets() const;

        void add(const Widget::Ptr& widgetPtr, const String& widgetName = "");

        [[nodiscard]] Widget::Ptr get(const String& widgetName) const;

        template <class WidgetType>
        [[nodiscard]] typename WidgetType::Ptr get(const String& widgetName) const
        {
            return m_container->get<WidgetType>(widgetName);
        }

        bool remove(const Widget::Ptr& widget);

        void removeAllWidgets();

        [[nodiscard]] Widget::Ptr getFocusedChild() const;

        [[nodiscard]] Widget::Ptr getFocusedLeaf() const;
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use getWidgetAtPos(pos, true) instead")
        [[nodiscard]] Widget::Ptr getWidgetAtPosition(Vector2f pos) const;
#endif

        [[nodiscard]] Widget::Ptr getWidgetAtPos(Vector2f pos, bool recursive) const;
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use getWidgetBelowMouseCursor(mousePos, true) instead")
        [[nodiscard]] Widget::Ptr getWidgetBelowMouseCursor(Vector2i mousePos) const;
#endif

        [[nodiscard]] Widget::Ptr getWidgetBelowMouseCursor(Vector2i mousePos, bool recursive) const;

        [[nodiscard]] Vector2i getLastMousePosition() const;

        bool focusNextWidget(bool recursive = true);

        bool focusPreviousWidget(bool recursive = true);

        void unfocusAllWidgets();

        void moveWidgetToFront(const Widget::Ptr& widget);

        void moveWidgetToBack(const Widget::Ptr& widget);

        std::size_t moveWidgetForward(const Widget::Ptr& widget);

        std::size_t moveWidgetBackward(const Widget::Ptr& widget);

        bool setWidgetIndex(const Widget::Ptr& widget, std::size_t index);

        [[nodiscard]] int getWidgetIndex(const Widget::Ptr& widget) const;

        void setOpacity(float opacity);

        [[nodiscard]] float getOpacity() const;

        void setTextSize(unsigned int size);

        [[nodiscard]] unsigned int getTextSize() const;

        void loadWidgetsFromFile(const String& filename, bool replaceExisting = true);

        void loadWidgetsFromFile(const String& filename, const FormLoadOptions& options);

        void saveWidgetsToFile(const String& filename) const;

        void loadWidgetsFromStream(std::stringstream& stream, bool replaceExisting = true);

        void loadWidgetsFromStream(std::stringstream&& stream, bool replaceExisting = true);

        void loadWidgetsFromStream(std::stringstream& stream, const FormLoadOptions& options);

        void loadWidgetsFromStream(std::stringstream&& stream, const FormLoadOptions& options);

        void saveWidgetsToStream(std::stringstream& stream) const;

        void setOverrideMouseCursor(Cursor::Type type);

        void restoreOverrideMouseCursor();

        void requestMouseCursor(Cursor::Type type);

        void setDrawingUpdatesTime(bool drawUpdatesTime);

        bool updateTime();

        bool updateTime(Duration elapsedTime);

        [[nodiscard]] Vector2f mapPixelToCoords(Vector2i pixel) const;

        [[nodiscard]] Vector2f mapCoordsToPixel(Vector2f coord) const;

        virtual void mainLoop(Color clearColor = {240, 240, 240}) = 0;

        virtual void startTextInput(FloatRect inputRect);

        virtual void stopTextInput();

        virtual void updateTextCursorPosition(FloatRect inputRect, Vector2f caretPos);

        [[nodiscard]] virtual bool isKeyboardModifierPressed(Event::KeyModifier modifierKey) const; // TGUI_NEXT: Pure virtual

        void setKeyboardNavigationEnabled(bool enabled);

        [[nodiscard]] bool isKeyboardNavigationEnabled() const;

 
    protected:
        // Handles the backend-independent part of the two finger scrolling.
        // Returns whether the touch event should be absorbed by the gui.
        bool handleTwoFingerScroll(bool wasAlreadyScrolling);

        // Updates the view and changes the size of the root container when needed.
        // Derived classes should update m_framebufferSize in this function and then call this function from the base class.
        virtual void updateContainerSize();

        // Used when the NumLock is off to translate keypad key events to key events for text cursor navigation.
        // The key parameter should be a value from Numpad0 to Numpad9 and the output is the key code that corresponds to the
        // wanted functionality (e.g. for Numpad0 we return the Insert key). Unknown is returned for Numpad5.
        static Event::KeyboardKey translateKeypadKey(Event::KeyboardKey key);

 
    public:
        SignalFloatRect onViewChange = {"ViewChanged"}; 
        Signal onWindowFocus = {"WindowFocused"};       
        Signal onWindowUnfocus = {"WindowUnfocused"};   

 
    protected:
        std::chrono::steady_clock::time_point m_lastUpdateTime;
        bool m_windowFocused = true;
 
        RootContainer::Ptr m_container = std::make_shared<RootContainer>();
 
        Widget::Ptr m_visibleToolTip = nullptr;
        Duration m_tooltipTime;
        bool m_tooltipPossible = false;
        Vector2f m_toolTipRelativePos;
        Vector2i m_lastMousePos;
        std::uintptr_t m_trackedFingerId = 0;
        TwoFingerScrollDetect m_twoFingerScroll;
 
        Vector2i m_framebufferSize;
        RelFloatRect m_viewport{RelativeValue{0}, RelativeValue{0}, RelativeValue{1}, RelativeValue{1}};
        RelFloatRect m_view{RelativeValue{0}, RelativeValue{0}, RelativeValue{1}, RelativeValue{1}};
        FloatRect m_lastView;
 
        bool m_drawUpdatesTime = true;
        bool m_tabKeyUsageEnabled = true;
        bool m_keyboardNavigationEnabled = false; // TGUI_NEXT: Enable by default?
 
        Cursor::Type m_requestedMouseCursor = Cursor::Type::Arrow;
        std::stack<Cursor::Type> m_overrideMouseCursors;
 
        std::shared_ptr<BackendRenderTarget> m_backendRenderTarget = nullptr;
    };

} // namespace tgui

 
#endif // TGUI_BACKEND_GUI_HPP