ChildWindow.hpp

//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2025 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_CHILD_WINDOW_HPP
#define TGUI_CHILD_WINDOW_HPP
 
#include <TGUI/CopiedSharedPtr.hpp>
#include <TGUI/Container.hpp>
#include <TGUI/Widgets/Button.hpp>
#include <TGUI/Renderers/ChildWindowRenderer.hpp>
 
#include <limits>

 
namespace tgui
{
    class TGUI_API ChildWindow : public Container
    {
    public:
 
        using Ptr = std::shared_ptr<ChildWindow>; 
        using ConstPtr = std::shared_ptr<const ChildWindow>; 
 
        static constexpr const char StaticWidgetType[] = "ChildWindow"; 

        using TitleAlignment TGUI_DEPRECATED("Use tgui::HorizontalAlignment instead") = HorizontalAlignment;

        enum TitleButton : unsigned int
        {
            None     = 0,      
            Close    = 1 << 0, 
            Maximize = 1 << 1, 
            Minimize = 1 << 2  
        };

        enum class CloseBehavior
        {
            None,   
            Hide,   
            Remove  
        };

        ChildWindow(const char* typeName = StaticWidgetType, bool initRenderer = true);

        ChildWindow(const ChildWindow&);

        ChildWindow(ChildWindow&&) noexcept;

        ChildWindow& operator= (const ChildWindow&);

        ChildWindow& operator= (ChildWindow&&) noexcept;

        TGUI_NODISCARD static ChildWindow::Ptr create(const String& title = "", unsigned int titleButtons = TitleButton::Close);

        TGUI_NODISCARD static ChildWindow::Ptr copy(const ChildWindow::ConstPtr& childWindow);

        TGUI_NODISCARD ChildWindowRenderer* getSharedRenderer() override;
        TGUI_NODISCARD const ChildWindowRenderer* getSharedRenderer() const override;

        TGUI_NODISCARD ChildWindowRenderer* getRenderer() override;

        void setPosition(const Layout2d& position) override;
        using Widget::setPosition;

        void setSize(const Layout2d& size) override;
        using Widget::setSize;

        TGUI_NODISCARD Vector2f getInnerSize() const override;

        virtual void setClientSize(const Layout2d& size);

        TGUI_NODISCARD Vector2f getClientSize() const;

        void setMaximumSize(Vector2f size);

        TGUI_NODISCARD Vector2f getMaximumSize() const;

        void setMinimumSize(Vector2f size);

        TGUI_NODISCARD Vector2f getMinimumSize() const;

        void setTitle(const String& title);

        TGUI_NODISCARD const String& getTitle() const;

        void setTitleTextSize(unsigned int size);

        TGUI_NODISCARD unsigned int getTitleTextSize() const;

        void setTitleAlignment(HorizontalAlignment alignment);

        TGUI_NODISCARD HorizontalAlignment getTitleAlignment() const;

        void setTitleButtons(unsigned int buttons);

        TGUI_NODISCARD unsigned int getTitleButtons() const;

        void setCloseBehavior(CloseBehavior behavior);

        TGUI_NODISCARD CloseBehavior getCloseBehavior() const;

        void close();

        TGUI_DEPRECATED("Use parent->remove(childWindow) instead") void destroy();

        void setResizable(bool resizable = true);

        TGUI_NODISCARD bool isResizable() const;

        void setPositionLocked(bool positionLocked = true);

        TGUI_NODISCARD bool isPositionLocked() const;

        void setKeepInParent(bool enabled = true);
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use getKeepInParent instead") TGUI_NODISCARD bool isKeptInParent() const;
#endif

        TGUI_NODISCARD bool getKeepInParent() const;

        TGUI_NODISCARD Vector2f getChildWidgetsOffset() const override;

        void setParent(Container* parent) override;

        TGUI_NODISCARD bool isMouseOnWidget(Vector2f pos) const override;

        bool leftMousePressed(Vector2f pos) override;

        void leftMouseReleased(Vector2f pos) override;

        void rightMousePressed(Vector2f pos) override;

        void rightMouseReleased(Vector2f pos) override;

        void mouseMoved(Vector2f pos) override;

