ChildWindow.hpp

//
// TGUI - Texus's Graphical User Interface
// Copyright (C) 2012-2017 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/Widgets/Button.hpp>
#include <TGUI/Widgets/Label.hpp>


namespace tgui
{
 class ChildWindowRenderer;

 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 TitleButtons
 {
 None = 0, 
 Close = 1 << 0, 
 Minimize = 1 << 1, 
 Maximize = 1 << 2 
 };

 // Default constructor
 ChildWindow();


 static ChildWindow::Ptr create();


 static ChildWindow::Ptr copy(ChildWindow::ConstPtr childWindow);


 std::shared_ptr<ChildWindowRenderer> getRenderer() const
 {
 return std::static_pointer_cast<ChildWindowRenderer>(m_renderer);
 }


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


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


 virtual sf::Vector2f getFullSize() const override;


 void setMaximumSize(sf::Vector2f size);


 sf::Vector2f getMaximumSize() const;


 void setMinimumSize(sf::Vector2f size);


 sf::Vector2f getMinimumSize() const;


 virtual void setFont(const Font& font) override;


 virtual void setOpacity(float opacity) override;


 void setTitle(const sf::String& title);


 const sf::String& getTitle() const
 {
 return m_titleText.getText();
 }


 void setTitleAlignment(TitleAlignment alignment);


 TitleAlignment getTitleAlignment() const
 {
 return m_titleAlignment;
 }


 void setTitleButtons(TitleButtons buttons);


 TitleButtons getTitleButtons() const
 {
 return m_titleButtons;
 }


 void setTitleButtonsText(const sf::String& closeText = "x", const sf::String& minimizeText = "-", const sf::String& maximizeText = "+");


 void setIcon(const Texture& icon);


 const Texture& getIcon();


 void destroy();


 void setResizable(bool resizable = true);


 bool isResizable() const;


 void keepInParent(bool enabled = true);


 bool isKeptInParent() const;


 void setCloseButton(Button::Ptr closeButton);


 Button::Ptr getCloseButton() const;


 void setMinimizeButton(Button::Ptr minimizeButton);


 Button::Ptr getMinimizeButton() const;


 void setMaximizeButton(Button::Ptr maximizeButton);


 Button::Ptr getMaximizeButton() const;


 virtual sf::Vector2f getChildWidgetsOffset() const override;


 virtual bool mouseOnWidget(float x, float y) const override;

 virtual void leftMousePressed(float x, float y) override;

 virtual void leftMouseReleased(float x, float y) override;

 virtual void mouseMoved(float x, float y) override;

 virtual void mouseWheelMoved(int delta, int x, int y) override;

 virtual void mouseNoLongerOnWidget() override;

 virtual void mouseNoLongerDown() override;


 protected:

 virtual void reload(const std::string& primary = "", const std::string& secondary = "", bool force = false) override;


 // Makes a copy of the widget
 virtual Widget::Ptr clone() const override
 {
 return std::make_shared<ChildWindow>(*this);
 }


 // Draws the widget on the render target.
 virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;


 protected:

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

 protected:

 Texture m_iconTexture;

 Label m_titleText;
 sf::Vector2f m_draggingPosition;
 sf::Vector2f m_maximumSize;
 sf::Vector2f m_minimumSize;
 TitleAlignment m_titleAlignment = TitleAlignment::Center;
 TitleButtons m_titleButtons = TitleButtons::Close;
 sf::String m_closeButtonText = "x";
 sf::String m_minimizeButtonText = "-";
 sf::String m_maximizeButtonText = "+";

 std::shared_ptr<Button> m_closeButton = std::make_shared<Button>();
 std::shared_ptr<Button> m_minimizeButton = std::make_shared<Button>();
 std::shared_ptr<Button> m_maximizeButton = std::make_shared<Button>();

 bool m_mouseDownOnTitleBar = false;
 bool m_keepInParent = false;

 bool m_resizable = false;
 int m_resizeDirection = ResizeNone;

 friend class ChildWindowRenderer;

 };



 class TGUI_API ChildWindowRenderer : public WidgetRenderer, public WidgetBorders
 {
 public:

 ChildWindowRenderer(ChildWindow* childWindow) : m_childWindow{childWindow} {}


 virtual void setProperty(std::string property, const std::string& value) override;


 virtual void setProperty(std::string property, ObjectConverter&& value) override;


 virtual ObjectConverter getProperty(std::string property) const override;


 virtual std::map<std::string, ObjectConverter> getPropertyValuePairs() const override;


 void setTitleBarColor(const Color& color);


 void setTitleBarHeight(float height);


 void setTitleColor(const Color& color);


 void setBorderColor(const Color& borderColor);


 virtual void setBorders(const Borders& borders) override;
 using WidgetBorders::setBorders;


 void setDistanceToSide(float distanceToSide);

 void setPaddingBetweenButtons(float paddingBetweenButtons);

 void setBackgroundColor(const Color& backgroundColor);


 void setTitleBarTexture(const Texture& texture);


 std::shared_ptr<ButtonRenderer> getCloseButton() const;

 std::shared_ptr<ButtonRenderer> getMinimizeButton() const;

 std::shared_ptr<ButtonRenderer> getMaximizeButton() const;

 // Draws the widget on the render target.
 void draw(sf::RenderTarget& target, sf::RenderStates states) const;


 protected:

 // Makes a copy of the renderer
 virtual std::shared_ptr<WidgetRenderer> clone(Widget* widget) override;


 protected:

 ChildWindow* m_childWindow;

 float m_titleBarHeight = 0;
 float m_distanceToSide = 0;
 float m_paddingBetweenButtons = 3; // Pixels between buttons

 Texture m_textureTitleBar;

 sf::Color m_titleColor;
 sf::Color m_titleBarColor;

 sf::Color m_backgroundColor;
 sf::Color m_borderColor;

 sf::String m_closeButtonClassName = "";
 sf::String m_minimizeButtonClassName = "";
 sf::String m_maximizeButtonClassName = "";

 friend class ChildWindow;

 };

}


#endif // TGUI_CHILD_WINDOW_HPP