Gui.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_WINDOW_HPP
#define TGUI_WINDOW_HPP
 
 
#include <queue>
 
#include <TGUI/Container.hpp>
 
 
namespace tgui
{
 class TGUI_API Gui
 {
 public:
 
 Gui();
 
 
 Gui(sf::RenderWindow& window);
 
 
 Gui(sf::RenderTarget& window);
 
 
 // Deleted copy constructor
 Gui(const Gui& copy) = delete;
 
 
 // Deleted assignment operator overload
 Gui& operator=(const Gui& right) = delete;
 
 
 void setWindow(sf::RenderWindow& window);
 
 
 void setWindow(sf::RenderTarget& window);
 
 
 sf::RenderTarget* getWindow() const
 {
 return m_window;
 }
 
 
 void setView(const sf::View& view);
 
 
 const sf::View& getView() const
 {
 return m_view;
 }
 
 
 bool handleEvent(sf::Event event);
 
 
 void draw();
 
 
 sf::Vector2f getSize() const;
 
 
 GuiContainer::Ptr getContainer() const
 {
 return m_container;
 }
 
 
 void setFont(const Font& font)
 {
 m_container->setFont(font);
 }
 
 
 std::shared_ptr<sf::Font> getFont() const
 {
 return m_container->getFont();
 }
 
 
 const std::vector< Widget::Ptr >& getWidgets()
 {
 return m_container->getWidgets();
 }
 
 
 const std::vector<sf::String>& getWidgetNames()
 {
 return m_container->getWidgetNames();
 }
 
 
 void add(const Widget::Ptr& widgetPtr, const sf::String& widgetName = "");
 
 
 Widget::Ptr get(const sf::String& widgetName, bool recursive = false) const;
 
 
 template <class T>
 typename T::Ptr get(const sf::String& widgetName, bool recursive = false) const
 {
 return m_container->get<T>(widgetName, recursive);
 }
 
 
 bool remove(const Widget::Ptr& widget);
 
 
 void removeAllWidgets();
 
 
 bool setWidgetName(const Widget::Ptr& widget, const std::string& name);
 
 
 std::string getWidgetName(const Widget::Ptr& widget) const;
 
 
 void focusWidget(const Widget::Ptr& widget);
 
 
 void focusNextWidget();
 
 
 void focusPreviousWidget();
 
 
 void unfocusWidgets();
 
 
 void uncheckRadioButtons();
 
 
 void setOpacity(float opacity);
 
 
 float getOpacity() const;
 
 
 void loadWidgetsFromFile(const std::string& filename);
 
 
 void saveWidgetsToFile(const std::string& filename);
 
 
 void loadWidgetsFromStream(std::stringstream& stream);
 
 
 void saveWidgetsToStream(std::stringstream& stream);
 
 
 // Update the internal clock to make animation possible. This function is called automatically by the draw function.
 // You will thus only need to call it yourself when you are drawing everything manually.
 void updateTime(const sf::Time& elapsedTime);
 
 
 protected:
 
 // The internal clock which is used for animation of widgets
 sf::Clock m_clock;
 
 // The sfml window or other target to draw on
 sf::RenderTarget* m_window;
 
 #if SFML_VERSION_MAJOR == 2 && SFML_VERSION_MINOR < 5
 // Does m_Window contains a sf::RenderWindow?
 bool m_accessToWindow;
 #endif
 
 // Internal container to store all widgets
 GuiContainer::Ptr m_container = std::make_shared<GuiContainer>();
 
 Widget::Ptr m_visibleToolTip = nullptr;
 sf::Time m_tooltipTime;
 bool m_tooltipPossible = false;
 sf::Vector2f m_lastMousePos;
 
 sf::View m_view;
 
 
 };
 
 
}
 
 
#endif // TGUI_WINDOW_HPP