        void keyPressed(const Event::KeyEvent& event) override;

        bool canHandleKeyPress(const Event::KeyEvent& event) override;

        void mouseNoLongerOnWidget() override;

        void leftMouseButtonNoLongerDown() override;

        void draw(BackendRenderTarget& target, RenderStates states) const override;

    protected:

        // Updates the title bar texture, text and buttons after the title bar height has changed.
        void updateTitleBarHeight();

        // Returns the size of the title bar without its borders
        TGUI_NODISCARD Vector2f getInnerTitleBarSize() const;

        // Returns the size of the client area plus the client padding around it
        TGUI_NODISCARD Vector2f getInnerSizeWithPadding() const;

        // Returns the difference between the child window size and its client size.
        // This returns the combined size of the title bar, borders and padding.
        TGUI_NODISCARD Vector2f getDecorationSize() const;

        // Updates the mouse cursor for resizable child windows
        void updateResizeMouseCursor(Vector2f mousePos);

        TGUI_NODISCARD Signal& getSignal(String signalName) override;

        void rendererChanged(const String& property) override;

        TGUI_NODISCARD std::unique_ptr<DataIO::Node> save(SavingRenderersMap& renderers) const override;

        void load(const std::unique_ptr<DataIO::Node>& node, const LoadingRenderersMap& renderers) override;

        void mouseEnteredWidget() override;

        void mouseLeftWidget() override;

        // Makes a copy of the widget
        TGUI_NODISCARD Widget::Ptr clone() const override;

    private:

        // Helper function to connect the title button callbacks from the various constuctors and assignment operators
        void connectTitleButtonCallbacks();

    public:
 
        Signal            onMousePress = {"MousePressed"};  
        SignalChildWindow onClose      = {"Closed"};        
        SignalChildWindow onMinimize   = {"Minimized"};     
        SignalChildWindow onMaximize   = {"Maximized"};     
        SignalChildWindow onEscapeKeyPress = {"EscapeKeyPressed"}; 

        SignalTyped<bool*> onClosing = {"Closing"};

    protected:
 
        enum ResizeDirection
        {
            ResizeNone   = 0,
            ResizeLeft   = 1,
            ResizeTop    = 2,
            ResizeRight  = 4,
            ResizeBottom = 8
        };

    protected:
 
        Text           m_titleText;
        Vector2f       m_draggingPosition;
        Vector2f       m_maximumSize    = {std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity()};
        Vector2f       m_minimumSize    = {0, 0};
        Layout*        m_decorationLayoutX = nullptr;
        Layout*        m_decorationLayoutY = nullptr;
        HorizontalAlignment m_titleAlignment = HorizontalAlignment::Center;
        unsigned int   m_titleButtons   = TitleButton::Close;
        unsigned int   m_titleTextSize  = 0;
        Cursor::Type   m_currentChildWindowMouseCursor = Cursor::Type::Arrow;
        CloseBehavior  m_closeBehavior = CloseBehavior::Remove;
 
        CopiedSharedPtr<Button> m_closeButton;
        CopiedSharedPtr<Button> m_minimizeButton;
        CopiedSharedPtr<Button> m_maximizeButton;
 
        bool m_mouseDownOnTitleBar = false;
        bool m_keepInParent = false;
 
        bool m_positionLocked = false;
        bool m_resizable = false;
        int m_resizeDirection = ResizeNone;
 
        Sprite m_spriteTitleBar;
        Sprite m_spriteBackground;
 
        // Cached renderer properties
        Borders m_bordersCached;
        Padding m_clientPaddingCached;
        Color   m_borderColorCached;
        Color   m_borderColorFocusedCached;
        Color   m_titleColorCached;
        Color   m_titleBarColorCached;
        Color   m_backgroundColorCached;
        float   m_titleBarHeightCached = 20;
        float   m_borderBelowTitleBarCached = 0;
        float   m_distanceToSideCached = 0;
        float   m_paddingBetweenButtonsCached = 0;
        float   m_minimumResizableBorderWidthCached = 10;
        bool    m_showTextOnTitleButtonsCached = false;

    };

}

 
#endif // TGUI_CHILD_WINDOW_HPP