BackendGui.hpp

 
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2024 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/RelFloatRect.hpp>
#include <TGUI/Event.hpp>
#include <TGUI/Cursor.hpp>
#include <TGUI/TwoFingerScrollDetect.hpp>
 
#if !TGUI_EXPERIMENTAL_USE_STD_MODULE
    #include <chrono>
    #include <stack>
#endif
 
 
TGUI_MODULE_EXPORT 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);
 
        TGUI_NODISCARD RelFloatRect getViewport() const;
 
        void setAbsoluteView(const FloatRect& view);
 
        void setRelativeView(const FloatRect& view);
 
        TGUI_NODISCARD RelFloatRect getView() const;
 
        bool handleEvent(Event event);
 
        void setTabKeyUsageEnabled(bool enabled);
 
        TGUI_NODISCARD bool isTabKeyUsageEnabled() const;
 
        virtual void draw();
 
        TGUI_NODISCARD RootContainer::Ptr getContainer() const;
 
        TGUI_NODISCARD std::shared_ptr<BackendRenderTarget> getBackendRenderTarget() const;
 
        void setFont(const Font& font);
 
        TGUI_NODISCARD Font getFont() const;
 
        TGUI_NODISCARD const std::vector<Widget::Ptr>& getWidgets() const;
 
        void add(const Widget::Ptr& widgetPtr, const String& widgetName = "");
 
        TGUI_NODISCARD Widget::Ptr get(const String& widgetName) const;
 
        template <class WidgetType>
        TGUI_NODISCARD typename WidgetType::Ptr get(const String& widgetName) const
        {
            return m_container->get<WidgetType>(widgetName);
        }
 
        bool remove(const Widget::Ptr& widget);
 
        void removeAllWidgets();
 
        TGUI_NODISCARD Widget::Ptr getFocusedChild() const;
 
        TGUI_NODISCARD Widget::Ptr getFocusedLeaf() const;
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use getWidgetAtPos(pos, true) instead") TGUI_NODISCARD Widget::Ptr getWidgetAtPosition(Vector2f pos) const;
#endif
 
        TGUI_NODISCARD Widget::Ptr getWidgetAtPos(Vector2f pos, bool recursive) const;
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use getWidgetBelowMouseCursor(mousePos, true) instead") TGUI_NODISCARD Widget::Ptr getWidgetBelowMouseCursor(Vector2i mousePos) const;
#endif
 
        TGUI_NODISCARD Widget::Ptr getWidgetBelowMouseCursor(Vector2i mousePos, bool recursive) 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);
 
        TGUI_NODISCARD int getWidgetIndex(const Widget::Ptr& widget) const;
 
        void setOpacity(float opacity);
 
        TGUI_NODISCARD float getOpacity() const;
 
        void setTextSize(unsigned int size);
 
        TGUI_NODISCARD unsigned int getTextSize() const;
 
        void loadWidgetsFromFile(const String& filename, bool replaceExisting = true);
 
        void saveWidgetsToFile(const String& filename);
 
        void loadWidgetsFromStream(std::stringstream& stream, bool replaceExisting = true);
 
        void loadWidgetsFromStream(std::stringstream&& stream, bool replaceExisting = true);
 
        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);
 
        TGUI_NODISCARD Vector2f mapPixelToCoords(Vector2i pixel) const;
 
        TGUI_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);
 
        TGUI_NODISCARD virtual bool isKeyboardModifierPressed(Event::KeyModifier modifierKey) const; // TGUI_NEXT: Pure virtual
 
        void setKeyboardNavigationEnabled(bool enabled);
 
        TGUI_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.
        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;
        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;
    };
 
}
 
 
#endif // TGUI_BACKEND_GUI_HPP