rubenwardy
/
TGUI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

💥 Theme and Renderer implementations were changed to allow a default theme to be set

0.8
Bruno Van de Velde 2017-09-22 23:31:09 +02:00
parent 5c6aacb9fe
commit b2b8c1fb46
94 changed files with 2087 additions and 1002 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
include/TGUI/Color.hpp
View File

@ -65,7 +65,10 @@ namespace tgui
/// The isSet function will return false when the object was created using this constructor.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color();
Color() :
m_isSet{false}
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -74,7 +77,11 @@ namespace tgui
/// @param color Color to set
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color(const sf::Color& color);
Color(const sf::Color& color) :
m_isSet{true},
m_color{color}
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -86,7 +93,11 @@ namespace tgui
/// @param alpha Alpha component
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color(sf::Uint8 red, sf::Uint8 green, sf::Uint8 blue, sf::Uint8 alpha = 255);
Color(sf::Uint8 red, sf::Uint8 green, sf::Uint8 blue, sf::Uint8 alpha = 255) :
m_isSet{true},
m_color{red, green, blue, alpha}
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -165,6 +176,30 @@ namespace tgui
sf::Uint8 getAlpha() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the color with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator==(const Color& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the color with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator!=(const Color& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the color with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator==(const sf::Color& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the color with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator!=(const sf::Color& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private:

12
include/TGUI/Font.hpp
View File

@ -133,6 +133,18 @@ namespace tgui
bool operator!=(std::nullptr_t) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the font with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator==(const Font& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the font with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator!=(const Font& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Retrieve a glyph of the font
///

50
include/TGUI/Loading/Theme.hpp
View File

@ -45,11 +45,18 @@ namespace tgui
/// @brief Constructs the theme class, with an optional theme file to load
///
/// @param primary Primary parameter for the theme loader (filename of the theme file in DefaultThemeLoader)
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Theme(const std::string& primary = "");
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Destructor
///
/// When a pointer to this theme was passed to setDefault, the default theme will be reset.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
~Theme();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the primary theme loader parameter
///
@ -57,7 +64,6 @@ namespace tgui
///
/// When the theme was loaded before and a renderer with the same name is encountered, the widgets that were using
/// the old renderer will be reloaded with the new renderer.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void load(const std::string& primary);
@ -69,10 +75,23 @@ namespace tgui
///
/// @return Shared renderer data
///
/// @throw
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<RendererData> getRenderer(const std::string& id);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Gets data for the renderers
///
/// @param id The secondary parameter for the theme loader (name of section in theme file in DefaultThemeLoader).
///
/// @return Shared renderer data
///
/// Unlike getRenderer which throws an exception, this function will return nullptr when the renderer is not found
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<RendererData> getRendererNoThrow(const std::string& id);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Manually adds a renderer data to the theme
///
@ -81,7 +100,6 @@ namespace tgui
///
/// If a renderer with the same id already exists then it will be replaced by this one.
/// Widgets using the old renderer will keep using that old renderer and remain unchanged.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void addRenderer(const std::string& id, std::shared_ptr<RendererData> renderer);
@ -92,7 +110,6 @@ namespace tgui
/// @param id Identifier of the renderer
///
/// @return True when removed, false when the identifier did not match any renderer
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool removeRenderer(const std::string& id);
@ -101,7 +118,6 @@ namespace tgui
/// @brief Changes the function that will load the widget theme data
///
/// @param themeLoader Pointer to the new loader
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void setThemeLoader(std::shared_ptr<BaseThemeLoader> themeLoader);
@ -110,14 +126,36 @@ namespace tgui
/// @brief Returns the function that is currently being used to load the widget theme data
///
/// @return Theme loader
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static std::shared_ptr<BaseThemeLoader> getThemeLoader();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets the theme class that widgets use by default
///
/// @param theme Theme to use as default
///
/// The default theme will automatically be reset to nullptr when the theme that is pointed to is destructed.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void setDefault(Theme* theme);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns a pointer to the theme class that widgets use by default
///
/// @return Default theme
///
/// @warning When setDefault was not called or was given a nullptr as parameter, getDefault will return the default
/// theme. If you set textures in this theme then you MUST call setDefault(nullptr) before the end of the
/// program to prevent a potential crash due to undefined order of destruction.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static Theme* getDefault();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected:
static Theme* m_defaultTheme;
static std::shared_ptr<BaseThemeLoader> m_themeLoader; ///< Theme loader which will do the actual loading
std::map<std::string, std::shared_ptr<RendererData>> m_renderers; ///< Maps ids to renderer datas
std::string m_primary;

31
include/TGUI/Loading/ThemeLoader.hpp
View File

@ -40,7 +40,6 @@ namespace tgui
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Base class for theme loader implementations
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class TGUI_API BaseThemeLoader
{
@ -56,7 +55,6 @@ namespace tgui
/// @brief Optionally already do some work when only the primary parameter is known yet
///
/// @param primary Primary parameter of the loader (filename of the theme file in DefaultThemeLoader)
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void preload(const std::string& primary);
@ -70,11 +68,23 @@ namespace tgui
/// For the default loader, the primary parameter is the filename while the secondary parameter is the section name.
///
/// @return Map op property-value pairs
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual const std::map<sf::String, sf::String>& load(const std::string& primary, const std::string& secondary) = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Check if the requested property-value pairs are available
///
/// @param primary Primary parameter of the loader
/// @param secondary Secondary parameter of the loader
///
/// For the default loader, the primary parameter is the filename while the secondary parameter is the section name.
///
/// @return Whether a map op property-value pairs is available
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual bool canLoad(const std::string& primary, const std::string& secondary) = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
};
@ -86,7 +96,6 @@ namespace tgui
/// This loader will be able to extract the data from these files.
///
/// On first access, the entire file will be cached, the next times the cached map is simply returned.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class TGUI_API DefaultThemeLoader : public BaseThemeLoader
{
@ -98,7 +107,6 @@ namespace tgui
/// @param filename Filename of the theme file to load
///
/// @exception Exception when finding syntax errors in the file
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void preload(const std::string& filename) override;
@ -113,17 +121,26 @@ namespace tgui
///
/// @exception Exception when finding syntax errors in the file
/// @exception Exception when file did not contain requested class name
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const std::map<sf::String, sf::String>& load(const std::string& filename, const std::string& section) override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Check if the requested property-value pairs are available
///
/// @param filename Filename of the theme file
/// @param section Name of the section inside the theme file
///
/// @return Whether a map op property-value pairs is available
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool canLoad(const std::string& filename, const std::string& section) override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Empties the caches and force files to be reloaded.
///
/// @param filename File to remove from cache.
/// If no filename is given, the entire cache is cleared.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void flushCache(const std::string& filename = "");

16
include/TGUI/ObjectConverter.hpp
View File

@ -348,6 +348,22 @@ namespace tgui
Type getType() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Check if the object equals another one
///
/// Objects with different types will always be considered as different, even if using them would have the same outcome
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator==(const ObjectConverter& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Check if the object differs from another one
///
/// Objects with different types will always be considered as different, even if using them would have the same outcome
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator!=(const ObjectConverter& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private:
Type m_type = Type::None;

9
include/TGUI/RendererDefines.hpp
View File

@ -27,7 +27,7 @@
#define TGUI_RENDERER_DEFINES_HPP
#include <TGUI/Global.hpp>
#include <TGUI/Loading/Theme.hpp>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -117,7 +117,7 @@
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define TGUI_RENDERER_PROPERTY_RENDERER(CLASS, NAME) \
#define TGUI_RENDERER_PROPERTY_RENDERER(CLASS, NAME, RENDERER) \
std::shared_ptr<RendererData> CLASS::get##NAME() const \
{ \
const auto it = m_data->propertyValuePairs.find(toLower(#NAME)); \
@ -125,8 +125,9 @@
return it->second.getRenderer(); \
else \
{ \
m_data->propertyValuePairs[toLower(#NAME)] = {RendererData::create()}; \
return m_data->propertyValuePairs[toLower(#NAME)].getRenderer(); \
auto renderer = Theme::getDefault()->getRendererNoThrow(RENDERER); \
m_data->propertyValuePairs[toLower(#NAME)] = {renderer ? renderer : RendererData::create()}; \
return renderer; \
} \
} \
void CLASS::set##NAME(std::shared_ptr<RendererData> renderer) \

2
include/TGUI/Renderers/EditBoxRenderer.hpp
View File

@ -64,7 +64,7 @@ namespace tgui
/// @param style The new default text style
///
/// @code
/// editBox->getRenderer()->setDefaultTextStyle(sf::Text::Italic | sf::Text::Bold);
/// editBox->getSharedRenderer()->setDefaultTextStyle(sf::Text::Italic | sf::Text::Bold);
/// @endcode
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

9
include/TGUI/Renderers/WidgetRenderer.hpp
View File

@ -49,7 +49,8 @@ namespace tgui
}
std::map<std::string, ObjectConverter> propertyValuePairs;
std::map<void*, std::function<void(const std::string& property)>> observers;
std::map<const void*, std::function<void(const std::string& property)>> observers;
bool shared = true;
};
@ -82,7 +83,7 @@ namespace tgui
/// @brief Virtual destructor
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual ~WidgetRenderer() {};
virtual ~WidgetRenderer() = default;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -164,7 +165,7 @@ namespace tgui
/// @param function Callback function to call when the renderer changes
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void subscribe(void* id, const std::function<void(const std::string& property)>& function);
void subscribe(const void* id, const std::function<void(const std::string& property)>& function);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -173,7 +174,7 @@ namespace tgui
/// @param id Unique identifier used when subscribing the callback function
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void unsubscribe(void* id);
void unsubscribe(const void* id);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

12
include/TGUI/Texture.hpp
View File

@ -275,6 +275,18 @@ namespace tgui
void setDestructCallback(const CallbackFunc& func);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the texture with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator==(const Texture& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Compares the texture with another one
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool operator!=(const Texture& right) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets a different image loader
///

59
include/TGUI/Widget.hpp
View File

@ -32,6 +32,7 @@
#include <TGUI/Signal.hpp>
#include <TGUI/Sprite.hpp>
#include <TGUI/Layout.hpp>
#include <TGUI/Loading/Theme.hpp>
#include <TGUI/Renderers/WidgetRenderer.hpp>
#include <TGUI/Aurora/SmartPtr/CopiedPtr.hpp>
#include <TGUI/Aurora/Tools/Downcast.hpp>
@ -101,16 +102,26 @@ namespace tgui
/// @brief Sets a new renderer for the widget. The renderer determines how the widget looks
///
/// @param rendererData new renderer data
///
/// The renderer data is shared with this widget. When the data is changed, this widget will be updated as well.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setRenderer(const std::shared_ptr<RendererData>& rendererData);
void setRenderer(std::shared_ptr<RendererData> rendererData);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WidgetRenderer* getRenderer() const;
WidgetRenderer* getSharedRenderer();
const WidgetRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WidgetRenderer* getRenderer();
const WidgetRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -403,6 +414,38 @@ namespace tgui
virtual void moveToBack();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets the font of the widget that is used when no font is set in the renderer
///
/// @param font New font for the widget
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setInheritedFont(const Font& font);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the font of the widget that is used when no font is set in the renderer
///
/// @return Font of the widget
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const Font& getInheritedFont() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets the opacity of the widget that will be multiplied with the opacity set in the renderer
///
/// @param opacity Opacity of the widget
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setInheritedOpacity(float opacity);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the opacity of the widget that is multiplied with the opacity set in the renderer
///
/// @return Opacity of the widget
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float getInheritedOpacity() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets the tool tip that should be displayed when hovering over the widget
///
@ -709,9 +752,15 @@ namespace tgui
// Show animations
std::vector<std::shared_ptr<priv::Animation>> m_showAnimations;
// Renderer properties that can be passed from containers to their children
Font m_inheritedFont;
float m_inheritedOpacity = 1;
// Cached renderer properties
Font m_fontCached;
float m_opacityCached;
float m_opacityCached = 1;
std::function<void(const std::string& property)> m_rendererChangedCallback = [this](const std::string& property){ rendererChangedCallback(property); };
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/BoxLayout.hpp
View File

@ -53,14 +53,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BoxLayoutRenderer* getRenderer() const
{
return aurora::downcast<BoxLayoutRenderer*>(m_renderer.get());
}
BoxLayoutRenderer* getSharedRenderer();
const BoxLayoutRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BoxLayoutRenderer* getRenderer();
const BoxLayoutRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Button.hpp
View File

@ -76,14 +76,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ButtonRenderer* getRenderer() const
{
return aurora::downcast<ButtonRenderer*>(m_renderer.get());
}
ButtonRenderer* getSharedRenderer();
const ButtonRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ButtonRenderer* getRenderer();
const ButtonRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

20
include/TGUI/Widgets/ChatBox.hpp
View File

@ -86,14 +86,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChatBoxRenderer* getRenderer() const
{
return aurora::downcast<ChatBoxRenderer*>(m_renderer.get());
}
ChatBoxRenderer* getSharedRenderer();
const ChatBoxRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChatBoxRenderer* getRenderer();
const ChatBoxRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -218,7 +222,7 @@ namespace tgui
/// @param lineIndex The index of the line of which you request the font. The first line has index 0
///
/// @return The font of the requested line.
/// When the index is too high then the default font (set with chatBox->getRenderer()->setFont(font)) is returned.
/// When the index is too high then the default font is returned.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<sf::Font> getLineFont(std::size_t lineIndex) const;

12
include/TGUI/Widgets/CheckBox.hpp
View File

@ -72,18 +72,6 @@ namespace tgui
static CheckBox::Ptr copy(CheckBox::ConstPtr checkbox);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RadioButtonRenderer* getRenderer() const
{
return aurora::downcast<RadioButtonRenderer*>(m_renderer.get());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the full size of the radio button
///

18
include/TGUI/Widgets/ChildWindow.hpp
View File

@ -93,14 +93,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChildWindowRenderer* getRenderer() const
{
return aurora::downcast<ChildWindowRenderer*>(m_renderer.get());
}
ChildWindowRenderer* getSharedRenderer();
const ChildWindowRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChildWindowRenderer* getRenderer();
const ChildWindowRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/ComboBox.hpp
View File

@ -93,14 +93,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ComboBoxRenderer* getRenderer() const
{
return aurora::downcast<ComboBoxRenderer*>(m_renderer.get());
}
ComboBoxRenderer* getSharedRenderer();
const ComboBoxRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ComboBoxRenderer* getRenderer();
const ComboBoxRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/EditBox.hpp
View File

@ -106,14 +106,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EditBoxRenderer* getRenderer() const
{
return aurora::downcast<EditBoxRenderer*>(m_renderer.get());
}
EditBoxRenderer* getSharedRenderer();
const EditBoxRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EditBoxRenderer* getRenderer();
const EditBoxRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Group.hpp
View File

@ -81,14 +81,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GroupRenderer* getRenderer() const
{
return aurora::downcast<GroupRenderer*>(m_renderer.get());
}
GroupRenderer* getSharedRenderer();
const GroupRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GroupRenderer* getRenderer();
const GroupRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Knob.hpp
View File

@ -73,14 +73,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
KnobRenderer* getRenderer() const
{
return aurora::downcast<KnobRenderer*>(m_renderer.get());
}
KnobRenderer* getSharedRenderer();
const KnobRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
KnobRenderer* getRenderer();
const KnobRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Label.hpp
View File

@ -98,14 +98,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LabelRenderer* getRenderer() const
{
return aurora::downcast<LabelRenderer*>(m_renderer.get());
}
LabelRenderer* getSharedRenderer();
const LabelRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LabelRenderer* getRenderer();
const LabelRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/ListBox.hpp
View File

@ -74,14 +74,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ListBoxRenderer* getRenderer() const
{
return aurora::downcast<ListBoxRenderer*>(m_renderer.get());
}
ListBoxRenderer* getSharedRenderer();
const ListBoxRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ListBoxRenderer* getRenderer();
const ListBoxRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/MenuBar.hpp
View File

@ -74,14 +74,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MenuBarRenderer* getRenderer() const
{
return aurora::downcast<MenuBarRenderer*>(m_renderer.get());
}
MenuBarRenderer* getSharedRenderer();
const MenuBarRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MenuBarRenderer* getRenderer();
const MenuBarRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/MessageBox.hpp
View File

@ -102,14 +102,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MessageBoxRenderer* getRenderer() const
{
return aurora::downcast<MessageBoxRenderer*>(m_renderer.get());
}
MessageBoxRenderer* getSharedRenderer();
const MessageBoxRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MessageBoxRenderer* getRenderer();
const MessageBoxRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Panel.hpp
View File

@ -78,14 +78,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PanelRenderer* getRenderer() const
{
return aurora::downcast<PanelRenderer*>(m_renderer.get());
}
PanelRenderer* getSharedRenderer();
const PanelRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PanelRenderer* getRenderer();
const PanelRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Picture.hpp
View File

@ -108,14 +108,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PictureRenderer* getRenderer() const
{
return aurora::downcast<PictureRenderer*>(m_renderer.get());
}
PictureRenderer* getSharedRenderer();
const PictureRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PictureRenderer* getRenderer();
const PictureRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/ProgressBar.hpp
View File

@ -89,14 +89,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ProgressBarRenderer* getRenderer() const
{
return aurora::downcast<ProgressBarRenderer*>(m_renderer.get());
}
ProgressBarRenderer* getSharedRenderer();
const ProgressBarRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ProgressBarRenderer* getRenderer();
const ProgressBarRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/RadioButton.hpp
View File

@ -74,14 +74,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RadioButtonRenderer* getRenderer() const
{
return aurora::downcast<RadioButtonRenderer*>(m_renderer.get());
}
RadioButtonRenderer* getSharedRenderer();
const RadioButtonRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RadioButtonRenderer* getRenderer();
const RadioButtonRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/RangeSlider.hpp
View File

@ -76,14 +76,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RangeSliderRenderer* getRenderer() const
{
return aurora::downcast<RangeSliderRenderer*>(m_renderer.get());
}
RangeSliderRenderer* getSharedRenderer();
const RangeSliderRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RangeSliderRenderer* getRenderer();
const RangeSliderRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/ScrollablePanel.hpp
View File

@ -81,14 +81,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollablePanelRenderer* getRenderer() const
{
return aurora::downcast<ScrollablePanelRenderer*>(m_renderer.get());
}
ScrollablePanelRenderer* getSharedRenderer();
const ScrollablePanelRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollablePanelRenderer* getRenderer();
const ScrollablePanelRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Scrollbar.hpp
View File

@ -73,14 +73,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollbarRenderer* getRenderer() const
{
return aurora::downcast<ScrollbarRenderer*>(m_renderer.get());
}
ScrollbarRenderer* getSharedRenderer();
const ScrollbarRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollbarRenderer* getRenderer();
const ScrollbarRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Slider.hpp
View File

@ -76,14 +76,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SliderRenderer* getRenderer() const
{
return aurora::downcast<SliderRenderer*>(m_renderer.get());
}
SliderRenderer* getSharedRenderer();
const SliderRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SliderRenderer* getRenderer();
const SliderRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/SpinButton.hpp
View File

@ -76,14 +76,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SpinButtonRenderer* getRenderer() const
{
return aurora::downcast<SpinButtonRenderer*>(m_renderer.get());
}
SpinButtonRenderer* getSharedRenderer();
const SpinButtonRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SpinButtonRenderer* getRenderer();
const SpinButtonRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/Tabs.hpp
View File

@ -74,14 +74,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TabsRenderer* getRenderer() const
{
return aurora::downcast<TabsRenderer*>(m_renderer.get());
}
TabsRenderer* getSharedRenderer();
const TabsRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TabsRenderer* getRenderer();
const TabsRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
include/TGUI/Widgets/TextBox.hpp
View File

@ -78,14 +78,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Temporary pointer to the renderer
///
/// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TextBoxRenderer* getRenderer() const
{
return aurora::downcast<TextBoxRenderer*>(m_renderer.get());
}
TextBoxRenderer* getSharedRenderer();
const TextBoxRenderer* getSharedRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
/// @return Temporary pointer to the renderer
/// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TextBoxRenderer* getRenderer();
const TextBoxRenderer* getRenderer() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

4
src/TGUI/Animation.cpp
View File

@ -139,7 +139,7 @@ namespace tgui
return true;
}
m_widget->getRenderer()->setOpacity(m_startOpacity + ((m_elapsedTime.asSeconds() / m_totalDuration.asSeconds()) * (m_endOpacity - m_startOpacity)));
m_widget->setInheritedOpacity(m_startOpacity + ((m_elapsedTime.asSeconds() / m_totalDuration.asSeconds()) * (m_endOpacity - m_startOpacity)));
return false;
}
@ -147,7 +147,7 @@ namespace tgui
void FadeAnimation::finish()
{
m_widget->getRenderer()->setOpacity(m_endOpacity);
m_widget->setInheritedOpacity(m_endOpacity);
Animation::finish();
}

51
src/TGUI/Color.cpp
View File

@ -32,29 +32,6 @@ namespace tgui
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color::Color() :
m_isSet{false}
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color::Color(const sf::Color& color) :
m_isSet{true},
m_color{color}
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color::Color(sf::Uint8 red, sf::Uint8 green, sf::Uint8 blue, sf::Uint8 alpha) :
m_isSet{true},
m_color{red, green, blue, alpha}
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color::Color(const std::string& string) :
m_isSet{true},
m_color(Deserializer::deserialize(tgui::ObjectConverter::Type::Color, string).getColor()) // Did not compile with clang 3.6 when using braces
@ -111,6 +88,34 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Color::operator==(const Color& right) const
{
return (m_isSet == right.m_isSet) && (m_color == right.m_color);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Color::operator!=(const Color& right) const
{
return !(*this == right);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Color::operator==(const sf::Color& right) const
{
return m_isSet && (m_color == right);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Color::operator!=(const sf::Color& right) const
{
return !(*this == right);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

19
src/TGUI/Container.cpp
View File

@ -138,16 +138,15 @@ namespace tgui
{
assert(widgetPtr != nullptr);
// Let the widget inherit our font if it did not had a font yet
if (!widgetPtr->getRenderer()->getFont() && m_fontCached)
widgetPtr->getRenderer()->setFont(m_fontCached);
widgetPtr->setParent(this);
m_widgets.push_back(widgetPtr);
m_widgetNames.push_back(widgetName);
if (m_fontCached)
widgetPtr->setInheritedFont(m_fontCached);
if (m_opacityCached < 1)
widgetPtr->getRenderer()->setOpacity(m_opacityCached);
widgetPtr->setInheritedOpacity(m_opacityCached);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -677,16 +676,12 @@ namespace tgui
if (property == "opacity")
{
for (std::size_t i = 0; i < m_widgets.size(); ++i)
m_widgets[i]->getRenderer()->setOpacity(m_opacityCached);
m_widgets[i]->setInheritedOpacity(m_opacityCached);
}
else if (property == "font")
{
// Update the font of child widgets when a font was set (but let them keep their font if the container font was removed)
if (m_fontCached != nullptr)
{
for (const auto& widget : m_widgets)
widget->getRenderer()->setFont(m_fontCached);
}
for (const auto& widget : m_widgets)
widget->setInheritedFont(m_fontCached);
}
}

14
src/TGUI/Font.cpp
View File

@ -111,6 +111,20 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Font::operator==(const Font& right) const
{
return m_font == right.m_font;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Font::operator!=(const Font& right) const
{
return m_font != right.m_font;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const sf::Glyph& Font::getGlyph(sf::Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness) const
{
assert(m_font != nullptr);

8
src/TGUI/Gui.cpp
View File

@ -306,14 +306,14 @@ namespace tgui
void Gui::setFont(const Font& font)
{
m_container->getRenderer()->setFont(font);
m_container->setInheritedFont(font);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<sf::Font> Gui::getFont() const
{
return m_container->getRenderer()->getFont();
return m_container->getInheritedFont();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -411,14 +411,14 @@ namespace tgui
void Gui::setOpacity(float opacity)
{
m_container->getRenderer()->setOpacity(opacity);
m_container->setInheritedOpacity(opacity);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float Gui::getOpacity() const
{
return m_container->getRenderer()->getOpacity();
return m_container->getInheritedOpacity();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

262
src/TGUI/Loading/Theme.cpp
View File

@ -31,8 +31,191 @@
namespace tgui
{
namespace
{
struct DefaultTheme : public Theme
{
DefaultTheme()
{
m_renderers = {
{"button", RendererData::create({{"borders", Borders{2}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"bordercolordown", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"textcolordown", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"backgroundcolordown", sf::Color::White}})}, ///TODO: Define default disabled colors
{"chatbox", RendererData::create({{"borders", Borders{2}},
{"padding", Padding{2, 0, 0, 0}},
{"bordercolor", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}}})},
{"checkbox", RendererData::create({{"borders", Borders{3}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"checkcolor", Color{60, 60, 60}},
{"checkcolorhover", sf::Color::Black},
{"textdistanceratio", 0.2f}})}, ///TODO: Define default disabled colors
{"childwindow", RendererData::create({{"borders", Borders{1}},
{"bordercolor", sf::Color::Black},
{"titlecolor", sf::Color::Black},
{"titlebarcolor", sf::Color::White},
{"backgroundcolor", Color{230, 230, 230}},
{"distancetoside", 3.f},
{"paddingbetweenbuttons", 1.f}})},
{"childwindowbutton", RendererData::create({{"borders", Borders{1}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"bordercolordown", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"textcolordown", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"backgroundcolordown", sf::Color::White}})},
{"combobox", RendererData::create({{"borders", Borders{2}},
{"padding", Padding{0}},
{"bordercolor", sf::Color::Black},
{"textcolor", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"arrowcolor", Color{60, 60, 60}},
{"arrowcolorhover", sf::Color::Black},
{"arrowbackgroundcolor", Color{245, 245, 245}},
{"arrowbackgroundcolorhover", sf::Color::White}})},
{"editbox", RendererData::create({{"borders", Borders{2}},
{"padding", Padding{4, 2, 4, 2}},
{"caretwidth", 1.f},
{"caretcolor", sf::Color::Black},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"selectedtextcolor", sf::Color::White},
{"selectedtextbackgroundcolor", Color{0, 110, 255}},
{"defaulttextcolor", Color{160, 160, 160}},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White}})}, ///TODO: Define default disabled colors
{"group", RendererData::create()},
{"horizontallayout", RendererData::create()},
{"horizontalwrap", RendererData::create()},
{"knob", RendererData::create({{"borders", Borders{5}},
{"imagerotation", 0.f},
{"bordercolor", sf::Color::Black},
{"thumbcolor", sf::Color::Black},
{"backgroundcolor", sf::Color::White}})},
{"label", RendererData::create({{"borders", Borders{}},
{"bordercolor", Color{60, 60, 60}},
{"textcolor", Color{60, 60, 60}},
{"backgroundcolor", sf::Color::Transparent}})},
{"listbox", RendererData::create({{"borders", Borders{2}},
{"padding", Padding{0}},
{"bordercolor", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"selectedbackgroundcolor", Color{0, 110, 255}},
{"selectedbackgroundcolorhover", Color{30, 150, 255}}})},
{"menubar", RendererData::create({{"textcolor", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"backgroundcolor", sf::Color::White},
{"selectedbackgroundcolor", Color{0, 110, 255}},
{"distancetoside", 4.f}})},
{"messagebox", RendererData::create({{"borders", Borders{1}},
{"bordercolor", sf::Color::Black},
{"titlecolor", sf::Color::Black},
{"titlebarcolor", sf::Color::White},
{"backgroundcolor", Color{230, 230, 230}},
{"distancetoside", 3.f},
{"paddingbetweenbuttons", 1.f},
{"textcolor", sf::Color::Black}})},
{"panel", RendererData::create({{"bordercolor", sf::Color::Black},
{"backgroundcolor", sf::Color::Transparent}})},
{"picture", RendererData::create()},
{"progressbar", RendererData::create({{"borders", Borders{2}},
{"bordercolor", sf::Color::Black},
{"textcolor", sf::Color::Black},
{"textcolorfilled", sf::Color::White},
{"backgroundcolor", Color{245, 245, 245}},
{"fillcolor", Color{0, 110, 255}}})},
{"radiobutton", RendererData::create({{"borders", Borders{3}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"checkcolor", Color{60, 60, 60}},
{"checkcolorhover", sf::Color::Black},
{"textdistanceratio", 0.2f}})}, ///TODO: Define default disabled colors
{"rangeslider", RendererData::create({{"borders", Borders{2}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"trackcolor", Color{245, 245, 245}},
{"trackcolorhover", Color{255, 255, 255}},
{"thumbcolor", Color{245, 245, 245}},
{"thumbcolorhover", Color{255, 255, 255}}})},
{"scrollablepanel", RendererData::create({{"bordercolor", sf::Color::Black},
{"backgroundcolor", sf::Color::Transparent}})},
{"scrollbar", RendererData::create({{"trackcolor", Color{245, 245, 245}},
{"thumbcolor", Color{220, 220, 220}},
{"thumbcolorhover", Color{230, 230, 230}},
{"arrowbackgroundcolor", Color{245, 245, 245}},
{"arrowbackgroundcolorhover", Color{255, 255, 255}},
{"arrowcolor", Color{60, 60, 60}},
{"arrowcolorhover", Color{0, 0, 0}}})},
{"slider", RendererData::create({{"borders", Borders{2}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"trackcolor", Color{245, 245, 245}},
{"trackcolorhover", Color{255, 255, 255}},
{"thumbcolor", Color{245, 245, 245}},
{"thumbcolorhover", Color{255, 255, 255}}})},
{"spinbutton", RendererData::create({{"borders", Borders{2}},
{"bordercolor", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"arrowcolor", Color{60, 60, 60}},
{"arrowcolorhover", sf::Color::Black},
{"spacebetweenarrows", 2.f}})},
{"tabs", RendererData::create({{"borders", Borders{2}},
{"bordercolor", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"selectedbackgroundcolor", Color{0, 110, 255}},
{"selectedbackgroundcolorhover", Color{30, 150, 255}},
{"distancetoside", 1.f}})},
{"textbox", RendererData::create({{"borders", Borders{2}},
{"padding", Padding{2, 0, 0, 0}},
{"caretwidth", 1.f},
{"caretcolor", sf::Color::Black},
{"bordercolor", sf::Color::Black},
{"textcolor", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"selectedtextbackgroundcolor", Color{0, 110, 255}},
{"backgroundcolor", sf::Color::White}})},
{"verticallayout", RendererData::create({})}
};
}
};
DefaultTheme defaultTheme;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Theme* Theme::m_defaultTheme = &defaultTheme;
std::shared_ptr<BaseThemeLoader> Theme::m_themeLoader = std::make_shared<DefaultThemeLoader>();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -46,6 +229,14 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Theme::~Theme()
{
if (m_defaultTheme == this)
setDefault(nullptr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Theme::load(const std::string& primary)
{
m_primary = primary;
@ -55,38 +246,18 @@ namespace tgui
for (auto& pair : m_renderers)
{
auto& renderer = pair.second;
auto oldData = renderer;
const auto oldData = renderer;
/// TODO: Exceptions should not be used for such situations!
/// Add a function to ThemeLoader that lists which sections exist.
// Try to load the new renderer
const std::map<sf::String, sf::String>* properties;
try
{
properties = &m_themeLoader->load(m_primary, pair.first);
}
catch (const Exception&)
{
// Exceptions are ignored. When a renderer was loaded from the old theme but is no longer found
// in the new theme then just ignore it and keep the old renderer.
if (!m_themeLoader->canLoad(m_primary, pair.first))
continue;
}
// Keep track of the old font
Font oldFont;
if (renderer->propertyValuePairs.find("font") != pair.second->propertyValuePairs.end())
oldFont = renderer->propertyValuePairs["font"].getFont();
auto& properties = m_themeLoader->load(m_primary, pair.first);
// Update the property-value pairs of the renderer
renderer->propertyValuePairs = std::map<std::string, ObjectConverter>{};
for (const auto& property : *properties)
for (const auto& property : properties)
renderer->propertyValuePairs[property.first] = ObjectConverter(property.second);
// If there used to be a font but no new font was set then keep the old font
if ((properties->find("font") == properties->end()) && (oldFont != nullptr))
renderer->propertyValuePairs["font"] = ObjectConverter(oldFont);
// Tell the widgets that were using this renderer about all the updated properties, both new ones and old ones that were now reset to their default value
auto oldIt = oldData->propertyValuePairs.begin();
auto newIt = renderer->propertyValuePairs.begin();
@ -153,6 +324,29 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<RendererData> Theme::getRendererNoThrow(const std::string& id)
{
std::string lowercaseSecondary = toLower(id);
// If we already have this renderer in cache then just return it
auto it = m_renderers.find(lowercaseSecondary);
if (it != m_renderers.end())
return it->second;
m_renderers[lowercaseSecondary] = RendererData::create();
if (!m_themeLoader->canLoad(m_primary, lowercaseSecondary))
return nullptr;
auto& properties = m_themeLoader->load(m_primary, lowercaseSecondary);
for (const auto& property : properties)
m_renderers[lowercaseSecondary]->propertyValuePairs[property.first] = ObjectConverter(property.second);
return m_renderers[lowercaseSecondary];
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Theme::addRenderer(const std::string& id, std::shared_ptr<RendererData> renderer)
{
m_renderers[id] = renderer;
@ -187,6 +381,26 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Theme::setDefault(Theme* theme)
{
if (theme)
m_defaultTheme = theme;
else
{
defaultTheme = {};
m_defaultTheme = &defaultTheme;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Theme* Theme::getDefault()
{
return m_defaultTheme;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

14
src/TGUI/Loading/ThemeLoader.cpp
View File

@ -245,10 +245,10 @@ namespace tgui
{
preload(filename);
std::string lowercaseClassName = toLower(section);
const std::string lowercaseClassName = toLower(section);
// An empty filename is not considered an error and will result in an empty property list
if (filename == "")
if (filename.empty())
return m_propertiesCache[""][lowercaseClassName];
if (m_propertiesCache[filename].find(lowercaseClassName) == m_propertiesCache[filename].end())
@ -259,6 +259,16 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool DefaultThemeLoader::canLoad(const std::string& filename, const std::string& section)
{
if (filename.empty())
return true;
else
return m_propertiesCache[filename].find(toLower(section)) != m_propertiesCache[filename].end();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void DefaultThemeLoader::readFile(const std::string& filename, std::stringstream& contents) const
{
if (filename.empty())

1
src/TGUI/Loading/WidgetLoader.cpp
View File

@ -180,6 +180,7 @@ namespace tgui
else if (toLower(childNode->name) == "renderer")
{
auto rendererData = RendererData::create();
rendererData->shared = false;
for (const auto& pair : childNode->propertyValuePairs)
rendererData->propertyValuePairs[pair.first] = {pair.second->value};

4
src/TGUI/Loading/WidgetSaver.cpp
View File

@ -166,11 +166,11 @@ namespace tgui
}
/// TODO: Separate renderer section?
if (!widget->getRenderer()->getPropertyValuePairs().empty())
if (!widget->getSharedRenderer()->getPropertyValuePairs().empty())
{
node->children.emplace_back(make_unique<DataIO::Node>());
node->children.back()->name = "Renderer";
for (const auto& pair : widget->getRenderer()->getPropertyValuePairs())
for (const auto& pair : widget->getSharedRenderer()->getPropertyValuePairs())
{
// Skip "font = null"
if (pair.first == "font" && ObjectConverter{pair.second}.getString() == "null")

63
src/TGUI/ObjectConverter.cpp
View File

@ -214,6 +214,69 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ObjectConverter::operator==(const ObjectConverter& right) const
{
if (this == &right)
return true;
if (m_type != right.m_type)
return false;
switch (m_type)
{
case Type::None:
return true;
case Type::String:
return m_string == right.m_string;
#ifdef TGUI_USE_VARIANT
case Type::Bool:
return std::get<bool>(m_value) == std::get<bool>(right.m_value);
case Type::Font:
return std::get<Font>(m_value) == std::get<Font>(right.m_value);
case Type::Color:
return std::get<Color>(m_value) == std::get<Color>(right.m_value);
case Type::Number:
return std::get<float>(m_value) == std::get<float>(right.m_value);
case Type::Outline:
return std::get<Outline>(m_value) == std::get<Outline>(right.m_value);
case Type::Texture:
return std::get<Texture>(m_value) == std::get<Texture>(right.m_value);
case Type::TextStyle:
return std::get<TextStyle>(m_value) == std::get<TextStyle>(right.m_value);
case Type::RendererData:
return std::get<std::shared_ptr<RendererData>>(m_value) == std::get<std::shared_ptr<RendererData>>(right.m_value);
#else
case Type::Bool:
return m_value.as<bool>() == right.m_value.as<bool>();
case Type::Font:
return m_value.as<Font>() == right.m_value.as<Font>();
case Type::Color:
return m_value.as<Color>() == right.m_value.as<Color>();
case Type::Number:
return m_value.as<float>() == right.m_value.as<float>();
case Type::Outline:
return m_value.as<Outline>() == right.m_value.as<Outline>();
case Type::Texture:
return m_value.as<Texture>() == right.m_value.as<Texture>();
case Type::TextStyle:
return m_value.as<TextStyle>() == right.m_value.as<TextStyle>();
case Type::RendererData:
return m_value.as<std::shared_ptr<RendererData>>() == right.m_value.as<std::shared_ptr<RendererData>>();
#endif
default: // This case should never occur, but prevents a warning that control reaches end of non-void function
return false;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ObjectConverter::operator!=(const ObjectConverter& right) const
{
return !(*this == right);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/TGUI/Renderers/ChatBoxRenderer.cpp
View File

@ -38,7 +38,7 @@ namespace tgui
TGUI_RENDERER_PROPERTY_TEXTURE(ChatBoxRenderer, TextureBackground)
TGUI_RENDERER_PROPERTY_RENDERER(ChatBoxRenderer, Scrollbar)
TGUI_RENDERER_PROPERTY_RENDERER(ChatBoxRenderer, Scrollbar, "scrollbar")
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

6
src/TGUI/Renderers/ChildWindowRenderer.cpp
View File

@ -39,9 +39,9 @@ namespace tgui
TGUI_RENDERER_PROPERTY_TEXTURE(ChildWindowRenderer, TextureTitleBar)
TGUI_RENDERER_PROPERTY_RENDERER(ChildWindowRenderer, CloseButton)
TGUI_RENDERER_PROPERTY_RENDERER(ChildWindowRenderer, MaximizeButton)
TGUI_RENDERER_PROPERTY_RENDERER(ChildWindowRenderer, MinimizeButton)
TGUI_RENDERER_PROPERTY_RENDERER(ChildWindowRenderer, CloseButton, "childwindowbutton")
TGUI_RENDERER_PROPERTY_RENDERER(ChildWindowRenderer, MaximizeButton, "childwindowbutton")
TGUI_RENDERER_PROPERTY_RENDERER(ChildWindowRenderer, MinimizeButton, "childwindowbutton")
TGUI_RENDERER_PROPERTY_NUMBER(ChildWindowRenderer, DistanceToSide, 3)
TGUI_RENDERER_PROPERTY_NUMBER(ChildWindowRenderer, PaddingBetweenButtons, 1)

2
src/TGUI/Renderers/ComboBoxRenderer.cpp
View File

@ -49,7 +49,7 @@ namespace tgui
TGUI_RENDERER_PROPERTY_TEXT_STYLE(ComboBoxRenderer, TextStyle, sf::Text::Regular)
TGUI_RENDERER_PROPERTY_RENDERER(ComboBoxRenderer, ListBox)
TGUI_RENDERER_PROPERTY_RENDERER(ComboBoxRenderer, ListBox, "listbox")
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/TGUI/Renderers/ListBoxRenderer.cpp
View File

@ -48,7 +48,7 @@ namespace tgui
TGUI_RENDERER_PROPERTY_TEXT_STYLE(ListBoxRenderer, TextStyle, sf::Text::Regular)
TGUI_RENDERER_PROPERTY_TEXT_STYLE(ListBoxRenderer, SelectedTextStyle, {})
TGUI_RENDERER_PROPERTY_RENDERER(ListBoxRenderer, Scrollbar)
TGUI_RENDERER_PROPERTY_RENDERER(ListBoxRenderer, Scrollbar, "scrollbar")
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/TGUI/Renderers/MessageBoxRenderer.cpp
View File

@ -32,7 +32,7 @@ namespace tgui
{
TGUI_RENDERER_PROPERTY_COLOR(MessageBoxRenderer, TextColor, sf::Color::Black)
TGUI_RENDERER_PROPERTY_RENDERER(MessageBoxRenderer, Button)
TGUI_RENDERER_PROPERTY_RENDERER(MessageBoxRenderer, Button, "button")
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/TGUI/Renderers/ScrollablePanelRenderer.cpp
View File

@ -30,7 +30,7 @@
namespace tgui
{
TGUI_RENDERER_PROPERTY_RENDERER(ScrollablePanelRenderer, Scrollbar)
TGUI_RENDERER_PROPERTY_RENDERER(ScrollablePanelRenderer, Scrollbar, "scrollbar")
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/TGUI/Renderers/TextBoxRenderer.cpp
View File

@ -44,7 +44,7 @@ namespace tgui
TGUI_RENDERER_PROPERTY_NUMBER(TextBoxRenderer, CaretWidth, 1)
TGUI_RENDERER_PROPERTY_RENDERER(TextBoxRenderer, Scrollbar)
TGUI_RENDERER_PROPERTY_RENDERER(TextBoxRenderer, Scrollbar, "scrollbar")
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

17
src/TGUI/Renderers/WidgetRenderer.cpp
View File

@ -68,10 +68,13 @@ namespace tgui
{
std::string lowercaseProperty = toLower(property);
m_data->propertyValuePairs[lowercaseProperty] = value;
if (m_data->propertyValuePairs[lowercaseProperty] != value)
{
m_data->propertyValuePairs[lowercaseProperty] = value;
for (const auto& observer : m_data->observers)
observer.second(lowercaseProperty);
for (const auto& observer : m_data->observers)
observer.second(lowercaseProperty);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -94,14 +97,14 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void WidgetRenderer::subscribe(void* id, const std::function<void(const std::string& property)>& function)
void WidgetRenderer::subscribe(const void* id, const std::function<void(const std::string& property)>& function)
{
m_data->observers[id] = function;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void WidgetRenderer::unsubscribe(void* id)
void WidgetRenderer::unsubscribe(const void* id)
{
m_data->observers.erase(id);
}
@ -124,7 +127,9 @@ namespace tgui
std::shared_ptr<RendererData> WidgetRenderer::clone() const
{
return std::make_shared<RendererData>(*m_data);
auto data = std::make_shared<RendererData>(*m_data);
data->observers = {};
return data;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

14
src/TGUI/Texture.cpp
View File

@ -269,6 +269,20 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Texture::operator==(const Texture& right) const
{
return (m_data == right.m_data) && (m_middleRect == right.m_middleRect) && (m_id == right.m_id);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Texture::operator!=(const Texture& right) const
{
return !(*this == right);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Texture::setImageLoader(const ImageLoaderFunc& func)
{
assert(func != nullptr);

117
src/TGUI/Widget.cpp
View File

@ -62,10 +62,7 @@ namespace tgui
Widget::Widget()
{
m_renderer->subscribe(this, [this](const std::string& property){ rendererChangedCallback(property); });
// The opacity is 1 by default and thus has to be explicitly initialized
m_opacityCached = getRenderer()->getOpacity();
m_renderer->subscribe(this, m_rendererChangedCallback);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -110,7 +107,7 @@ namespace tgui
m_size.x.connectWidget(this, true, [this]{ setSize(getSizeLayout()); });
m_size.y.connectWidget(this, false, [this]{ setSize(getSizeLayout()); });
m_renderer->subscribe(this, [this](const std::string& property){ rendererChangedCallback(property); });
m_renderer->subscribe(this, m_rendererChangedCallback);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -151,7 +148,7 @@ namespace tgui
m_size.y.connectWidget(this, false, [this]{ setSize(getSizeLayout()); });
other.m_renderer->unsubscribe(&other);
m_renderer->subscribe(this, [this](const std::string& property){ rendererChangedCallback(property); });
m_renderer->subscribe(this, m_rendererChangedCallback);
other.m_renderer = nullptr;
}
@ -200,7 +197,7 @@ namespace tgui
m_size.x.connectWidget(this, true, [this]{ setSize(getSizeLayout()); });
m_size.y.connectWidget(this, false, [this]{ setSize(getSizeLayout()); });
m_renderer->subscribe(this, [this](const std::string& property){ rendererChangedCallback(property); });
m_renderer->subscribe(this, m_rendererChangedCallback);
}
return *this;
@ -250,7 +247,7 @@ namespace tgui
m_size.x.connectWidget(this, true, [this]{ setSize(getSizeLayout()); });
m_size.y.connectWidget(this, false, [this]{ setSize(getSizeLayout()); });
m_renderer->subscribe(this, [this](const std::string& property){ rendererChangedCallback(property); });
m_renderer->subscribe(this, m_rendererChangedCallback);
other.m_renderer = nullptr;
}
@ -260,18 +257,18 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Widget::setRenderer(const std::shared_ptr<RendererData>& rendererData)
void Widget::setRenderer(std::shared_ptr<RendererData> rendererData)
{
std::shared_ptr<RendererData> oldData = m_renderer->getData();
if (rendererData == nullptr)
rendererData = RendererData::create();
// If no font is given then try to use the one from the parent
if (m_parent && m_parent->getRenderer()->getFont() && (rendererData->propertyValuePairs.find("font") == rendererData->propertyValuePairs.end()))
rendererData->propertyValuePairs["font"] = ObjectConverter(m_parent->getRenderer()->getFont());
std::shared_ptr<RendererData> oldData = m_renderer->getData();
// Update the data
m_renderer->unsubscribe(this);
m_renderer->setData(rendererData);
m_renderer->subscribe(this, [this](const std::string& property){ rendererChangedCallback(property); });
m_renderer->subscribe(this, m_rendererChangedCallback);
rendererData->shared = true;
// Tell the widget about all the updated properties, both new ones and old ones that were now reset to their default value
auto oldIt = oldData->propertyValuePairs.begin();
@ -312,8 +309,47 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WidgetRenderer* Widget::getRenderer() const
const WidgetRenderer* Widget::getSharedRenderer() const
{
// You should not be allowed to call setters on the renderer when the widget is const
return m_renderer.get();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WidgetRenderer* Widget::getSharedRenderer()
{
return m_renderer.get();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const WidgetRenderer* Widget::getRenderer() const
{
if (m_renderer->getData()->shared)
{
m_renderer->unsubscribe(this);
m_renderer->setData(m_renderer->clone());
m_renderer->subscribe(this, m_rendererChangedCallback);
m_renderer->getData()->shared = false;
}
// You should not be allowed to call setters on the renderer when the widget is const
return m_renderer.get();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WidgetRenderer* Widget::getRenderer()
{
if (m_renderer->getData()->shared)
{
m_renderer->unsubscribe(this);
m_renderer->setData(m_renderer->clone());
m_renderer->subscribe(this, m_rendererChangedCallback);
m_renderer->getData()->shared = false;
}
return m_renderer.get();
}
@ -394,8 +430,8 @@ namespace tgui
{
case ShowAnimationType::Fade:
{
addAnimation(m_showAnimations, std::make_shared<priv::FadeAnimation>(shared_from_this(), 0.f, m_opacityCached, duration));
getRenderer()->setOpacity(0);
addAnimation(m_showAnimations, std::make_shared<priv::FadeAnimation>(shared_from_this(), 0.f, getInheritedOpacity(), duration));
setInheritedOpacity(0);
break;
}
case ShowAnimationType::Scale:
@ -466,8 +502,8 @@ namespace tgui
{
case ShowAnimationType::Fade:
{
float opacity = m_opacityCached;
addAnimation(m_showAnimations, std::make_shared<priv::FadeAnimation>(shared_from_this(), m_opacityCached, 0.f, duration, [=](){ hide(); getRenderer()->setOpacity(opacity); }));
float opacity = getInheritedOpacity();
addAnimation(m_showAnimations, std::make_shared<priv::FadeAnimation>(shared_from_this(), getInheritedOpacity(), 0.f, duration, [=](){ hide(); setInheritedOpacity(opacity); }));
break;
}
case ShowAnimationType::Scale:
@ -569,6 +605,36 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Widget::setInheritedFont(const Font& font)
{
m_inheritedFont = font;
rendererChanged("font");
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const Font& Widget::getInheritedFont() const
{
return m_inheritedFont;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Widget::setInheritedOpacity(float opacity)
{
m_inheritedOpacity = opacity;
rendererChanged("opacity");
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float Widget::getInheritedOpacity() const
{
return m_inheritedOpacity;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Widget::setToolTip(Widget::Ptr toolTip)
{
m_toolTip = toolTip;
@ -755,14 +821,15 @@ namespace tgui
void Widget::rendererChanged(const std::string& property)
{
if (property == "opacity")
m_opacityCached = getRenderer()->getOpacity();
{
m_opacityCached = getSharedRenderer()->getOpacity() * m_inheritedOpacity;
}
else if (property == "font")
{
m_fontCached = getRenderer()->getFont();
// Try to use the font of the parent when the font is removed
if (!m_fontCached && m_parent && m_parent->getRenderer()->getFont())
getRenderer()->setFont(m_parent->getRenderer()->getFont());
if (getSharedRenderer()->getFont())
m_fontCached = getSharedRenderer()->getFont();
else
m_fontCached = m_inheritedFont;
}
else
throw Exception{"Could not set property '" + property + "', widget of type '" + getWidgetType() + "' does not has this property."};

34
src/TGUI/Widgets/BoxLayout.cpp
View File

@ -35,8 +35,34 @@ namespace tgui
BoxLayout::BoxLayout(const Layout2d& size) :
Group{size}
{
m_renderer = aurora::makeCopied<BoxLayoutRenderer>();
setRenderer(RendererData::create());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BoxLayoutRenderer* BoxLayout::getSharedRenderer()
{
return aurora::downcast<BoxLayoutRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const BoxLayoutRenderer* BoxLayout::getSharedRenderer() const
{
return aurora::downcast<const BoxLayoutRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BoxLayoutRenderer* BoxLayout::getRenderer()
{
return aurora::downcast<BoxLayoutRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const BoxLayoutRenderer* BoxLayout::getRenderer() const
{
return aurora::downcast<const BoxLayoutRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -120,7 +146,7 @@ namespace tgui
{
if (property == "spacebetweenwidgets")
{
m_spaceBetweenWidgetsCached = getRenderer()->getSpaceBetweenWidgets();
m_spaceBetweenWidgetsCached = getSharedRenderer()->getSpaceBetweenWidgets();
updateWidgets();
}
else if (property == "padding")
@ -128,7 +154,7 @@ namespace tgui
Group::rendererChanged(property);
// Update the space between widgets as the padding is used when no space was explicitly set
m_spaceBetweenWidgetsCached = getRenderer()->getSpaceBetweenWidgets();
m_spaceBetweenWidgetsCached = getSharedRenderer()->getSpaceBetweenWidgets();
updateWidgets();
}
else

107
src/TGUI/Widgets/Button.cpp
View File

@ -29,21 +29,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"bordercolordown", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"textcolordown", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"backgroundcolordown", sf::Color::White}
///TODO: Define default disabled colors
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Button::Button()
@ -51,7 +36,7 @@ namespace tgui
m_type = "Button";
m_renderer = aurora::makeCopied<ButtonRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(120, 30);
}
@ -80,6 +65,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ButtonRenderer* Button::getSharedRenderer()
{
return aurora::downcast<ButtonRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ButtonRenderer* Button::getSharedRenderer() const
{
return aurora::downcast<const ButtonRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ButtonRenderer* Button::getRenderer()
{
return aurora::downcast<ButtonRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ButtonRenderer* Button::getRenderer() const
{
return aurora::downcast<const ButtonRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Button::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -119,16 +132,18 @@ namespace tgui
void Button::setText(const sf::String& text)
{
m_string = text;
m_text.setString(text);
// Set the text size when the text has a fixed size
if (m_textSize != 0)
m_text.setCharacterSize(m_textSize);
if ((getInnerSize().x < 0) || (getInnerSize().y < 0))
return;
// Draw the text normally unless the height is more than double of the width
if (getInnerSize().y <= getInnerSize().x * 2)
{
m_text.setString(text);
// Auto size the text when necessary
if (m_textSize == 0)
{
@ -263,7 +278,7 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if ((property == "textcolor") || (property == "textcolorhover") || (property == "textcolordown") || (property == "textcolordisabled")
@ -273,56 +288,56 @@ namespace tgui
}
else if (property == "texture")
{
m_sprite.setTexture(getRenderer()->getTexture());
m_sprite.setTexture(getSharedRenderer()->getTexture());
}
else if (property == "texturehover")
{
m_spriteHover.setTexture(getRenderer()->getTextureHover());
m_spriteHover.setTexture(getSharedRenderer()->getTextureHover());
}
else if (property == "texturedown")
{
m_spriteDown.setTexture(getRenderer()->getTextureDown());
m_spriteDown.setTexture(getSharedRenderer()->getTextureDown());
}
else if (property == "texturedisabled")
{
m_spriteDisabled.setTexture(getRenderer()->getTextureDisabled());
m_spriteDisabled.setTexture(getSharedRenderer()->getTextureDisabled());
}
else if (property == "texturefocused")
{
m_spriteFocused.setTexture(getRenderer()->getTextureFocused());
m_spriteFocused.setTexture(getSharedRenderer()->getTextureFocused());
m_allowFocus = m_spriteFocused.isSet();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "bordercolorhover")
{
m_borderColorHoverCached = getRenderer()->getBorderColorHover();
m_borderColorHoverCached = getSharedRenderer()->getBorderColorHover();
}
else if (property == "bordercolordown")
{
m_borderColorDownCached = getRenderer()->getBorderColorDown();
m_borderColorDownCached = getSharedRenderer()->getBorderColorDown();
}
else if (property == "bordercolordisabled")
{
m_borderColorDisabledCached = getRenderer()->getBorderColorDisabled();
m_borderColorDisabledCached = getSharedRenderer()->getBorderColorDisabled();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "backgroundcolorhover")
{
m_backgroundColorHoverCached = getRenderer()->getBackgroundColorHover();
m_backgroundColorHoverCached = getSharedRenderer()->getBackgroundColorHover();
}
else if (property == "backgroundcolordown")
{
m_backgroundColorDownCached = getRenderer()->getBackgroundColorDown();
m_backgroundColorDownCached = getSharedRenderer()->getBackgroundColorDown();
}
else if (property == "backgroundcolordisabled")
{
m_backgroundColorDisabledCached = getRenderer()->getBackgroundColorDisabled();
m_backgroundColorDisabledCached = getSharedRenderer()->getBackgroundColorDisabled();
}
else if (property == "opacity")
{
@ -387,24 +402,24 @@ namespace tgui
void Button::updateTextColorAndStyle()
{
if (!m_enabled && getRenderer()->getTextStyleDisabled().isSet())
m_text.setStyle(getRenderer()->getTextStyleDisabled());
else if (m_mouseHover && m_mouseDown && getRenderer()->getTextStyleDown().isSet())
m_text.setStyle(getRenderer()->getTextStyleDown());
else if (m_mouseHover && getRenderer()->getTextStyleHover().isSet())
m_text.setStyle(getRenderer()->getTextStyleHover());
if (!m_enabled && getSharedRenderer()->getTextStyleDisabled().isSet())
m_text.setStyle(getSharedRenderer()->getTextStyleDisabled());
else if (m_mouseHover && m_mouseDown && getSharedRenderer()->getTextStyleDown().isSet())
m_text.setStyle(getSharedRenderer()->getTextStyleDown());
else if (m_mouseHover && getSharedRenderer()->getTextStyleHover().isSet())
m_text.setStyle(getSharedRenderer()->getTextStyleHover());
else
m_text.setStyle(getRenderer()->getTextStyle());
m_text.setStyle(getSharedRenderer()->getTextStyle());
sf::Color color;
if (!m_enabled && getRenderer()->getTextColorDisabled().isSet())
color = getRenderer()->getTextColorDisabled();
else if (m_mouseHover && m_mouseDown && getRenderer()->getTextColorDown().isSet())
color = getRenderer()->getTextColorDown();
else if (m_mouseHover && getRenderer()->getTextColorHover().isSet())
color = getRenderer()->getTextColorHover();
if (!m_enabled && getSharedRenderer()->getTextColorDisabled().isSet())
color = getSharedRenderer()->getTextColorDisabled();
else if (m_mouseHover && m_mouseDown && getSharedRenderer()->getTextColorDown().isSet())
color = getSharedRenderer()->getTextColorDown();
else if (m_mouseHover && getSharedRenderer()->getTextColorHover().isSet())
color = getSharedRenderer()->getTextColorHover();
else
color = getRenderer()->getTextColor();
color = getSharedRenderer()->getTextColor();
m_text.setColor(color);
}

2
src/TGUI/Widgets/Canvas.cpp
View File

@ -151,7 +151,7 @@ namespace tgui
Widget::rendererChanged(property);
if (property == "opacity")
m_sprite.setColor(Color::calcColorOpacity(sf::Color::White, getRenderer()->getOpacity()));
m_sprite.setColor(Color::calcColorOpacity(sf::Color::White, getSharedRenderer()->getOpacity()));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

52
src/TGUI/Widgets/ChatBox.cpp
View File

@ -32,14 +32,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"padding", Padding{2, 0, 0, 0}},
{"bordercolor", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChatBox::ChatBox()
@ -48,7 +40,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<ChatBoxRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({200, 126});
setTextSize(m_textSize);
@ -73,6 +65,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChatBoxRenderer* ChatBox::getSharedRenderer()
{
return aurora::downcast<ChatBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ChatBoxRenderer* ChatBox::getSharedRenderer() const
{
return aurora::downcast<const ChatBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChatBoxRenderer* ChatBox::getRenderer()
{
return aurora::downcast<ChatBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ChatBoxRenderer* ChatBox::getRenderer() const
{
return aurora::downcast<const ChatBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ChatBox::setPosition(const Layout2d& position)
{
Widget::setPosition(position);
@ -444,36 +464,36 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
setSize(m_size);
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
}
else if (property == "scrollbar")
{
m_scroll.setRenderer(getRenderer()->getScrollbar());
m_scroll.setRenderer(getSharedRenderer()->getScrollbar());
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "opacity")
{
Widget::rendererChanged(property);
m_spriteBackground.setOpacity(m_opacityCached);
m_scroll.getRenderer()->setOpacity(m_opacityCached);
m_scroll.setInheritedOpacity(m_opacityCached);
for (auto& line : m_lines)
line.text.setOpacity(m_opacityCached);

6
src/TGUI/Widgets/CheckBox.cpp
View File

@ -37,6 +37,8 @@ namespace tgui
CheckBox::CheckBox()
{
m_type = "CheckBox";
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -157,9 +159,9 @@ namespace tgui
void CheckBox::rendererChanged(const std::string& property)
{
if (property == "textureunchecked")
m_textureUncheckedCached = getRenderer()->getTextureUnchecked();
m_textureUncheckedCached = getSharedRenderer()->getTextureUnchecked();
else if (property == "texturechecked")
m_textureCheckedCached = getRenderer()->getTextureChecked();
m_textureCheckedCached = getSharedRenderer()->getTextureChecked();
RadioButton::rendererChanged(property);
}

103
src/TGUI/Widgets/ChildWindow.cpp
View File

@ -50,29 +50,12 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{1}},
{"bordercolor", sf::Color::Black},
{"titlecolor", sf::Color::Black},
{"titlebarcolor", sf::Color::White},
{"backgroundcolor", Color{230, 230, 230}},
{"distancetoside", 3.f},
{"paddingbetweenbuttons", 1.f}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChildWindow::ChildWindow(const sf::String& title, unsigned int titleButtons)
{
m_type = "ChildWindow";
m_renderer = aurora::makeCopied<ChildWindowRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
getRenderer()->getCloseButton()->propertyValuePairs["borders"] = {Borders{1}};
getRenderer()->getMaximizeButton()->propertyValuePairs["borders"] = {Borders{1}};
getRenderer()->getMinimizeButton()->propertyValuePairs["borders"] = {Borders{1}};
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setTitleButtons(titleButtons);
setTitle(title);
@ -98,6 +81,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChildWindowRenderer* ChildWindow::getSharedRenderer()
{
return aurora::downcast<ChildWindowRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ChildWindowRenderer* ChildWindow::getSharedRenderer() const
{
return aurora::downcast<const ChildWindowRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ChildWindowRenderer* ChildWindow::getRenderer()
{
return aurora::downcast<ChildWindowRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ChildWindowRenderer* ChildWindow::getRenderer() const
{
return aurora::downcast<const ChildWindowRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ChildWindow::setPosition(const Layout2d& position)
{
float x = position.getValue().x;
@ -265,8 +276,8 @@ namespace tgui
if (m_titleButtons & TitleButton::Close)
{
m_closeButton = Button::create();
m_closeButton->setRenderer(getRenderer()->getCloseButton());
m_closeButton->getRenderer()->setOpacity(m_opacityCached);
m_closeButton->setRenderer(getSharedRenderer()->getCloseButton());
m_closeButton->setInheritedOpacity(m_opacityCached);
m_closeButton->connect("pressed", [this](){
if (!onClose.emit(this))
destroy();
@ -278,8 +289,8 @@ namespace tgui
if (m_titleButtons & TitleButton::Maximize)
{
m_maximizeButton = Button::create();
m_maximizeButton->setRenderer(getRenderer()->getMaximizeButton());
m_maximizeButton->getRenderer()->setOpacity(m_opacityCached);
m_maximizeButton->setRenderer(getSharedRenderer()->getMaximizeButton());
m_maximizeButton->setInheritedOpacity(m_opacityCached);
m_maximizeButton->connect("pressed", [this](){ onMaximize.emit(this); });
}
else
@ -288,8 +299,8 @@ namespace tgui
if (m_titleButtons & TitleButton::Minimize)
{
m_minimizeButton = Button::create();
m_minimizeButton->setRenderer(getRenderer()->getMinimizeButton());
m_minimizeButton->getRenderer()->setOpacity(m_opacityCached);
m_minimizeButton->setRenderer(getSharedRenderer()->getMinimizeButton());
m_minimizeButton->setInheritedOpacity(m_opacityCached);
m_minimizeButton->connect("pressed", [this](){ onMinimize.emit(this); });
}
else
@ -603,10 +614,10 @@ namespace tgui
{
if (button)
{
if (m_spriteTitleBar.isSet() && (button->getRenderer()->getTexture().getData() != nullptr))
if (m_spriteTitleBar.isSet() && (button->getSharedRenderer()->getTexture().getData() != nullptr))
{
button->setSize(button->getRenderer()->getTexture().getImageSize().x * (m_titleBarHeightCached / m_spriteTitleBar.getTexture().getImageSize().y),
button->getRenderer()->getTexture().getImageSize().y * (m_titleBarHeightCached / m_spriteTitleBar.getTexture().getImageSize().y));
button->setSize(button->getSharedRenderer()->getTexture().getImageSize().x * (m_titleBarHeightCached / m_spriteTitleBar.getTexture().getImageSize().y),
button->getSharedRenderer()->getTexture().getImageSize().y * (m_titleBarHeightCached / m_spriteTitleBar.getTexture().getImageSize().y));
}
else
button->setSize({m_titleBarHeightCached * 0.8f, m_titleBarHeightCached * 0.8f});
@ -642,43 +653,43 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "titlecolor")
{
m_titleText.setColor(getRenderer()->getTitleColor());
m_titleText.setColor(getSharedRenderer()->getTitleColor());
}
else if (property == "texturetitlebar")
{
m_spriteTitleBar.setTexture(getRenderer()->getTextureTitleBar());
m_spriteTitleBar.setTexture(getSharedRenderer()->getTextureTitleBar());
// If the title bar height is determined by the texture then update it (note that getTitleBarHeight has a non-trivial implementation)
m_titleBarHeightCached = getRenderer()->getTitleBarHeight();
m_titleBarHeightCached = getSharedRenderer()->getTitleBarHeight();
if (m_titleBarHeightCached == m_spriteTitleBar.getTexture().getImageSize().y)
updateTitleBarHeight();
}
else if (property == "titlebarheight")
{
m_titleBarHeightCached = getRenderer()->getTitleBarHeight();
m_titleBarHeightCached = getSharedRenderer()->getTitleBarHeight();
updateTitleBarHeight();
}
else if (property == "distancetoside")
{
m_distanceToSideCached = getRenderer()->getDistanceToSide();
m_distanceToSideCached = getSharedRenderer()->getDistanceToSide();
setPosition(m_position);
}
else if (property == "paddingbetweenbuttons")
{
m_paddingBetweenButtonsCached = getRenderer()->getPaddingBetweenButtons();
m_paddingBetweenButtonsCached = getSharedRenderer()->getPaddingBetweenButtons();
setPosition(m_position);
}
else if (property == "closebutton")
{
if (m_closeButton)
{
m_closeButton->setRenderer(getRenderer()->getCloseButton());
m_closeButton->getRenderer()->setOpacity(m_opacityCached);
m_closeButton->setRenderer(getSharedRenderer()->getCloseButton());
m_closeButton->setInheritedOpacity(m_opacityCached);
}
updateTitleBarHeight();
@ -687,8 +698,8 @@ namespace tgui
{
if (m_maximizeButton)
{
m_maximizeButton->setRenderer(getRenderer()->getMaximizeButton());
m_maximizeButton->getRenderer()->setOpacity(m_opacityCached);
m_maximizeButton->setRenderer(getSharedRenderer()->getMaximizeButton());
m_maximizeButton->setInheritedOpacity(m_opacityCached);
}
updateTitleBarHeight();
@ -697,23 +708,23 @@ namespace tgui
{
if (m_minimizeButton)
{
m_minimizeButton->setRenderer(getRenderer()->getMinimizeButton());
m_minimizeButton->getRenderer()->setOpacity(m_opacityCached);
m_minimizeButton->setRenderer(getSharedRenderer()->getMinimizeButton());
m_minimizeButton->setInheritedOpacity(m_opacityCached);
}
updateTitleBarHeight();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "titlebarcolor")
{
m_titleBarColorCached = getRenderer()->getTitleBarColor();
m_titleBarColorCached = getSharedRenderer()->getTitleBarColor();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "opacity")
{
@ -722,7 +733,7 @@ namespace tgui
for (auto& button : {m_closeButton, m_minimizeButton, m_maximizeButton})
{
if (button)
button->getRenderer()->setOpacity(m_opacityCached);
button->setInheritedOpacity(m_opacityCached);
}
m_titleText.setOpacity(m_opacityCached);
@ -735,11 +746,11 @@ namespace tgui
for (auto& button : {m_closeButton, m_minimizeButton, m_maximizeButton})
{
if (button)
button->getRenderer()->setFont(m_fontCached);
button->setInheritedFont(m_fontCached);
}
m_titleText.setFont(m_fontCached);
m_titleText.setCharacterSize(Text::findBestTextSize(m_fontCached, getRenderer()->getTitleBarHeight() * 0.8f));
m_titleText.setCharacterSize(Text::findBestTextSize(m_fontCached, getSharedRenderer()->getTitleBarHeight() * 0.8f));
setPosition(m_position);
}

83
src/TGUI/Widgets/ComboBox.cpp
View File

@ -32,19 +32,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"padding", Padding{0}},
{"bordercolor", sf::Color::Black},
{"textcolor", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"arrowcolor", Color{60, 60, 60}},
{"arrowcolorhover", sf::Color::Black},
{"arrowbackgroundcolor", Color{245, 245, 245}},
{"arrowbackgroundcolorhover", sf::Color::White}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ComboBox::ComboBox()
@ -56,7 +43,7 @@ namespace tgui
initListBox();
m_renderer = aurora::makeCopied<ComboBoxRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({150, 24});
}
@ -190,6 +177,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ComboBoxRenderer* ComboBox::getSharedRenderer()
{
return aurora::downcast<ComboBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ComboBoxRenderer* ComboBox::getSharedRenderer() const
{
return aurora::downcast<const ComboBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ComboBoxRenderer* ComboBox::getRenderer()
{
return aurora::downcast<ComboBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ComboBoxRenderer* ComboBox::getRenderer() const
{
return aurora::downcast<const ComboBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ComboBox::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -521,71 +536,71 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
setSize(m_size);
}
else if (property == "textcolor")
{
m_text.setColor(getRenderer()->getTextColor());
m_text.setColor(getSharedRenderer()->getTextColor());
}
else if (property == "textstyle")
{
m_text.setStyle(getRenderer()->getTextStyle());
m_text.setStyle(getSharedRenderer()->getTextStyle());
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
}
else if (property == "texturearrowup")
{
m_spriteArrowUp.setTexture(getRenderer()->getTextureArrowUp());
m_spriteArrowUp.setTexture(getSharedRenderer()->getTextureArrowUp());
setSize(m_size);
}
else if (property == "texturearrowuphover")
{
m_spriteArrowUpHover.setTexture(getRenderer()->getTextureArrowUpHover());
m_spriteArrowUpHover.setTexture(getSharedRenderer()->getTextureArrowUpHover());
}
else if (property == "texturearrowdown")
{
m_spriteArrowDown.setTexture(getRenderer()->getTextureArrowDown());
m_spriteArrowDown.setTexture(getSharedRenderer()->getTextureArrowDown());
setSize(m_size);
}
else if (property == "texturearrowdownhover")
{
m_spriteArrowDownHover.setTexture(getRenderer()->getTextureArrowDownHover());
m_spriteArrowDownHover.setTexture(getSharedRenderer()->getTextureArrowDownHover());
}
else if (property == "listbox")
{
m_listBox->setRenderer(getRenderer()->getListBox());
m_listBox->setRenderer(getSharedRenderer()->getListBox());
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "arrowbackgroundcolor")
{
m_arrowBackgroundColorCached = getRenderer()->getArrowBackgroundColor();
m_arrowBackgroundColorCached = getSharedRenderer()->getArrowBackgroundColor();
}
else if (property == "arrowbackgroundcolorhover")
{
m_arrowBackgroundColorHoverCached = getRenderer()->getArrowBackgroundColorHover();
m_arrowBackgroundColorHoverCached = getSharedRenderer()->getArrowBackgroundColorHover();
}
else if (property == "arrowcolor")
{
m_arrowColorCached = getRenderer()->getArrowColor();
m_arrowColorCached = getSharedRenderer()->getArrowColor();
}
else if (property == "arrowcolorhover")
{
m_arrowColorHoverCached = getRenderer()->getArrowColorHover();
m_arrowColorHoverCached = getSharedRenderer()->getArrowColorHover();
}
else if (property == "opacity")
{
@ -604,9 +619,7 @@ namespace tgui
Widget::rendererChanged(property);
m_text.setFont(m_fontCached);
if (m_listBox->getRenderer()->getFont() == nullptr)
m_listBox->getRenderer()->setFont(m_fontCached);
m_listBox->setInheritedFont(m_fontCached);
setSize(m_size);
}
@ -626,8 +639,8 @@ namespace tgui
void ComboBox::updateListBoxHeight()
{
const Borders borders = m_listBox->getRenderer()->getBorders();
const Padding padding = m_listBox->getRenderer()->getPadding();
const Borders borders = m_listBox->getSharedRenderer()->getBorders();
const Padding padding = m_listBox->getSharedRenderer()->getPadding();
if (m_nrOfItemsToDisplay > 0)
m_listBox->setSize({getSize().x, (m_listBox->getItemHeight() * (std::min<std::size_t>(m_nrOfItemsToDisplay, std::max<std::size_t>(m_listBox->getItemCount(), 1))))

113
src/TGUI/Widgets/EditBox.cpp
View File

@ -43,25 +43,6 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"padding", Padding{4, 2, 4, 2}},
{"caretwidth", 1.f},
{"caretcolor", sf::Color::Black},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"selectedtextcolor", sf::Color::White},
{"selectedtextbackgroundcolor", Color{0, 110, 255}},
{"defaulttextcolor", Color{160, 160, 160}},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White}
///TODO: Define default disabled colors
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EditBox::EditBox()
{
m_type = "EditBox";
@ -70,7 +51,7 @@ namespace tgui
m_allowFocus = true;
m_renderer = aurora::makeCopied<EditBoxRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({240, 30});
}
@ -94,6 +75,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EditBoxRenderer* EditBox::getSharedRenderer()
{
return aurora::downcast<EditBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const EditBoxRenderer* EditBox::getSharedRenderer() const
{
return aurora::downcast<const EditBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EditBoxRenderer* EditBox::getRenderer()
{
return aurora::downcast<EditBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const EditBoxRenderer* EditBox::getRenderer() const
{
return aurora::downcast<const EditBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void EditBox::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -123,8 +132,8 @@ namespace tgui
{
Widget::enable();
m_textBeforeSelection.setColor(getRenderer()->getTextColor());
m_textAfterSelection.setColor(getRenderer()->getTextColor());
m_textBeforeSelection.setColor(getSharedRenderer()->getTextColor());
m_textAfterSelection.setColor(getSharedRenderer()->getTextColor());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -133,10 +142,10 @@ namespace tgui
{
Widget::disable();
if (getRenderer()->getTextColorDisabled().isSet())
if (getSharedRenderer()->getTextColorDisabled().isSet())
{
m_textBeforeSelection.setColor(getRenderer()->getTextColorDisabled());
m_textAfterSelection.setColor(getRenderer()->getTextColorDisabled());
m_textBeforeSelection.setColor(getSharedRenderer()->getTextColorDisabled());
m_textAfterSelection.setColor(getSharedRenderer()->getTextColorDisabled());
}
}
@ -940,12 +949,12 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
m_paddingCached.updateParentSize(getSize());
setText(m_text);
@ -954,50 +963,50 @@ namespace tgui
}
else if (property == "caretwidth")
{
m_caret.setPosition({m_caret.getPosition().x + ((m_caret.getSize().x - getRenderer()->getCaretWidth()) / 2.0f), m_caret.getPosition().y});
m_caret.setSize({getRenderer()->getCaretWidth(), getInnerSize().y - m_paddingCached.getBottom() - m_paddingCached.getTop()});
m_caret.setPosition({m_caret.getPosition().x + ((m_caret.getSize().x - getSharedRenderer()->getCaretWidth()) / 2.0f), m_caret.getPosition().y});
m_caret.setSize({getSharedRenderer()->getCaretWidth(), getInnerSize().y - m_paddingCached.getBottom() - m_paddingCached.getTop()});
}
else if ((property == "textcolor") || (property == "textcolordisabled"))
{
if (m_enabled || !getRenderer()->getTextColorDisabled().isSet())
if (m_enabled || !getSharedRenderer()->getTextColorDisabled().isSet())
{
m_textBeforeSelection.setColor(getRenderer()->getTextColor());
m_textAfterSelection.setColor(getRenderer()->getTextColor());
m_textBeforeSelection.setColor(getSharedRenderer()->getTextColor());
m_textAfterSelection.setColor(getSharedRenderer()->getTextColor());
}
else
{
m_textBeforeSelection.setColor(getRenderer()->getTextColorDisabled());
m_textAfterSelection.setColor(getRenderer()->getTextColorDisabled());
m_textBeforeSelection.setColor(getSharedRenderer()->getTextColorDisabled());
m_textAfterSelection.setColor(getSharedRenderer()->getTextColorDisabled());
}
}
else if (property == "selectedtextcolor")
{
m_textSelection.setColor(getRenderer()->getSelectedTextColor());
m_textSelection.setColor(getSharedRenderer()->getSelectedTextColor());
}
else if (property == "defaulttextcolor")
{
m_defaultText.setColor(getRenderer()->getDefaultTextColor());
m_defaultText.setColor(getSharedRenderer()->getDefaultTextColor());
}
else if (property == "texture")
{
m_sprite.setTexture(getRenderer()->getTexture());
m_sprite.setTexture(getSharedRenderer()->getTexture());
}
else if (property == "texturehover")
{
m_spriteHover.setTexture(getRenderer()->getTextureHover());
m_spriteHover.setTexture(getSharedRenderer()->getTextureHover());
}
else if (property == "texturedisabled")
{
m_spriteDisabled.setTexture(getRenderer()->getTextureDisabled());
m_spriteDisabled.setTexture(getSharedRenderer()->getTextureDisabled());
}
else if (property == "texturefocused")
{
m_spriteFocused.setTexture(getRenderer()->getTextureFocused());
m_spriteFocused.setTexture(getSharedRenderer()->getTextureFocused());
m_allowFocus = m_spriteFocused.isSet();
}
else if (property == "textstyle")
{
const TextStyle style = getRenderer()->getTextStyle();
const TextStyle style = getSharedRenderer()->getTextStyle();
m_textBeforeSelection.setStyle(style);
m_textAfterSelection.setStyle(style);
m_textSelection.setStyle(style);
@ -1005,47 +1014,47 @@ namespace tgui
}
else if (property == "defaulttextstyle")
{
m_defaultText.setStyle(getRenderer()->getDefaultTextStyle());
m_defaultText.setStyle(getSharedRenderer()->getDefaultTextStyle());
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "bordercolorhover")
{
m_borderColorHoverCached = getRenderer()->getBorderColorHover();
m_borderColorHoverCached = getSharedRenderer()->getBorderColorHover();
}
else if (property == "bordercolordisabled")
{
m_borderColorDisabledCached = getRenderer()->getBorderColorDisabled();
m_borderColorDisabledCached = getSharedRenderer()->getBorderColorDisabled();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "backgroundcolorhover")
{
m_backgroundColorHoverCached = getRenderer()->getBackgroundColorHover();
m_backgroundColorHoverCached = getSharedRenderer()->getBackgroundColorHover();
}
else if (property == "backgroundcolordisabled")
{
m_backgroundColorDisabledCached = getRenderer()->getBackgroundColorDisabled();
m_backgroundColorDisabledCached = getSharedRenderer()->getBackgroundColorDisabled();
}
else if (property == "caretcolor")
{
m_caretColorCached = getRenderer()->getCaretColor();
m_caretColorCached = getSharedRenderer()->getCaretColor();
}
else if (property == "caretcolorhover")
{
m_caretColorHoverCached = getRenderer()->getCaretColorHover();
m_caretColorHoverCached = getSharedRenderer()->getCaretColorHover();
}
else if (property == "caretcolordisabled")
{
m_caretColorDisabledCached = getRenderer()->getCaretColorDisabled();
m_caretColorDisabledCached = getSharedRenderer()->getCaretColorDisabled();
}
else if (property == "selectedtextbackgroundcolor")
{
m_selectedTextBackgroundColorCached = getRenderer()->getSelectedTextBackgroundColor();
m_selectedTextBackgroundColorCached = getSharedRenderer()->getSelectedTextBackgroundColor();
}
else if (property == "opacity")
{

32
src/TGUI/Widgets/Group.cpp
View File

@ -37,7 +37,7 @@ namespace tgui
m_type = "Group";
m_renderer = aurora::makeCopied<GroupRenderer>();
setRenderer(RendererData::create());
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(size);
}
@ -61,6 +61,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GroupRenderer* Group::getSharedRenderer()
{
return aurora::downcast<GroupRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const GroupRenderer* Group::getSharedRenderer() const
{
return aurora::downcast<const GroupRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GroupRenderer* Group::getRenderer()
{
return aurora::downcast<GroupRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const GroupRenderer* Group::getRenderer() const
{
return aurora::downcast<const GroupRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Group::setSize(const Layout2d& size)
{
m_paddingCached.updateParentSize(size.getValue());
@ -111,7 +139,7 @@ namespace tgui
{
if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
setSize(m_size);
}
else

3
src/TGUI/Widgets/HorizontalLayout.cpp
View File

@ -36,6 +36,9 @@ namespace tgui
BoxLayoutRatios{size}
{
m_type = "HorizontalLayout";
m_renderer = aurora::makeCopied<BoxLayoutRenderer>();
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

3
src/TGUI/Widgets/HorizontalWrap.cpp
View File

@ -35,6 +35,9 @@ namespace tgui
BoxLayout{size}
{
m_type = "HorizontalWrap";
m_renderer = aurora::makeCopied<BoxLayoutRenderer>();
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

53
src/TGUI/Widgets/Knob.cpp
View File

@ -38,15 +38,6 @@ namespace
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{5}},
{"imagerotation", 0.f},
{"bordercolor", sf::Color::Black},
{"thumbcolor", sf::Color::Black},
{"backgroundcolor", sf::Color::White}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Knob::Knob()
@ -55,7 +46,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<KnobRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(140, 140);
}
@ -79,6 +70,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
KnobRenderer* Knob::getSharedRenderer()
{
return aurora::downcast<KnobRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const KnobRenderer* Knob::getSharedRenderer() const
{
return aurora::downcast<const KnobRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
KnobRenderer* Knob::getRenderer()
{
return aurora::downcast<KnobRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const KnobRenderer* Knob::getRenderer() const
{
return aurora::downcast<const KnobRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Knob::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -464,34 +483,34 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
setSize(m_size);
}
else if (property == "textureforeground")
{
m_spriteForeground.setTexture(getRenderer()->getTextureForeground());
m_spriteForeground.setTexture(getSharedRenderer()->getTextureForeground());
setSize(m_size);
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "thumbcolor")
{
m_thumbColorCached = getRenderer()->getThumbColor();
m_thumbColorCached = getSharedRenderer()->getThumbColor();
}
else if (property == "imagerotation")
{
m_imageRotationCached = getRenderer()->getImageRotation();
m_imageRotationCached = getSharedRenderer()->getImageRotation();
}
else if (property == "opacity")
{

52
src/TGUI/Widgets/Label.cpp
View File

@ -32,14 +32,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{}},
{"bordercolor", Color{60, 60, 60}},
{"textcolor", Color{60, 60, 60}},
{"backgroundcolor", sf::Color::Transparent}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Label::Label()
@ -47,7 +39,7 @@ namespace tgui
m_type = "Label";
m_renderer = aurora::makeCopied<LabelRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -74,6 +66,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LabelRenderer* Label::getSharedRenderer()
{
return aurora::downcast<LabelRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const LabelRenderer* Label::getSharedRenderer() const
{
return aurora::downcast<const LabelRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LabelRenderer* Label::getRenderer()
{
return aurora::downcast<LabelRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const LabelRenderer* Label::getRenderer() const
{
return aurora::downcast<const LabelRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Label::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -251,34 +271,34 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
m_bordersCached.updateParentSize(getSize());
rearrangeText();
}
else if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
m_paddingCached.updateParentSize(getSize());
rearrangeText();
}
else if (property == "textstyle")
{
m_textStyleCached = getRenderer()->getTextStyle();
m_textStyleCached = getSharedRenderer()->getTextStyle();
rearrangeText();
}
else if (property == "textcolor")
{
m_textColorCached = getRenderer()->getTextColor();
m_textColorCached = getSharedRenderer()->getTextColor();
for (auto& line : m_lines)
line.setColor(m_textColorCached);
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "font")
{
@ -443,7 +463,7 @@ namespace tgui
}
// Draw the background
if (m_backgroundColorCached != sf::Color::Transparent)
if (m_backgroundColorCached.isSet() && (m_backgroundColorCached != sf::Color::Transparent))
drawRectangleShape(target, states, innerSize, m_backgroundColorCached);
// Apply clipping when needed

76
src/TGUI/Widgets/ListBox.cpp
View File

@ -30,20 +30,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"padding", Padding{0}},
{"bordercolor", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"selectedbackgroundcolor", Color{0, 110, 255}},
{"selectedbackgroundcolorhover", Color{30, 150, 255}}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ListBox::ListBox()
@ -53,7 +39,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<ListBoxRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({150, 154});
setItemHeight(m_itemHeight);
@ -78,6 +64,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ListBoxRenderer* ListBox::getSharedRenderer()
{
return aurora::downcast<ListBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ListBoxRenderer* ListBox::getSharedRenderer() const
{
return aurora::downcast<const ListBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ListBoxRenderer* ListBox::getRenderer()
{
return aurora::downcast<ListBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ListBoxRenderer* ListBox::getRenderer() const
{
return aurora::downcast<const ListBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ListBox::setPosition(const Layout2d& position)
{
Widget::setPosition(position);
@ -620,41 +634,41 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
setSize(m_size);
}
else if (property == "textcolor")
{
m_textColorCached = getRenderer()->getTextColor();
m_textColorCached = getSharedRenderer()->getTextColor();
updateItemColorsAndStyle();
}
else if (property == "textcolorhover")
{
m_textColorHoverCached = getRenderer()->getTextColorHover();
m_textColorHoverCached = getSharedRenderer()->getTextColorHover();
updateItemColorsAndStyle();
}
else if (property == "selectedtextcolor")
{
m_selectedTextColorCached = getRenderer()->getSelectedTextColor();
m_selectedTextColorCached = getSharedRenderer()->getSelectedTextColor();
updateItemColorsAndStyle();
}
else if (property == "selectedtextcolorhover")
{
m_selectedTextColorHoverCached = getRenderer()->getSelectedTextColorHover();
m_selectedTextColorHoverCached = getSharedRenderer()->getSelectedTextColorHover();
updateItemColorsAndStyle();
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
}
else if (property == "textstyle")
{
m_textStyleCached = getRenderer()->getTextStyle();
m_textStyleCached = getSharedRenderer()->getTextStyle();
for (auto& item : m_items)
item.setStyle(m_textStyleCached);
@ -664,7 +678,7 @@ namespace tgui
}
else if (property == "selectedtextstyle")
{
m_selectedTextStyleCached = getRenderer()->getSelectedTextStyle();
m_selectedTextStyleCached = getSharedRenderer()->getSelectedTextStyle();
if (m_selectedItem >= 0)
{
@ -676,34 +690,34 @@ namespace tgui
}
else if (property == "scrollbar")
{
m_scroll.setRenderer(getRenderer()->getScrollbar());
m_scroll.setRenderer(getSharedRenderer()->getScrollbar());
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "backgroundcolorhover")
{
m_backgroundColorHoverCached = getRenderer()->getBackgroundColorHover();
m_backgroundColorHoverCached = getSharedRenderer()->getBackgroundColorHover();
}
else if (property == "selectedbackgroundcolor")
{
m_selectedBackgroundColorCached = getRenderer()->getSelectedBackgroundColor();
m_selectedBackgroundColorCached = getSharedRenderer()->getSelectedBackgroundColor();
}
else if (property == "selectedbackgroundcolorhover")
{
m_selectedBackgroundColorHoverCached = getRenderer()->getSelectedBackgroundColorHover();
m_selectedBackgroundColorHoverCached = getSharedRenderer()->getSelectedBackgroundColorHover();
}
else if (property == "opacity")
{
Widget::rendererChanged(property);
m_scroll.setInheritedOpacity(m_opacityCached);
m_spriteBackground.setOpacity(m_opacityCached);
m_scroll.getRenderer()->setOpacity(m_opacityCached);
for (auto& item : m_items)
item.setOpacity(m_opacityCached);
}

55
src/TGUI/Widgets/MenuBar.cpp
View File

@ -31,15 +31,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"textcolor", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"backgroundcolor", sf::Color::White},
{"selectedbackgroundcolor", Color{0, 110, 255}},
{"distancetoside", 4.f}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MenuBar::MenuBar()
@ -47,7 +38,7 @@ namespace tgui
m_type = "MenuBar";
m_renderer = aurora::makeCopied<MenuBarRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({0, 20});
}
@ -71,6 +62,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MenuBarRenderer* MenuBar::getSharedRenderer()
{
return aurora::downcast<MenuBarRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const MenuBarRenderer* MenuBar::getSharedRenderer() const
{
return aurora::downcast<const MenuBarRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MenuBarRenderer* MenuBar::getRenderer()
{
return aurora::downcast<MenuBarRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const MenuBarRenderer* MenuBar::getRenderer() const
{
return aurora::downcast<const MenuBarRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void MenuBar::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -524,7 +543,7 @@ namespace tgui
{
if (property == "textcolor")
{
m_textColorCached = getRenderer()->getTextColor();
m_textColorCached = getSharedRenderer()->getTextColor();
for (unsigned int i = 0; i < m_menus.size(); ++i)
{
@ -542,7 +561,7 @@ namespace tgui
}
else if (property == "selectedtextcolor")
{
m_selectedTextColorCached = getRenderer()->getSelectedTextColor();
m_selectedTextColorCached = getSharedRenderer()->getSelectedTextColor();
if (m_visibleMenu != -1)
{
@ -557,27 +576,27 @@ namespace tgui
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
}
else if (property == "textureitembackground")
{
m_spriteItemBackground.setTexture(getRenderer()->getTextureItemBackground());
m_spriteItemBackground.setTexture(getSharedRenderer()->getTextureItemBackground());
}
else if (property == "textureselecteditembackground")
{
m_spriteSelectedItemBackground.setTexture(getRenderer()->getTextureSelectedItemBackground());
m_spriteSelectedItemBackground.setTexture(getSharedRenderer()->getTextureSelectedItemBackground());
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "selectedbackgroundcolor")
{
m_selectedBackgroundColorCached = getRenderer()->getSelectedBackgroundColor();
m_selectedBackgroundColorCached = getSharedRenderer()->getSelectedBackgroundColor();
}
else if (property == "distancetoside")
{
m_distanceToSideCached = getRenderer()->getDistanceToSide();
m_distanceToSideCached = getSharedRenderer()->getDistanceToSide();
}
else if (property == "opacity")
{

59
src/TGUI/Widgets/MessageBox.cpp
View File

@ -24,24 +24,11 @@
#include <TGUI/Widgets/MessageBox.hpp>
#include <TGUI/Loading/Theme.hpp>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{1}},
{"bordercolor", sf::Color::Black},
{"titlecolor", sf::Color::Black},
{"titlebarcolor", sf::Color::White},
{"backgroundcolor", Color{230, 230, 230}},
{"distancetoside", 3.f},
{"paddingbetweenbuttons", 1.f},
{"textcolor", sf::Color::Black}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MessageBox::MessageBox()
@ -49,11 +36,7 @@ namespace tgui
m_type = "MessageBox";
m_renderer = aurora::makeCopied<MessageBoxRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
getRenderer()->getCloseButton()->propertyValuePairs["borders"] = {Borders{1}};
getRenderer()->getMaximizeButton()->propertyValuePairs["borders"] = {Borders{1}};
getRenderer()->getMinimizeButton()->propertyValuePairs["borders"] = {Borders{1}};
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
add(m_label, "#TGUI_INTERNAL$MessageBoxText#");
m_label->setTextSize(m_textSize);
@ -176,6 +159,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MessageBoxRenderer* MessageBox::getSharedRenderer()
{
return aurora::downcast<MessageBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const MessageBoxRenderer* MessageBox::getSharedRenderer() const
{
return aurora::downcast<const MessageBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MessageBoxRenderer* MessageBox::getRenderer()
{
return aurora::downcast<MessageBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const MessageBoxRenderer* MessageBox::getRenderer() const
{
return aurora::downcast<const MessageBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void MessageBox::setText(const sf::String& text)
{
m_label->setText(text);
@ -216,12 +227,10 @@ namespace tgui
void MessageBox::addButton(const sf::String& caption)
{
auto button = Button::create(caption);
button->setRenderer(getSharedRenderer()->getButton());
button->setTextSize(m_textSize);
button->connect("Pressed", [=]() { onButtonPress.emit(this, caption); });
if (!getRenderer()->getButton()->propertyValuePairs.empty())
button->setRenderer(getRenderer()->getButton());
add(button, "#TGUI_INTERNAL$MessageBoxButton:" + caption + "#");
m_buttons.push_back(button);
@ -309,11 +318,11 @@ namespace tgui
{
if (property == "textcolor")
{
m_label->getRenderer()->setTextColor(getRenderer()->getTextColor());
m_label->getRenderer()->setTextColor(getSharedRenderer()->getTextColor());
}
else if (property == "button")
{
const auto& renderer = getRenderer()->getButton();
const auto& renderer = getSharedRenderer()->getButton();
for (auto& button : m_buttons)
button->setRenderer(renderer);
}
@ -321,10 +330,10 @@ namespace tgui
{
ChildWindow::rendererChanged(property);
m_label->getRenderer()->setFont(m_fontCached);
m_label->setInheritedFont(m_fontCached);
for (auto& button : m_buttons)
button->getRenderer()->setFont(m_fontCached);
button->setInheritedFont(m_fontCached);
rearrange();
}

42
src/TGUI/Widgets/Panel.cpp
View File

@ -30,12 +30,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"bordercolor", sf::Color::Black},
{"backgroundcolor", sf::Color::Transparent}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Panel::Panel(const Layout2d& size)
@ -43,7 +37,7 @@ namespace tgui
m_type = "Panel";
m_renderer = aurora::makeCopied<PanelRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(size);
}
@ -67,6 +61,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PanelRenderer* Panel::getSharedRenderer()
{
return aurora::downcast<PanelRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const PanelRenderer* Panel::getSharedRenderer() const
{
return aurora::downcast<const PanelRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PanelRenderer* Panel::getRenderer()
{
return aurora::downcast<PanelRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const PanelRenderer* Panel::getRenderer() const
{
return aurora::downcast<const PanelRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Panel::setSize(const Layout2d& size)
{
m_bordersCached.updateParentSize(size.getValue());
@ -142,16 +164,16 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else
Group::rendererChanged(property);

34
src/TGUI/Widgets/Picture.cpp
View File

@ -36,7 +36,7 @@ namespace tgui
m_type = "Picture";
m_renderer = aurora::makeCopied<PictureRenderer>();
setRenderer(RendererData::create({}));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -68,6 +68,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PictureRenderer* Picture::getSharedRenderer()
{
return aurora::downcast<PictureRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const PictureRenderer* Picture::getSharedRenderer() const
{
return aurora::downcast<const PictureRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PictureRenderer* Picture::getRenderer()
{
return aurora::downcast<PictureRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const PictureRenderer* Picture::getRenderer() const
{
return aurora::downcast<const PictureRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Picture::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -148,7 +176,7 @@ namespace tgui
{
if (property == "texture")
{
const auto& texture = getRenderer()->getTexture();
const auto& texture = getSharedRenderer()->getTexture();
if (!m_sprite.isSet() && (getSize() == sf::Vector2f{0,0}))
setSize(texture.getImageSize());
@ -157,7 +185,7 @@ namespace tgui
}
else if (property == "ignoretransparentparts")
{
m_ignoreTransparentParts = getRenderer()->getIgnoreTransparentParts();
m_ignoreTransparentParts = getSharedRenderer()->getIgnoreTransparentParts();
}
else if (property == "opacity")
{

64
src/TGUI/Widgets/ProgressBar.cpp
View File

@ -30,16 +30,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"bordercolor", sf::Color::Black},
{"textcolor", sf::Color::Black},
{"textcolorfilled", sf::Color::White},
{"backgroundcolor", Color{245, 245, 245}},
{"fillcolor", Color{0, 110, 255}}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ProgressBar::ProgressBar()
@ -47,7 +37,7 @@ namespace tgui
m_type = "ProgressBar";
m_renderer = aurora::makeCopied<ProgressBarRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(160, 20);
}
@ -71,6 +61,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ProgressBarRenderer* ProgressBar::getSharedRenderer()
{
return aurora::downcast<ProgressBarRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ProgressBarRenderer* ProgressBar::getSharedRenderer() const
{
return aurora::downcast<const ProgressBarRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ProgressBarRenderer* ProgressBar::getRenderer()
{
return aurora::downcast<ProgressBarRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ProgressBarRenderer* ProgressBar::getRenderer() const
{
return aurora::downcast<const ProgressBarRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ProgressBar::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -269,43 +287,43 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if ((property == "textcolor") || (property == "textcolorfilled"))
{
m_textBack.setColor(getRenderer()->getTextColor());
m_textBack.setColor(getSharedRenderer()->getTextColor());
if (getRenderer()->getTextColorFilled().isSet())
m_textFront.setColor(getRenderer()->getTextColorFilled());
if (getSharedRenderer()->getTextColorFilled().isSet())
m_textFront.setColor(getSharedRenderer()->getTextColorFilled());
else
m_textFront.setColor(getRenderer()->getTextColor());
m_textFront.setColor(getSharedRenderer()->getTextColor());
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
}
else if (property == "texturefill")
{
m_spriteFill.setTexture(getRenderer()->getTextureFill());
m_spriteFill.setTexture(getSharedRenderer()->getTextureFill());
recalculateFillSize();
}
else if (property == "textstyle")
{
m_textBack.setStyle(getRenderer()->getTextStyle());
m_textFront.setStyle(getRenderer()->getTextStyle());
m_textBack.setStyle(getSharedRenderer()->getTextStyle());
m_textFront.setStyle(getSharedRenderer()->getTextStyle());
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "fillcolor")
{
m_fillColorCached = getRenderer()->getFillColor();
m_fillColorCached = getSharedRenderer()->getFillColor();
}
else if (property == "opacity")
{

221
src/TGUI/Widgets/RadioButton.cpp
View File

@ -29,21 +29,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{3}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"checkcolor", Color{60, 60, 60}},
{"checkcolorhover", sf::Color::Black},
{"textdistanceratio", 0.2f}
///TODO: Define default disabled colors
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RadioButton::RadioButton()
@ -51,7 +36,7 @@ namespace tgui
m_type = "RadioButton";
m_renderer = aurora::makeCopied<RadioButtonRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({24, 24});
}
@ -75,6 +60,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RadioButtonRenderer* RadioButton::getSharedRenderer()
{
return aurora::downcast<RadioButtonRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const RadioButtonRenderer* RadioButton::getSharedRenderer() const
{
return aurora::downcast<const RadioButtonRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RadioButtonRenderer* RadioButton::getRenderer()
{
return aurora::downcast<RadioButtonRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const RadioButtonRenderer* RadioButton::getRenderer() const
{
return aurora::downcast<const RadioButtonRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RadioButton::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -289,7 +302,7 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
m_bordersCached.updateParentSize(getSize());
updateTextureSizes();
}
@ -300,7 +313,7 @@ namespace tgui
}
else if (property == "textstyle")
{
m_textStyleCached = getRenderer()->getTextStyle();
m_textStyleCached = getSharedRenderer()->getTextStyle();
if (m_checked && m_textStyleCheckedCached.isSet())
m_text.setStyle(m_textStyleCheckedCached);
@ -309,7 +322,7 @@ namespace tgui
}
else if (property == "textstylechecked")
{
m_textStyleCheckedCached = getRenderer()->getTextStyleChecked();
m_textStyleCheckedCached = getSharedRenderer()->getTextStyleChecked();
if (m_checked && m_textStyleCheckedCached.isSet())
m_text.setStyle(m_textStyleCheckedCached);
@ -318,98 +331,98 @@ namespace tgui
}
else if (property == "textureunchecked")
{
m_spriteUnchecked.setTexture(getRenderer()->getTextureUnchecked());
m_spriteUnchecked.setTexture(getSharedRenderer()->getTextureUnchecked());
updateTextureSizes();
}
else if (property == "texturechecked")
{
m_spriteChecked.setTexture(getRenderer()->getTextureChecked());
m_spriteChecked.setTexture(getSharedRenderer()->getTextureChecked());
updateTextureSizes();
}
else if (property == "textureuncheckedhover")
{
m_spriteUncheckedHover.setTexture(getRenderer()->getTextureUncheckedHover());
m_spriteUncheckedHover.setTexture(getSharedRenderer()->getTextureUncheckedHover());
}
else if (property == "texturecheckedhover")
{
m_spriteCheckedHover.setTexture(getRenderer()->getTextureCheckedHover());
m_spriteCheckedHover.setTexture(getSharedRenderer()->getTextureCheckedHover());
}
else if (property == "textureuncheckeddisabled")
{
m_spriteUncheckedDisabled.setTexture(getRenderer()->getTextureUncheckedDisabled());
m_spriteUncheckedDisabled.setTexture(getSharedRenderer()->getTextureUncheckedDisabled());
}
else if (property == "texturecheckeddisabled")
{
m_spriteCheckedDisabled.setTexture(getRenderer()->getTextureCheckedDisabled());
m_spriteCheckedDisabled.setTexture(getSharedRenderer()->getTextureCheckedDisabled());
}
else if (property == "texturefocused")
{
m_spriteFocused.setTexture(getRenderer()->getTextureFocused());
m_spriteFocused.setTexture(getSharedRenderer()->getTextureFocused());
m_allowFocus = m_spriteFocused.isSet();
}
else if (property == "checkcolor")
{
m_checkColorCached = getRenderer()->getCheckColor();
m_checkColorCached = getSharedRenderer()->getCheckColor();
}
else if (property == "checkcolorhover")
{
m_checkColorHoverCached = getRenderer()->getCheckColorHover();
m_checkColorHoverCached = getSharedRenderer()->getCheckColorHover();
}
else if (property == "checkcolordisabled")
{
m_checkColorDisabledCached = getRenderer()->getCheckColorDisabled();
m_checkColorDisabledCached = getSharedRenderer()->getCheckColorDisabled();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "bordercolorhover")
{
m_borderColorHoverCached = getRenderer()->getBorderColorHover();
m_borderColorHoverCached = getSharedRenderer()->getBorderColorHover();
}
else if (property == "bordercolordisabled")
{
m_borderColorDisabledCached = getRenderer()->getBorderColorDisabled();
m_borderColorDisabledCached = getSharedRenderer()->getBorderColorDisabled();
}
else if (property == "bordercolorchecked")
{
m_borderColorCheckedCached = getRenderer()->getBorderColorChecked();
m_borderColorCheckedCached = getSharedRenderer()->getBorderColorChecked();
}
else if (property == "bordercolorcheckedhover")
{
m_borderColorCheckedHoverCached = getRenderer()->getBorderColorCheckedHover();
m_borderColorCheckedHoverCached = getSharedRenderer()->getBorderColorCheckedHover();
}
else if (property == "bordercolorcheckeddisabled")
{
m_borderColorCheckedDisabledCached = getRenderer()->getBorderColorCheckedDisabled();
m_borderColorCheckedDisabledCached = getSharedRenderer()->getBorderColorCheckedDisabled();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "backgroundcolorhover")
{
m_backgroundColorHoverCached = getRenderer()->getBackgroundColorHover();
m_backgroundColorHoverCached = getSharedRenderer()->getBackgroundColorHover();
}
else if (property == "backgroundcolordisabled")
{
m_backgroundColorDisabledCached = getRenderer()->getBackgroundColorDisabled();
m_backgroundColorDisabledCached = getSharedRenderer()->getBackgroundColorDisabled();
}
else if (property == "backgroundcolorchecked")
{
m_backgroundColorCheckedCached = getRenderer()->getBackgroundColorChecked();
m_backgroundColorCheckedCached = getSharedRenderer()->getBackgroundColorChecked();
}
else if (property == "backgroundcolorcheckedhover")
{
m_backgroundColorCheckedHoverCached = getRenderer()->getBackgroundColorCheckedHover();
m_backgroundColorCheckedHoverCached = getSharedRenderer()->getBackgroundColorCheckedHover();
}
else if (property == "backgroundcolorcheckeddisabled")
{
m_backgroundColorCheckedDisabledCached = getRenderer()->getBackgroundColorCheckedDisabled();
m_backgroundColorCheckedDisabledCached = getSharedRenderer()->getBackgroundColorCheckedDisabled();
}
else if (property == "textdistanceratio")
{
m_textDistanceRatioCached = getRenderer()->getTextDistanceRatio();
m_textDistanceRatioCached = getSharedRenderer()->getTextDistanceRatio();
}
else if (property == "opacity")
{
@ -448,12 +461,12 @@ namespace tgui
sf::Color RadioButton::getCurrentCheckColor() const
{
if (!m_enabled && getRenderer()->getCheckColorDisabled().isSet())
return getRenderer()->getCheckColorDisabled();
else if (m_mouseHover && getRenderer()->getCheckColorHover().isSet())
return getRenderer()->getCheckColorHover();
if (!m_enabled && getSharedRenderer()->getCheckColorDisabled().isSet())
return getSharedRenderer()->getCheckColorDisabled();
else if (m_mouseHover && getSharedRenderer()->getCheckColorHover().isSet())
return getSharedRenderer()->getCheckColorHover();
else
return getRenderer()->getCheckColor();
return getSharedRenderer()->getCheckColor();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -462,37 +475,37 @@ namespace tgui
{
if (m_checked)
{
if (!m_enabled && getRenderer()->getBackgroundColorCheckedDisabled().isSet())
return getRenderer()->getBackgroundColorCheckedDisabled();
else if (!m_enabled && getRenderer()->getBackgroundColorDisabled().isSet())
return getRenderer()->getBackgroundColorDisabled();
if (!m_enabled && getSharedRenderer()->getBackgroundColorCheckedDisabled().isSet())
return getSharedRenderer()->getBackgroundColorCheckedDisabled();
else if (!m_enabled && getSharedRenderer()->getBackgroundColorDisabled().isSet())
return getSharedRenderer()->getBackgroundColorDisabled();
else if (m_mouseHover)
{
if (getRenderer()->getBackgroundColorCheckedHover().isSet())
return getRenderer()->getBackgroundColorCheckedHover();
else if (getRenderer()->getBackgroundColorChecked().isSet())
return getRenderer()->getBackgroundColorChecked();
else if (getRenderer()->getBackgroundColorHover().isSet())
return getRenderer()->getBackgroundColorHover();
if (getSharedRenderer()->getBackgroundColorCheckedHover().isSet())
return getSharedRenderer()->getBackgroundColorCheckedHover();
else if (getSharedRenderer()->getBackgroundColorChecked().isSet())
return getSharedRenderer()->getBackgroundColorChecked();
else if (getSharedRenderer()->getBackgroundColorHover().isSet())
return getSharedRenderer()->getBackgroundColorHover();
else
return getRenderer()->getBackgroundColor();
return getSharedRenderer()->getBackgroundColor();
}
else
{
if (getRenderer()->getBackgroundColorChecked().isSet())
return getRenderer()->getBackgroundColorChecked();
if (getSharedRenderer()->getBackgroundColorChecked().isSet())
return getSharedRenderer()->getBackgroundColorChecked();
else
return getRenderer()->getBackgroundColor();
return getSharedRenderer()->getBackgroundColor();
}
}
else
{
if (!m_enabled && getRenderer()->getBackgroundColorDisabled().isSet())
return getRenderer()->getBackgroundColorDisabled();
else if (m_mouseHover && getRenderer()->getBackgroundColorHover().isSet())
return getRenderer()->getBackgroundColorHover();
if (!m_enabled && getSharedRenderer()->getBackgroundColorDisabled().isSet())
return getSharedRenderer()->getBackgroundColorDisabled();
else if (m_mouseHover && getSharedRenderer()->getBackgroundColorHover().isSet())
return getSharedRenderer()->getBackgroundColorHover();
else
return getRenderer()->getBackgroundColor();
return getSharedRenderer()->getBackgroundColor();
}
}
@ -502,37 +515,37 @@ namespace tgui
{
if (m_checked)
{
if (!m_enabled && getRenderer()->getBorderColorCheckedDisabled().isSet())
return getRenderer()->getBorderColorCheckedDisabled();
else if (!m_enabled && getRenderer()->getBorderColorDisabled().isSet())
return getRenderer()->getBorderColorDisabled();
if (!m_enabled && getSharedRenderer()->getBorderColorCheckedDisabled().isSet())
return getSharedRenderer()->getBorderColorCheckedDisabled();
else if (!m_enabled && getSharedRenderer()->getBorderColorDisabled().isSet())
return getSharedRenderer()->getBorderColorDisabled();
else if (m_mouseHover)
{
if (getRenderer()->getBorderColorCheckedHover().isSet())
return getRenderer()->getBorderColorCheckedHover();
else if (getRenderer()->getBorderColorChecked().isSet())
return getRenderer()->getBorderColorChecked();
else if (getRenderer()->getBorderColorHover().isSet())
return getRenderer()->getBorderColorHover();
if (getSharedRenderer()->getBorderColorCheckedHover().isSet())
return getSharedRenderer()->getBorderColorCheckedHover();
else if (getSharedRenderer()->getBorderColorChecked().isSet())
return getSharedRenderer()->getBorderColorChecked();
else if (getSharedRenderer()->getBorderColorHover().isSet())
return getSharedRenderer()->getBorderColorHover();
else
return getRenderer()->getBorderColor();
return getSharedRenderer()->getBorderColor();
}
else
{
if (getRenderer()->getBorderColorChecked().isSet())
return getRenderer()->getBorderColorChecked();
if (getSharedRenderer()->getBorderColorChecked().isSet())
return getSharedRenderer()->getBorderColorChecked();
else
return getRenderer()->getBorderColor();
return getSharedRenderer()->getBorderColor();
}
}
else
{
if (!m_enabled && getRenderer()->getBorderColorDisabled().isSet())
return getRenderer()->getBorderColorDisabled();
else if (m_mouseHover && getRenderer()->getBorderColorHover().isSet())
return getRenderer()->getBorderColorHover();
if (!m_enabled && getSharedRenderer()->getBorderColorDisabled().isSet())
return getSharedRenderer()->getBorderColorDisabled();
else if (m_mouseHover && getSharedRenderer()->getBorderColorHover().isSet())
return getSharedRenderer()->getBorderColorHover();
else
return getRenderer()->getBorderColor();
return getSharedRenderer()->getBorderColor();
}
}
@ -555,37 +568,37 @@ namespace tgui
{
if (m_checked)
{
if (!m_enabled && getRenderer()->getTextColorCheckedDisabled().isSet())
m_text.setColor(getRenderer()->getTextColorCheckedDisabled());
else if (!m_enabled && getRenderer()->getTextColorDisabled().isSet())
m_text.setColor(getRenderer()->getTextColorDisabled());
if (!m_enabled && getSharedRenderer()->getTextColorCheckedDisabled().isSet())
m_text.setColor(getSharedRenderer()->getTextColorCheckedDisabled());
else if (!m_enabled && getSharedRenderer()->getTextColorDisabled().isSet())
m_text.setColor(getSharedRenderer()->getTextColorDisabled());
else if (m_mouseHover)
{
if (getRenderer()->getTextColorCheckedHover().isSet())
m_text.setColor(getRenderer()->getTextColorCheckedHover());
else if (getRenderer()->getTextColorChecked().isSet())
m_text.setColor(getRenderer()->getTextColorChecked());
else if (getRenderer()->getTextColorHover().isSet())
m_text.setColor(getRenderer()->getTextColorHover());
if (getSharedRenderer()->getTextColorCheckedHover().isSet())
m_text.setColor(getSharedRenderer()->getTextColorCheckedHover());
else if (getSharedRenderer()->getTextColorChecked().isSet())
m_text.setColor(getSharedRenderer()->getTextColorChecked());
else if (getSharedRenderer()->getTextColorHover().isSet())
m_text.setColor(getSharedRenderer()->getTextColorHover());
else
m_text.setColor(getRenderer()->getTextColor());
m_text.setColor(getSharedRenderer()->getTextColor());
}
else
{
if (getRenderer()->getTextColorChecked().isSet())
m_text.setColor(getRenderer()->getTextColorChecked());
if (getSharedRenderer()->getTextColorChecked().isSet())
m_text.setColor(getSharedRenderer()->getTextColorChecked());
else
m_text.setColor(getRenderer()->getTextColor());
m_text.setColor(getSharedRenderer()->getTextColor());
}
}
else
{
if (!m_enabled && getRenderer()->getTextColorDisabled().isSet())
m_text.setColor(getRenderer()->getTextColorDisabled());
else if (m_mouseHover && getRenderer()->getTextColorHover().isSet())
m_text.setColor(getRenderer()->getTextColorHover());
if (!m_enabled && getSharedRenderer()->getTextColorDisabled().isSet())
m_text.setColor(getSharedRenderer()->getTextColorDisabled());
else if (m_mouseHover && getSharedRenderer()->getTextColorHover().isSet())
m_text.setColor(getSharedRenderer()->getTextColorHover());
else
m_text.setColor(getRenderer()->getTextColor());
m_text.setColor(getSharedRenderer()->getTextColor());
}
}

67
src/TGUI/Widgets/RangeSlider.cpp
View File

@ -29,17 +29,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"trackcolor", Color{245, 245, 245}},
{"trackcolorhover", Color{255, 255, 255}},
{"thumbcolor", Color{245, 245, 245}},
{"thumbcolorhover", Color{255, 255, 255}}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RangeSlider::RangeSlider()
@ -49,7 +38,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<RangeSliderRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(200, 16);
}
@ -78,6 +67,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RangeSliderRenderer* RangeSlider::getSharedRenderer()
{
return aurora::downcast<RangeSliderRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const RangeSliderRenderer* RangeSlider::getSharedRenderer() const
{
return aurora::downcast<const RangeSliderRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RangeSliderRenderer* RangeSlider::getRenderer()
{
return aurora::downcast<RangeSliderRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const RangeSliderRenderer* RangeSlider::getRenderer() const
{
return aurora::downcast<const RangeSliderRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RangeSlider::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -465,12 +482,12 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "texturetrack")
{
m_spriteTrack.setTexture(getRenderer()->getTextureTrack());
m_spriteTrack.setTexture(getSharedRenderer()->getTextureTrack());
if (m_spriteTrack.getTexture().getImageSize().x < m_spriteTrack.getTexture().getImageSize().y)
m_verticalImage = true;
@ -481,48 +498,48 @@ namespace tgui
}
else if (property == "texturetrackhover")
{
m_spriteTrackHover.setTexture(getRenderer()->getTextureTrackHover());
m_spriteTrackHover.setTexture(getSharedRenderer()->getTextureTrackHover());
}
else if (property == "texturethumb")
{
m_spriteThumb.setTexture(getRenderer()->getTextureThumb());
m_spriteThumb.setTexture(getSharedRenderer()->getTextureThumb());
setSize(m_size);
}
else if (property == "texturethumbhover")
{
m_spriteThumbHover.setTexture(getRenderer()->getTextureThumbHover());
m_spriteThumbHover.setTexture(getSharedRenderer()->getTextureThumbHover());
}
else if (property == "trackcolor")
{
m_trackColorCached = getRenderer()->getTrackColor();
m_trackColorCached = getSharedRenderer()->getTrackColor();
}
else if (property == "trackcolorhover")
{
m_trackColorHoverCached = getRenderer()->getTrackColorHover();
m_trackColorHoverCached = getSharedRenderer()->getTrackColorHover();
}
else if (property == "selectedtrackcolor")
{
m_selectedTrackColorCached = getRenderer()->getSelectedTrackColor();
m_selectedTrackColorCached = getSharedRenderer()->getSelectedTrackColor();
}
else if (property == "selectedtrackcolorhover")
{
m_selectedTrackColorHoverCached = getRenderer()->getSelectedTrackColorHover();
m_selectedTrackColorHoverCached = getSharedRenderer()->getSelectedTrackColorHover();
}
else if (property == "thumbcolor")
{
m_thumbColorCached = getRenderer()->getThumbColor();
m_thumbColorCached = getSharedRenderer()->getThumbColor();
}
else if (property == "thumbcolorhover")
{
m_thumbColorHoverCached = getRenderer()->getThumbColorHover();
m_thumbColorHoverCached = getSharedRenderer()->getThumbColorHover();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "bordercolorhover")
{
m_borderColorHoverCached = getRenderer()->getBorderColorHover();
m_borderColorHoverCached = getSharedRenderer()->getBorderColorHover();
}
else if (property == "opacity")
{

40
src/TGUI/Widgets/ScrollablePanel.cpp
View File

@ -31,12 +31,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"bordercolor", sf::Color::Black},
{"backgroundcolor", sf::Color::Transparent}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollablePanel::ScrollablePanel(const Layout2d& size, sf::Vector2f contentSize) :
@ -45,7 +39,7 @@ namespace tgui
m_type = "ScrollablePanel";
m_renderer = aurora::makeCopied<ScrollablePanelRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
// Rotate the horizontal scrollbar
m_horizontalScrollbar.setSize(m_horizontalScrollbar.getSize().y, m_horizontalScrollbar.getSize().x);
@ -72,6 +66,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollablePanelRenderer* ScrollablePanel::getSharedRenderer()
{
return aurora::downcast<ScrollablePanelRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ScrollablePanelRenderer* ScrollablePanel::getSharedRenderer() const
{
return aurora::downcast<const ScrollablePanelRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollablePanelRenderer* ScrollablePanel::getRenderer()
{
return aurora::downcast<ScrollablePanelRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ScrollablePanelRenderer* ScrollablePanel::getRenderer() const
{
return aurora::downcast<const ScrollablePanelRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ScrollablePanel::setSize(const Layout2d& size)
{
Panel::setSize(size);
@ -301,8 +323,8 @@ namespace tgui
{
if (property == "scrollbar")
{
m_verticalScrollbar.setRenderer(getRenderer()->getScrollbar());
m_horizontalScrollbar.setRenderer(getRenderer()->getScrollbar());
m_verticalScrollbar.setRenderer(getSharedRenderer()->getScrollbar());
m_horizontalScrollbar.setRenderer(getSharedRenderer()->getScrollbar());
}
else
Panel::rendererChanged(property);

73
src/TGUI/Widgets/Scrollbar.cpp
View File

@ -30,17 +30,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"trackcolor", Color{245, 245, 245}},
{"thumbcolor", Color{220, 220, 220}},
{"thumbcolorhover", Color{230, 230, 230}},
{"arrowbackgroundcolor", Color{245, 245, 245}},
{"arrowbackgroundcolorhover", Color{255, 255, 255}},
{"arrowcolor", Color{60, 60, 60}},
{"arrowcolorhover", Color{0, 0, 0}}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Scrollbar::Scrollbar()
@ -50,7 +39,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<ScrollbarRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(16, 160);
}
@ -74,6 +63,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollbarRenderer* Scrollbar::getSharedRenderer()
{
return aurora::downcast<ScrollbarRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ScrollbarRenderer* Scrollbar::getSharedRenderer() const
{
return aurora::downcast<const ScrollbarRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ScrollbarRenderer* Scrollbar::getRenderer()
{
return aurora::downcast<ScrollbarRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ScrollbarRenderer* Scrollbar::getRenderer() const
{
return aurora::downcast<const ScrollbarRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Scrollbar::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -680,71 +697,71 @@ namespace tgui
{
if (property == "texturetrack")
{
m_spriteTrack.setTexture(getRenderer()->getTextureTrack());
m_spriteTrack.setTexture(getSharedRenderer()->getTextureTrack());
setSize(m_size);
}
else if (property == "texturetrackhover")
{
m_spriteTrackHover.setTexture(getRenderer()->getTextureTrackHover());
m_spriteTrackHover.setTexture(getSharedRenderer()->getTextureTrackHover());
}
else if (property == "texturethumb")
{
m_spriteThumb.setTexture(getRenderer()->getTextureThumb());
m_spriteThumb.setTexture(getSharedRenderer()->getTextureThumb());
setSize(m_size);
}
else if (property == "texturethumbhover")
{
m_spriteThumbHover.setTexture(getRenderer()->getTextureThumbHover());
m_spriteThumbHover.setTexture(getSharedRenderer()->getTextureThumbHover());
}
else if (property == "texturearrowup")
{
m_spriteArrowUp.setTexture(getRenderer()->getTextureArrowUp());
m_spriteArrowUp.setTexture(getSharedRenderer()->getTextureArrowUp());
setSize(m_size);
}
else if (property == "texturearrowuphover")
{
m_spriteArrowUpHover.setTexture(getRenderer()->getTextureArrowUpHover());
m_spriteArrowUpHover.setTexture(getSharedRenderer()->getTextureArrowUpHover());
}
else if (property == "texturearrowdown")
{
m_spriteArrowDown.setTexture(getRenderer()->getTextureArrowDown());
m_spriteArrowDown.setTexture(getSharedRenderer()->getTextureArrowDown());
setSize(m_size);
}
else if (property == "texturearrowdownhover")
{
m_spriteArrowDownHover.setTexture(getRenderer()->getTextureArrowDownHover());
m_spriteArrowDownHover.setTexture(getSharedRenderer()->getTextureArrowDownHover());
}
else if (property == "trackcolor")
{
m_trackColorCached = getRenderer()->getTrackColor();
m_trackColorCached = getSharedRenderer()->getTrackColor();
}
else if (property == "trackcolorhover")
{
m_trackColorHoverCached = getRenderer()->getTrackColorHover();
m_trackColorHoverCached = getSharedRenderer()->getTrackColorHover();
}
else if (property == "thumbcolor")
{
m_thumbColorCached = getRenderer()->getThumbColor();
m_thumbColorCached = getSharedRenderer()->getThumbColor();
}
else if (property == "thumbcolorhover")
{
m_thumbColorHoverCached = getRenderer()->getThumbColorHover();
m_thumbColorHoverCached = getSharedRenderer()->getThumbColorHover();
}
else if (property == "arrowbackgroundcolor")
{
m_arrowBackgroundColorCached = getRenderer()->getArrowBackgroundColor();
m_arrowBackgroundColorCached = getSharedRenderer()->getArrowBackgroundColor();
}
else if (property == "arrowbackgroundcolorhover")
{
m_arrowBackgroundColorHoverCached = getRenderer()->getArrowBackgroundColorHover();
m_arrowBackgroundColorHoverCached = getSharedRenderer()->getArrowBackgroundColorHover();
}
else if (property == "arrowcolor")
{
m_arrowColorCached = getRenderer()->getArrowColor();
m_arrowColorCached = getSharedRenderer()->getArrowColor();
}
else if (property == "arrowcolorhover")
{
m_arrowColorHoverCached = getRenderer()->getArrowColorHover();
m_arrowColorHoverCached = getSharedRenderer()->getArrowColorHover();
}
else if (property == "opacity")
{

63
src/TGUI/Widgets/Slider.cpp
View File

@ -29,17 +29,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"bordercolor", Color{60, 60, 60}},
{"bordercolorhover", sf::Color::Black},
{"trackcolor", Color{245, 245, 245}},
{"trackcolorhover", Color{255, 255, 255}},
{"thumbcolor", Color{245, 245, 245}},
{"thumbcolorhover", Color{255, 255, 255}}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Slider::Slider()
@ -49,7 +38,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<SliderRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(200, 16);
}
@ -78,6 +67,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SliderRenderer* Slider::getSharedRenderer()
{
return aurora::downcast<SliderRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const SliderRenderer* Slider::getSharedRenderer() const
{
return aurora::downcast<const SliderRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SliderRenderer* Slider::getRenderer()
{
return aurora::downcast<SliderRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const SliderRenderer* Slider::getRenderer() const
{
return aurora::downcast<const SliderRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Slider::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -404,12 +421,12 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "texturetrack")
{
m_spriteTrack.setTexture(getRenderer()->getTextureTrack());
m_spriteTrack.setTexture(getSharedRenderer()->getTextureTrack());
if (m_spriteTrack.getTexture().getImageSize().x < m_spriteTrack.getTexture().getImageSize().y)
m_verticalImage = true;
@ -420,40 +437,40 @@ namespace tgui
}
else if (property == "texturetrackhover")
{
m_spriteTrackHover.setTexture(getRenderer()->getTextureTrackHover());
m_spriteTrackHover.setTexture(getSharedRenderer()->getTextureTrackHover());
}
else if (property == "texturethumb")
{
m_spriteThumb.setTexture(getRenderer()->getTextureThumb());
m_spriteThumb.setTexture(getSharedRenderer()->getTextureThumb());
setSize(m_size);
}
else if (property == "texturethumbhover")
{
m_spriteThumbHover.setTexture(getRenderer()->getTextureThumbHover());
m_spriteThumbHover.setTexture(getSharedRenderer()->getTextureThumbHover());
}
else if (property == "trackcolor")
{
m_trackColorCached = getRenderer()->getTrackColor();
m_trackColorCached = getSharedRenderer()->getTrackColor();
}
else if (property == "trackcolorhover")
{
m_trackColorHoverCached = getRenderer()->getTrackColorHover();
m_trackColorHoverCached = getSharedRenderer()->getTrackColorHover();
}
else if (property == "thumbcolor")
{
m_thumbColorCached = getRenderer()->getThumbColor();
m_thumbColorCached = getSharedRenderer()->getThumbColor();
}
else if (property == "thumbcolorhover")
{
m_thumbColorHoverCached = getRenderer()->getThumbColorHover();
m_thumbColorHoverCached = getSharedRenderer()->getThumbColorHover();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "bordercolorhover")
{
m_borderColorHoverCached = getRenderer()->getBorderColorHover();
m_borderColorHoverCached = getSharedRenderer()->getBorderColorHover();
}
else if (property == "opacity")
{

63
src/TGUI/Widgets/SpinButton.cpp
View File

@ -30,17 +30,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"bordercolor", sf::Color::Black},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"arrowcolor", Color{60, 60, 60}},
{"arrowcolorhover", sf::Color::Black},
{"spacebetweenarrows", 2.f}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SpinButton::SpinButton()
@ -48,7 +37,7 @@ namespace tgui
m_type = "SpinButton";
m_renderer = aurora::makeCopied<SpinButtonRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize(20, 42);
}
@ -77,6 +66,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SpinButtonRenderer* SpinButton::getSharedRenderer()
{
return aurora::downcast<SpinButtonRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const SpinButtonRenderer* SpinButton::getSharedRenderer() const
{
return aurora::downcast<const SpinButtonRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SpinButtonRenderer* SpinButton::getRenderer()
{
return aurora::downcast<SpinButtonRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const SpinButtonRenderer* SpinButton::getRenderer() const
{
return aurora::downcast<const SpinButtonRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -304,49 +321,49 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "spacebetweenarrows")
{
m_spaceBetweenArrowsCached = getRenderer()->getSpaceBetweenArrows();
m_spaceBetweenArrowsCached = getSharedRenderer()->getSpaceBetweenArrows();
setSize(m_size);
}
else if (property == "texturearrowup")
{
m_spriteArrowUp.setTexture(getRenderer()->getTextureArrowUp());
m_spriteArrowUp.setTexture(getSharedRenderer()->getTextureArrowUp());
}
else if (property == "texturearrowuphover")
{
m_spriteArrowUpHover.setTexture(getRenderer()->getTextureArrowUpHover());
m_spriteArrowUpHover.setTexture(getSharedRenderer()->getTextureArrowUpHover());
}
else if (property == "texturearrowdown")
{
m_spriteArrowDown.setTexture(getRenderer()->getTextureArrowDown());
m_spriteArrowDown.setTexture(getSharedRenderer()->getTextureArrowDown());
}
else if (property == "texturearrowdownhover")
{
m_spriteArrowDownHover.setTexture(getRenderer()->getTextureArrowDownHover());
m_spriteArrowDownHover.setTexture(getSharedRenderer()->getTextureArrowDownHover());
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "backgroundcolorhover")
{
m_backgroundColorHoverCached = getRenderer()->getBackgroundColorHover();
m_backgroundColorHoverCached = getSharedRenderer()->getBackgroundColorHover();
}
else if (property == "arrowcolor")
{
m_arrowColorCached = getRenderer()->getArrowColor();
m_arrowColorCached = getSharedRenderer()->getArrowColor();
}
else if (property == "arrowcolorhover")
{
m_arrowColorHoverCached = getRenderer()->getArrowColorHover();
m_arrowColorHoverCached = getSharedRenderer()->getArrowColorHover();
}
else if (property == "opacity")
{

70
src/TGUI/Widgets/Tabs.cpp
View File

@ -30,20 +30,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"bordercolor", sf::Color::Black},
{"textcolor", Color{60, 60, 60}},
{"textcolorhover", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"backgroundcolor", Color{245, 245, 245}},
{"backgroundcolorhover", sf::Color::White},
{"selectedbackgroundcolor", Color{0, 110, 255}},
{"selectedbackgroundcolorhover", Color{30, 150, 255}},
{"distancetoside", 1.f}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Tabs::Tabs()
@ -51,7 +37,7 @@ namespace tgui
m_type = "Tabs";
m_renderer = aurora::makeCopied<TabsRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setTabHeight(30);
}
@ -75,6 +61,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TabsRenderer* Tabs::getSharedRenderer()
{
return aurora::downcast<TabsRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const TabsRenderer* Tabs::getSharedRenderer() const
{
return aurora::downcast<const TabsRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TabsRenderer* Tabs::getRenderer()
{
return aurora::downcast<TabsRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const TabsRenderer* Tabs::getRenderer() const
{
return aurora::downcast<const TabsRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Tabs::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -473,61 +487,61 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
recalculateTabsWidth();
}
else if (property == "textcolor")
{
m_textColorCached = getRenderer()->getTextColor();
m_textColorCached = getSharedRenderer()->getTextColor();
updateTextColors();
}
else if (property == "textcolorhover")
{
m_textColorHoverCached = getRenderer()->getTextColorHover();
m_textColorHoverCached = getSharedRenderer()->getTextColorHover();
updateTextColors();
}
else if (property == "selectedtextcolor")
{
m_selectedTextColorCached = getRenderer()->getSelectedTextColor();
m_selectedTextColorCached = getSharedRenderer()->getSelectedTextColor();
updateTextColors();
}
else if (property == "selectedtextcolorhover")
{
m_selectedTextColorHoverCached = getRenderer()->getSelectedTextColorHover();
m_selectedTextColorHoverCached = getSharedRenderer()->getSelectedTextColorHover();
updateTextColors();
}
else if (property == "texturetab")
{
m_spriteTab.setTexture(getRenderer()->getTextureTab());
m_spriteTab.setTexture(getSharedRenderer()->getTextureTab());
}
else if (property == "textureselectedtab")
{
m_spriteSelectedTab.setTexture(getRenderer()->getTextureSelectedTab());
m_spriteSelectedTab.setTexture(getSharedRenderer()->getTextureSelectedTab());
}
else if (property == "distancetoside")
{
m_distanceToSideCached = getRenderer()->getDistanceToSide();
m_distanceToSideCached = getSharedRenderer()->getDistanceToSide();
recalculateTabsWidth();
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "backgroundcolorhover")
{
m_backgroundColorHoverCached = getRenderer()->getBackgroundColorHover();
m_backgroundColorHoverCached = getSharedRenderer()->getBackgroundColorHover();
}
else if (property == "selectedbackgroundcolor")
{
m_selectedBackgroundColorCached = getRenderer()->getSelectedBackgroundColor();
m_selectedBackgroundColorCached = getSharedRenderer()->getSelectedBackgroundColor();
}
else if (property == "selectedbackgroundcolorhover")
{
m_selectedBackgroundColorHoverCached = getRenderer()->getSelectedBackgroundColorHover();
m_selectedBackgroundColorHoverCached = getSharedRenderer()->getSelectedBackgroundColorHover();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "opacity")
{

73
src/TGUI/Widgets/TextBox.cpp
View File

@ -34,19 +34,6 @@
namespace tgui
{
static std::map<std::string, ObjectConverter> defaultRendererValues =
{
{"borders", Borders{2}},
{"padding", Padding{2, 0, 0, 0}},
{"caretwidth", 1.f},
{"caretcolor", sf::Color::Black},
{"bordercolor", sf::Color::Black},
{"textcolor", sf::Color::Black},
{"selectedtextcolor", sf::Color::White},
{"selectedtextbackgroundcolor", Color{0, 110, 255}},
{"backgroundcolor", sf::Color::White}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TextBox::TextBox()
@ -55,7 +42,7 @@ namespace tgui
m_draggableWidget = true;
m_renderer = aurora::makeCopied<TextBoxRenderer>();
setRenderer(RendererData::create(defaultRendererValues));
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
setSize({360, 189});
}
@ -79,6 +66,34 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TextBoxRenderer* TextBox::getSharedRenderer()
{
return aurora::downcast<TextBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const TextBoxRenderer* TextBox::getSharedRenderer() const
{
return aurora::downcast<const TextBoxRenderer*>(Widget::getSharedRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TextBoxRenderer* TextBox::getRenderer()
{
return aurora::downcast<TextBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const TextBoxRenderer* TextBox::getRenderer() const
{
return aurora::downcast<const TextBoxRenderer*>(Widget::getRenderer());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TextBox::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -1408,59 +1423,59 @@ namespace tgui
{
if (property == "borders")
{
m_bordersCached = getRenderer()->getBorders();
m_bordersCached = getSharedRenderer()->getBorders();
setSize(m_size);
}
else if (property == "padding")
{
m_paddingCached = getRenderer()->getPadding();
m_paddingCached = getSharedRenderer()->getPadding();
setSize(m_size);
}
else if (property == "textcolor")
{
m_textBeforeSelection.setColor(getRenderer()->getTextColor());
m_textAfterSelection1.setColor(getRenderer()->getTextColor());
m_textAfterSelection2.setColor(getRenderer()->getTextColor());
m_textBeforeSelection.setColor(getSharedRenderer()->getTextColor());
m_textAfterSelection1.setColor(getSharedRenderer()->getTextColor());
m_textAfterSelection2.setColor(getSharedRenderer()->getTextColor());
}
else if (property == "selectedtextcolor")
{
m_textSelection1.setColor(getRenderer()->getSelectedTextColor());
m_textSelection2.setColor(getRenderer()->getSelectedTextColor());
m_textSelection1.setColor(getSharedRenderer()->getSelectedTextColor());
m_textSelection2.setColor(getSharedRenderer()->getSelectedTextColor());
}
else if (property == "texturebackground")
{
m_spriteBackground.setTexture(getRenderer()->getTextureBackground());
m_spriteBackground.setTexture(getSharedRenderer()->getTextureBackground());
}
else if (property == "scrollbar")
{
m_verticalScroll.setRenderer(getRenderer()->getScrollbar());
m_verticalScroll.setRenderer(getSharedRenderer()->getScrollbar());
}
else if (property == "backgroundcolor")
{
m_backgroundColorCached = getRenderer()->getBackgroundColor();
m_backgroundColorCached = getSharedRenderer()->getBackgroundColor();
}
else if (property == "selectedtextbackgroundcolor")
{
m_selectedTextBackgroundColorCached = getRenderer()->getSelectedTextBackgroundColor();
m_selectedTextBackgroundColorCached = getSharedRenderer()->getSelectedTextBackgroundColor();
}
else if (property == "bordercolor")
{
m_borderColorCached = getRenderer()->getBorderColor();
m_borderColorCached = getSharedRenderer()->getBorderColor();
}
else if (property == "caretcolor")
{
m_caretColorCached = getRenderer()->getCaretColor();
m_caretColorCached = getSharedRenderer()->getCaretColor();
}
else if (property == "caretwidth")
{
m_caretWidthCached = getRenderer()->getCaretWidth();
m_caretWidthCached = getSharedRenderer()->getCaretWidth();
}
else if (property == "opacity")
{
Widget::rendererChanged(property);
m_verticalScroll.setInheritedOpacity(m_opacityCached);
m_spriteBackground.setOpacity(m_opacityCached);
m_verticalScroll.getRenderer()->setOpacity(m_opacityCached);
m_textBeforeSelection.setOpacity(m_opacityCached);
m_textAfterSelection1.setOpacity(m_opacityCached);
m_textAfterSelection2.setOpacity(m_opacityCached);

3
src/TGUI/Widgets/VerticalLayout.cpp
View File

@ -36,6 +36,9 @@ namespace tgui
BoxLayoutRatios{size}
{
m_type = "VerticalLayout";
m_renderer = aurora::makeCopied<BoxLayoutRenderer>();
setRenderer(Theme::getDefault()->getRendererNoThrow(m_type));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

19
tests/Animation.cpp
View File

@ -35,7 +35,8 @@ TEST_CASE("[Animation]") {
tgui::Widget::Ptr widget = tgui::ClickableWidget::create();
widget->setPosition(30, 15);
widget->setSize(120, 30);
widget->getRenderer()->setOpacity(0.9f);
widget->setInheritedOpacity(0.9f);
widget->getRenderer()->setOpacity(0.5f);
tgui::Panel::Ptr parent = tgui::Panel::create();
parent->setSize(480, 360);
@ -73,11 +74,11 @@ TEST_CASE("[Animation]") {
SECTION("showWithEffect") {
SECTION("Fade") {
widget->showWithEffect(tgui::ShowAnimationType::Fade, sf::milliseconds(300));
REQUIRE(widget->getRenderer()->getOpacity() == 0);
REQUIRE(widget->getInheritedOpacity() == 0);
widget->update(sf::milliseconds(100));
REQUIRE(tgui::compareFloats(widget->getRenderer()->getOpacity(), 0.3f));
REQUIRE(tgui::compareFloats(widget->getInheritedOpacity(), 0.3f));
widget->update(sf::milliseconds(200));
REQUIRE(widget->getRenderer()->getOpacity() == 0.9f);
REQUIRE(widget->getInheritedOpacity() == 0.9f);
}
SECTION("Scale") {
@ -132,15 +133,15 @@ TEST_CASE("[Animation]") {
widget->update(sf::milliseconds(100));
REQUIRE(widget->getPosition() == sf::Vector2f(30, 15));
REQUIRE(widget->getSize() == sf::Vector2f(120, 30));
REQUIRE(widget->getRenderer()->getOpacity() == 0.9f);
REQUIRE(widget->getInheritedOpacity() == 0.9f);
}
SECTION("hideWithEffect") {
SECTION("Fade") {
widget->hideWithEffect(tgui::ShowAnimationType::Fade, sf::milliseconds(300));
REQUIRE(widget->getRenderer()->getOpacity() == 0.9f);
REQUIRE(widget->getInheritedOpacity() == 0.9f);
widget->update(sf::milliseconds(100));
REQUIRE(tgui::compareFloats(widget->getRenderer()->getOpacity(), 0.6f));
REQUIRE(tgui::compareFloats(widget->getInheritedOpacity(), 0.6f));
}
SECTION("Scale") {
@ -185,14 +186,14 @@ TEST_CASE("[Animation]") {
widget->update(sf::milliseconds(200));
REQUIRE(widget->getPosition() == sf::Vector2f(30, 15));
REQUIRE(widget->getSize() == sf::Vector2f(120, 30));
REQUIRE(widget->getRenderer()->getOpacity() == 0.9f);
REQUIRE(widget->getInheritedOpacity() == 0.9f);
REQUIRE(!widget->isVisible());
// The widget no longer changes after the animation is over
widget->update(sf::milliseconds(100));
REQUIRE(widget->getPosition() == sf::Vector2f(30, 15));
REQUIRE(widget->getSize() == sf::Vector2f(120, 30));
REQUIRE(widget->getRenderer()->getOpacity() == 0.9f);
REQUIRE(widget->getInheritedOpacity() == 0.9f);
REQUIRE(!widget->isVisible());
}

10
tests/Container.cpp
View File

@ -257,11 +257,11 @@ TEST_CASE("[Container]")
container->setOpacity(0.7f);
REQUIRE(container->getOpacity() == 0.7f);
REQUIRE(widget1->getRenderer()->getOpacity() == 0.7f);
REQUIRE(widget2->getRenderer()->getOpacity() == 0.7f);
REQUIRE(widget3->getRenderer()->getOpacity() == 0.7f);
REQUIRE(widget4->getRenderer()->getOpacity() == 0.7f);
REQUIRE(widget5->getRenderer()->getOpacity() == 0.7f);
REQUIRE(widget1->getInheritedOpacity() == 0.7f);
REQUIRE(widget2->getInheritedOpacity() == 0.7f);
REQUIRE(widget3->getInheritedOpacity() == 0.7f);
REQUIRE(widget4->getInheritedOpacity() == 0.7f);
REQUIRE(widget5->getInheritedOpacity() == 0.7f);
}
// TODO: Events

67
tests/Loading/Theme.cpp
View File

@ -87,40 +87,62 @@ TEST_CASE("[Theme]")
SECTION("With widgets")
{
auto label1 = tgui::Label::create();
label1->getRenderer()->setTextColor("red");
REQUIRE(label1->getRenderer()->getTextColor() == sf::Color::Red);
SECTION("Using getSharedRenderer")
{
auto label1 = tgui::Label::create();
label1->getSharedRenderer()->setTextColor("red");
REQUIRE(label1->getSharedRenderer()->getTextColor() == sf::Color::Red);
label1->setRenderer(theme.getRenderer("label"));
REQUIRE(label1->getRenderer()->getTextColor() != sf::Color::Red);
label1->setRenderer(theme.getRenderer("label"));
REQUIRE(label1->getSharedRenderer()->getTextColor() != sf::Color::Red);
label1->getRenderer()->setTextColor("green");
REQUIRE(label1->getRenderer()->getTextColor() == sf::Color::Green);
label1->getSharedRenderer()->setTextColor("green");
REQUIRE(label1->getSharedRenderer()->getTextColor() == sf::Color::Green);
auto label2 = tgui::Label::create();
label2->getRenderer()->setTextColor("blue");
REQUIRE(label2->getRenderer()->getTextColor() == sf::Color::Blue);
auto label2 = tgui::Label::create();
label2->getSharedRenderer()->setTextColor("blue");
REQUIRE(label2->getSharedRenderer()->getTextColor() == sf::Color::Blue);
label2->setRenderer(theme.getRenderer("label"));
REQUIRE(label1->getRenderer()->getTextColor() == sf::Color::Green);
label2->setRenderer(theme.getRenderer("label"));
REQUIRE(label1->getSharedRenderer()->getTextColor() == sf::Color::Green);
label1->getRenderer()->setTextColor("yellow");
REQUIRE(label2->getRenderer()->getTextColor() == sf::Color::Yellow);
// Changing the renderer of one label affects the look of the other one
label1->getSharedRenderer()->setTextColor("yellow");
REQUIRE(label2->getSharedRenderer()->getTextColor() == sf::Color::Yellow);
}
SECTION("Using getRenderer")
{
auto label1 = tgui::Label::create();
label1->getRenderer()->setTextColor("red");
REQUIRE(label1->getRenderer()->getTextColor() == sf::Color::Red);
label1->setRenderer(theme.getRenderer("label"));
REQUIRE(label1->getRenderer()->getTextColor() != sf::Color::Red);
label1->getRenderer()->setTextColor("green");
REQUIRE(label1->getRenderer()->getTextColor() == sf::Color::Green);
auto label2 = tgui::Label::create();
label2->getRenderer()->setTextColor("blue");
REQUIRE(label2->getRenderer()->getTextColor() == sf::Color::Blue);
label2->setRenderer(theme.getRenderer("label"));
REQUIRE(label1->getRenderer()->getTextColor() == sf::Color::Green);
// Changing the renderer of one label does not affect the other one
label1->getRenderer()->setTextColor("yellow");
REQUIRE(label2->getRenderer()->getTextColor() != sf::Color::Yellow);
}
}
SECTION("Without widgets")
{
sf::Color defaultColor = tgui::LabelRenderer().getTextColor();
REQUIRE(tgui::LabelRenderer(theme.getRenderer("label")).getTextColor() != sf::Color::Cyan);
tgui::LabelRenderer(theme.getRenderer("label")).setTextColor(sf::Color::Cyan);
REQUIRE(tgui::LabelRenderer(theme.getRenderer("label")).getTextColor() == sf::Color::Cyan);
REQUIRE(theme.getRenderer("label")->propertyValuePairs["textcolor"].getColor() == sf::Color::Cyan);
tgui::LabelRenderer(theme.getRenderer("label")).setTextColor({});
REQUIRE(tgui::LabelRenderer(theme.getRenderer("label")).getTextColor() == defaultColor);
REQUIRE(theme.getRenderer("label")->propertyValuePairs["textcolor"].getColor() == defaultColor);
}
}
@ -148,6 +170,11 @@ TEST_CASE("[Theme]")
return retVal;
}
bool canLoad(const std::string&, const std::string&) override
{
return true;
}
std::map<sf::String, sf::String> retVal;
unsigned int preloadCount = 0;
unsigned int loadCount = 0;

4
tests/Widget.cpp
View File

@ -248,10 +248,10 @@ TEST_CASE("[Widget]")
renderer->setFont(nullptr);
REQUIRE(renderer->getFont() == nullptr);
// Inheriting the font does not change the renderer (but the widget will have a usable font)
tgui::Gui gui;
gui.add(widget);
REQUIRE(renderer->getFont() != nullptr);
REQUIRE(renderer->getFont().getId() == "");
REQUIRE(renderer->getFont() == nullptr);
}
SECTION("Non-existent property")

2
tests/Widgets/ChatBox.cpp
View File

@ -240,8 +240,6 @@ TEST_CASE("[ChatBox]")
renderer->setBorderColor({40, 50, 60});
renderer->setBorders({1, 2, 3, 4});
renderer->setPadding({5, 6, 7, 8});
REQUIRE(renderer->getScrollbar()->propertyValuePairs.size() == 0);
renderer->setScrollbar(scrollbarRenderer.getData());
}

2
tests/Widgets/ComboBox.cpp
View File

@ -284,8 +284,6 @@ TEST_CASE("[ComboBox]")
renderer->setBorders({1, 2, 3, 4});
renderer->setPadding({5, 6, 7, 8});
renderer->setTextStyle(sf::Text::Bold);
REQUIRE(renderer->getListBox()->propertyValuePairs.size() == 0);
renderer->setListBox(listBoxRenderer.getData());
}

2
tests/Widgets/ListBox.cpp
View File

@ -325,8 +325,6 @@ TEST_CASE("[ListBox]")
renderer->setPadding({5, 6, 7, 8});
renderer->setTextStyle(sf::Text::Bold);
renderer->setSelectedTextStyle(sf::Text::Italic);
REQUIRE(renderer->getScrollbar()->propertyValuePairs.size() == 0);
renderer->setScrollbar(scrollbarRenderer.getData());
}

2
tests/Widgets/MessageBox.cpp
View File

@ -95,8 +95,6 @@ TEST_CASE("[MessageBox]")
SECTION("functions")
{
renderer->setTextColor({10, 20, 30});
REQUIRE(renderer->getButton()->propertyValuePairs.size() == 0);
renderer->setButton(buttonsRenderer.getData());
}

2
tests/Widgets/TextBox.cpp
View File

@ -213,8 +213,6 @@ TEST_CASE("[TextBox]")
renderer->setBorders({1, 2, 3, 4});
renderer->setPadding({5, 6, 7, 8});
renderer->setCaretWidth(2);
REQUIRE(renderer->getScrollbar()->propertyValuePairs.size() == 0);
renderer->setScrollbar(scrollbarRenderer.getData());
}

13
themes/BabyBlue.txt
View File

@ -22,12 +22,13 @@ CheckBox {
}
ChildWindow {
TextureTitlebar = "BabyBlue.png" Part(317, 2, 62, 31) Middle(10, 0, 42, 31);
TitleColor = rgb(100, 100, 100);
BackgroundColor = rgb(230, 230, 230);
BorderColor = White;
Borders = (2, 0, 2, 2);
DistanceToSide = 3;
TextureTitlebar = "BabyBlue.png" Part(317, 2, 62, 31) Middle(10, 0, 42, 31);
TitleColor = rgb(100, 100, 100);
BackgroundColor = rgb(230, 230, 230);
BorderColor = White;
Borders = (2, 0, 2, 2);
DistanceToSide = 3;
PaddingBetweenButtons = 1;
CloseButton = {
Texture = "BabyBlue.png" Part(96, 2, 25, 25);

43
themes/Black.txt
View File

@ -22,27 +22,28 @@ Checkbox {
}
ChildWindow {
TextureTitlebar = "Black.png" Part(48, 154, 75, 25) Middle(25, 0, 25, 25);
TitleColor = rgb(190, 190, 190);
BackgroundColor = rgb( 80, 80, 80);
BorderColor = Black;
Borders = (1, 1, 1, 1);
DistanceToSide = 5;
CloseButton = {
Texture = "Black.png" Part(48, 179, 15, 15);
TextureHover = "Black.png" Part(63, 179, 15, 15);
TextureDown = "Black.png" Part(78, 179, 15, 15);
};
MaximizeButton = {
Texture = "Black.png" Part(48, 194, 15, 15);
TextureHover = "Black.png" Part(63, 194, 15, 15);
TextureDown = "Black.png" Part(78, 194, 15, 15);
};
MinimizeButton = {
Texture = "Black.png" Part(93, 194, 15, 15);
TextureHover = "Black.png" Part(108, 194, 15, 15);
TextureDown = "Black.png" Part(123, 194, 15, 15);
};
TextureTitlebar = "Black.png" Part(48, 154, 75, 25) Middle(25, 0, 25, 25);
TitleColor = rgb(190, 190, 190);
BackgroundColor = rgb( 80, 80, 80);
BorderColor = Black;
Borders = (1, 1, 1, 1);
DistanceToSide = 5;
PaddingBetweenButtons = 2;
CloseButton = {
Texture = "Black.png" Part(48, 179, 15, 15);
TextureHover = "Black.png" Part(63, 179, 15, 15);
TextureDown = "Black.png" Part(78, 179, 15, 15);
};
MaximizeButton = {
Texture = "Black.png" Part(48, 194, 15, 15);
TextureHover = "Black.png" Part(63, 194, 15, 15);
TextureDown = "Black.png" Part(78, 194, 15, 15);
};
MinimizeButton = {
Texture = "Black.png" Part(93, 194, 15, 15);
TextureHover = "Black.png" Part(108, 194, 15, 15);
TextureDown = "Black.png" Part(123, 194, 15, 15);
};
}
ComboBox {

2
themes/TransparentGrey.txt
View File

@ -33,6 +33,8 @@ ChildWindow {
BackgroundColor = rgba(180, 180, 180, 215);
BorderColor = rgba(240, 240, 240, 215);
Borders = (1, 1, 1, 1);
DistanceToSide = 3;
PaddingBetweenButtons = 1;
CloseButton = &Button;
MaximizeButton = &Button;
MinimizeButton = &Button;