ChildWindow.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_CHILD_WINDOW_HPP
#define TGUI_CHILD_WINDOW_HPP
 
#include <TGUI/Container.hpp>
#include <TGUI/CopiedSharedPtr.hpp>
#include <TGUI/Renderers/ChildWindowRenderer.hpp>
#include <TGUI/Widgets/Button.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 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 
        };

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

        ChildWindow(const ChildWindow& other);

        ChildWindow(ChildWindow&& other) noexcept;

        ChildWindow& operator=(const ChildWindow& other);

        ChildWindow& operator=(ChildWindow&& other) noexcept;

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

        [[nodiscard]] static ChildWindow::Ptr copy(const ChildWindow::ConstPtr& childWindow);

        [[nodiscard]] ChildWindowRenderer* getSharedRenderer() override;
        [[nodiscard]] const ChildWindowRenderer* getSharedRenderer() const override;

        [[nodiscard]] ChildWindowRenderer* getRenderer() override;

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

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

        [[nodiscard]] Vector2f getInnerSize() const override;

        virtual void setClientSize(const Layout2d& size);

        [[nodiscard]] Vector2f getClientSize() const;

        void setMaximumSize(Vector2f size);

        [[nodiscard]] Vector2f getMaximumSize() const;

        void setMinimumSize(Vector2f size);

        [[nodiscard]] Vector2f getMinimumSize() const;

        void setTitle(const String& title);

        [[nodiscard]] const String& getTitle() const;

        void setTitleTextSize(unsigned int size);

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

        void setTitleAlignment(HorizontalAlignment alignment);

        [[nodiscard]] HorizontalAlignment getTitleAlignment() const;

        void setTitleButtons(unsigned int buttons);

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

        void setCloseBehavior(CloseBehavior behavior);

        [[nodiscard]] CloseBehavior getCloseBehavior() const;

        void close();

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

        void setResizable(bool resizable = true);

        [[nodiscard]] bool isResizable() const;

        void setPositionLocked(bool positionLocked = true);

        [[nodiscard]] bool isPositionLocked() const;

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

        [[nodiscard]] bool getKeepInParent() const;

        [[nodiscard]] Vector2f getChildWidgetsOffset() const override;

        void setParent(Container* parent) override;

        [[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
        [[nodiscard]] Vector2f getInnerTitleBarSize() const;

        // Returns the size of the client area plus the client padding around it
        [[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.
        [[nodiscard]] Vector2f getDecorationSize() const;

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

        [[nodiscard]] Signal& getSignal(String signalName) override;

        void rendererChanged(const String& property) override;

        [[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
        [[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;
    };
} // namespace tgui
 
#endif // TGUI_CHILD_WINDOW_HPP