ChildWindow.hpp

 
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2022 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:
 
        typedef std::shared_ptr<ChildWindow> Ptr; 
        typedef std::shared_ptr<const ChildWindow> ConstPtr; 
 
 
        enum class TitleAlignment
        {
            Left,   
            Center, 
            Right   
        };
 
 
        enum TitleButton
        {
            None     = 0,      
            Close    = 1 << 0, 
            Maximize = 1 << 1, 
            Minimize = 1 << 2  
        };
 
        ChildWindow(const char* typeName = "ChildWindow", bool initRenderer = true);
 
 
        ChildWindow(const ChildWindow&);
 
 
        ChildWindow(ChildWindow&&) noexcept;
 
 
        ChildWindow& operator= (const ChildWindow&);
 
 
        ChildWindow& operator= (ChildWindow&&) noexcept;
 
 
        static ChildWindow::Ptr create(const String& title = "", unsigned int titleButtons = TitleButton::Close);
 
 
        static ChildWindow::Ptr copy(ChildWindow::ConstPtr childWindow);
 
 
        ChildWindowRenderer* getSharedRenderer();
        const ChildWindowRenderer* getSharedRenderer() const;
 
        ChildWindowRenderer* getRenderer();
        const ChildWindowRenderer* getRenderer() const;
 
 
        void setPosition(const Layout2d& position) override;
        using Widget::setPosition;
 
 
        void setSize(const Layout2d& size) override;
        using Widget::setSize;
 
 
        Vector2f getInnerSize() const override;
 
 
        void setClientSize(const Layout2d& size);
 
 
        Vector2f getClientSize() const;
 
 
        void setMaximumSize(Vector2f size);
 
 
        Vector2f getMaximumSize() const;
 
 
        void setMinimumSize(Vector2f size);
 
 
        Vector2f getMinimumSize() const;
 
 
        void setTitle(const String& title);
 
 
        const String& getTitle() const;
 
 
        void setTitleTextSize(unsigned int size);
 
 
        unsigned int getTitleTextSize() const;
 
 
        void setTitleAlignment(TitleAlignment alignment);
 
 
        TitleAlignment getTitleAlignment() const;
 
 
        void setTitleButtons(unsigned int buttons);
 
 
        unsigned int getTitleButtons() const;
 
 
        void close();
 
 
        void destroy();
 
 
        void setResizable(bool resizable = true);
 
 
        bool isResizable() const;
 
 
        void setPositionLocked(bool positionLocked = true);
 
 
        bool isPositionLocked() const;
 
 
        void setKeepInParent(bool enabled = true);
 
 
        bool isKeptInParent() const;
 
 
        Vector2f getChildWidgetsOffset() const override;
 
 
        void setParent(Container* parent) override;
 
 
        bool isMouseOnWidget(Vector2f pos) const override;
 
        void 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;
 
        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();
 
 
        // Updates the mouse cursor for resizable child windows
        void updateResizeMouseCursor(Vector2f mousePos);
 
 
        Signal& getSignal(String signalName) override;
 
 
        void rendererChanged(const String& property) override;
 
 
        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
        Widget::Ptr clone() const override;
 
 
    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;
        TitleAlignment m_titleAlignment = TitleAlignment::Center;
        unsigned int   m_titleButtons   = TitleButton::Close;
        unsigned int   m_titleTextSize  = 0;
        Cursor::Type   m_currentChildWindowMouseCursor = Cursor::Type::Arrow;
 
        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;
        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