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(unsigned int buttons);
 
 
 unsigned int 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;
 unsigned int 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