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

Updated SpinButton code to use new renderer

0.8
Bruno Van de Velde 2016-07-28 16:06:13 +02:00
parent a3c0856d6e
commit dc5a7a71fa
26 changed files with 883 additions and 1060 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

252
include/TGUI/Renderers/SpinButtonRenderer.hpp Normal file
View File

@ -0,0 +1,252 @@
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2016 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef TGUI_SPIN_BUTTON_RENDERER_HPP
#define TGUI_SPIN_BUTTON_RENDERER_HPP
#include <TGUI/Renderers/WidgetRenderer.hpp>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace tgui
{
struct TGUI_API SpinButtonRenderer : public WidgetRenderer
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the size of the borders
///
/// @param borders Size of the borders
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setBorders(const Borders& borders);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the size of the borders
///
/// @return border size
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Borders getBorders() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the space that is left between the arrows
///
/// @param space The space between the arrows
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setSpaceBetweenArrows(float space);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the space that is left between the arrows
///
/// @return space between the arrows
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float getSpaceBetweenArrows() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the color of the background of the arrows
///
/// @param color New background color
///
/// Note that this color is ignored when you set an image as background.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setBackgroundColor(Color color);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the background color of the arrows
///
/// @return background color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color getBackgroundColor() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the background color of the arrows in the hover state (mouse standing on top of the spin button)
///
/// @param color New background color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setBackgroundColorHover(Color color);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the background color of the arrows in the hover state (mouse standing on top of the spin button)
///
/// @return background color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color getBackgroundColorHover() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the color of the arrows
///
/// @param color New arrow color
///
/// Note that this color is ignored when an up and down arrow texture were set.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setArrowColor(Color color);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the color of the arrows
///
/// @return arrow color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color getArrowColor() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the color of the arrows in the hover state (mouse standing on top of the spin button)
///
/// @param color New arrow color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setArrowColorHover(Color color);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the color of the arrows in the hover state (mouse standing on top of the spin button)
///
/// @return arrow color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color getArrowColorHover() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the color of the borders
///
/// @param color New border color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setBorderColor(Color color);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the color of the borders
///
/// @return Border color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Color getBorderColor() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the image that is used as the up arrow
///
/// @param texture The new up arrow texture
///
/// When this image and the down image are set, the arrow color property will be ignored.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextureArrowUp(const Texture& texture);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the image that is used as the up arrow
///
/// @return up arrow texture
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Texture& getTextureArrowUp() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the image that is used as the up arrow when the mouse is located on top of the spin button
///
/// @param texture The new up hover arrow texture
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextureArrowUpHover(const Texture& texture);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the image that is used as the up arrow when the mouse is located on top of the spin button
///
/// @return up hover arrow texture
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Texture& getTextureArrowUpHover() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the image that is used as the down arrow
///
/// @param texture The new down arrow texture
///
/// When this image and the up image are set, the arrow color property will be ignored.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextureArrowDown(const Texture& texture);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the image that is used as the up arrow
///
/// @return down arrow texture
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Texture& getTextureArrowDown() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the image that is used as the down arrow when the mouse is located on top of the spin button
///
/// @param texture The new down hover arrow texture
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextureArrowDownHover(const Texture& texture);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the image that is used as the down arrow when the mouse is located on top of the spin button
///
/// @return down hover arrow texture
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Texture& getTextureArrowDownHover() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#endif // TGUI_SPIN_BUTTON_RENDERER_HPP

8
include/TGUI/TGUI.hpp
View File

@ -41,8 +41,8 @@
#include <TGUI/Loading/WidgetLoader.hpp>
#include <TGUI/Loading/WidgetSaver.hpp>
#include <TGUI/Widgets/Button.hpp>/**
#include <TGUI/Widgets/Canvas.hpp>
#include <TGUI/Widgets/Button.hpp>
#include <TGUI/Widgets/Canvas.hpp>/**
#include <TGUI/Widgets/ChatBox.hpp>*/
#include <TGUI/Widgets/CheckBox.hpp>/**
#include <TGUI/Widgets/ChildWindow.hpp>*/
@ -60,8 +60,8 @@
#include <TGUI/Widgets/ProgressBar.hpp>
#include <TGUI/Widgets/RadioButton.hpp>/**
#include <TGUI/Widgets/Scrollbar.hpp>
#include <TGUI/Widgets/Slider.hpp>
#include <TGUI/Widgets/SpinButton.hpp>
#include <TGUI/Widgets/Slider.hpp>*/
#include <TGUI/Widgets/SpinButton.hpp>/**
#include <TGUI/Widgets/Tab.hpp>
#include <TGUI/Widgets/TextBox.hpp>
#include <TGUI/Widgets/ToolTip.hpp>*/

47
include/TGUI/Widgets/Canvas.hpp
View File

@ -93,22 +93,6 @@ namespace tgui
static Canvas::Ptr copy(Canvas::ConstPtr canvas);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets the position of the widget
///
/// This function completely overwrites the previous position.
/// See the move function to apply an offset based on the previous position instead.
/// The default position of a transformable widget is (0, 0).
///
/// @param position New position
///
/// @see move, getPosition
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setPosition(const Layout2d& position) override;
using Transformable::setPosition;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the size of the widget
///
@ -164,18 +148,25 @@ namespace tgui
void display();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the opacity of the widget
///
/// @param opacity The opacity of the widget. 0 means completely transparent, while 1 (default) means fully opaque
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setOpacity(float opacity) override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Function called when one of the properties of the renderer is changed
///
/// @param property Lowercase name of the property that was changed
/// @param value New value of the property
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void rendererChanged(const std::string& property, ObjectConverter& value) override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Draws the widget on the render target.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Makes a copy of the widget
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -185,12 +176,6 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Draws the widget on the render target.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected:

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

@ -27,14 +27,13 @@
#define TGUI_SPIN_BUTTON_HPP
#include <TGUI/Renderers/SpinButtonRenderer.hpp>
#include <TGUI/Widgets/ClickableWidget.hpp>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace tgui
{
class SpinButtonRenderer;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Spin button widget
///
@ -74,31 +73,15 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
///
/// @return Reference to the renderer
/// @return Temporary pointer to the renderer
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<SpinButtonRenderer> getRenderer() const
SpinButtonRenderer* getRenderer() const
{
return std::static_pointer_cast<SpinButtonRenderer>(m_renderer);
return aurora::downcast<SpinButtonRenderer*>(m_renderer.get());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets the position of the widget
///
/// This function completely overwrites the previous position.
/// See the move function to apply an offset based on the previous position instead.
/// The default position of a transformable widget is (0, 0).
///
/// @param position New position
///
/// @see move, getPosition
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setPosition(const Layout2d& position) override;
using Transformable::setPosition;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the size of the spin button
///
@ -109,17 +92,6 @@ namespace tgui
using Transformable::setSize;
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the full size of the spin button
///
/// The size returned by this function includes the borders.
///
/// @return Full size of the spin button
///
//////////////////////////////////////////////////////////////////////////////////////////////////////
virtual sf::Vector2f getFullSize() const override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets a minimum value
///
@ -132,6 +104,17 @@ namespace tgui
void setMinimum(int minimum);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the minimum value
///
/// @return The current minimum value
///
/// The default minimum value 0.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int getMinimum() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Sets a maximum value
///
@ -144,6 +127,17 @@ namespace tgui
void setMaximum(int maximum);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the maximum value
///
/// @return The current maximum value
///
/// The default maximum value 10.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int getMaximum() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the current value
///
@ -156,34 +150,6 @@ namespace tgui
void setValue(int value);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the minimum value
///
/// @return The current minimum value
///
/// The default minimum value 0.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int getMinimum() const
{
return m_minimum;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the maximum value
///
/// @return The current maximum value
///
/// The default maximum value 10.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int getMaximum() const
{
return m_maximum;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the current value
///
@ -192,10 +158,7 @@ namespace tgui
/// The default value is 0.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int getValue() const
{
return m_value;
}
int getValue() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -213,30 +176,7 @@ namespace tgui
/// @return Does the spin button lie vertically?
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool getVerticalScroll() const
{
return m_verticalScroll;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Changes the opacity of the widget
///
/// @param opacity The opacity of the widget. 0 means completely transparent, while 1 (default) means fully opaque
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setOpacity(float opacity) override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Returns the distance between the position where the widget is drawn and where the widget is placed
///
/// This is basically the width and height of the optional borders drawn around widgets.
///
/// @return Offset of the widget
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual sf::Vector2f getWidgetOffset() const override;
bool getVerticalScroll() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -264,18 +204,25 @@ namespace tgui
protected:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Reloads the widget
/// @brief Function called when one of the properties of the renderer is changed
///
/// @param primary Primary parameter for the loader
/// @param secondary Secondary parameter for the loader
/// @param force Try to only change the looks of the widget and not alter the widget itself when false
///
/// @throw Exception when the connected theme could not create the widget
///
/// When primary is an empty string the built-in white theme will be used.
/// @param property Lowercase name of the property that was changed
/// @param value New value of the property
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void reload(const std::string& primary = "", const std::string& secondary = "", bool force = false) override;
virtual void rendererChanged(const std::string& property, ObjectConverter& value) override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Returns the size of the arrows
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sf::Vector2f getArrowSize() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Draws the widget on the render target.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -287,12 +234,6 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Draws the widget on the render target.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected:
@ -310,7 +251,7 @@ namespace tgui
friend class SpinButtonRenderer;
};
/**
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class TGUI_API SpinButtonRenderer : public WidgetRenderer, public WidgetBorders
@ -557,7 +498,7 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
};
*/
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

5
src/TGUI/CMakeLists.txt
View File

@ -31,9 +31,10 @@ set(TGUI_SRC
Renderers/PanelRenderer.cpp
Renderers/ProgressBarRenderer.cpp
Renderers/RadioButtonRenderer.cpp
Renderers/SpinButtonRenderer.cpp
Renderers/WidgetRenderer.cpp
Widgets/Button.cpp
#Widgets/Canvas.cpp
Widgets/Canvas.cpp
#Widgets/ChatBox.cpp
Widgets/CheckBox.cpp
#Widgets/ChildWindow.cpp
@ -52,7 +53,7 @@ set(TGUI_SRC
Widgets/RadioButton.cpp
#Widgets/Scrollbar.cpp
#Widgets/Slider.cpp
#Widgets/SpinButton.cpp
Widgets/SpinButton.cpp
#Widgets/Tab.cpp
#Widgets/TextBox.cpp
#Widgets/ToolTip.cpp

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

@ -25,8 +25,8 @@
#include <TGUI/Loading/Deserializer.hpp>
#include <TGUI/Loading/WidgetLoader.hpp>
#include <TGUI/Widgets/Button.hpp>/**
#include <TGUI/Widgets/Canvas.hpp>
#include <TGUI/Widgets/Button.hpp>
#include <TGUI/Widgets/Canvas.hpp>/**
#include <TGUI/Widgets/ChatBox.hpp>*/
#include <TGUI/Widgets/CheckBox.hpp>/**
#include <TGUI/Widgets/ChildWindow.hpp>
@ -40,8 +40,8 @@
#include <TGUI/Widgets/ProgressBar.hpp>
#include <TGUI/Widgets/RadioButton.hpp>/**
#include <TGUI/Widgets/Scrollbar.hpp>
#include <TGUI/Widgets/Slider.hpp>
#include <TGUI/Widgets/SpinButton.hpp>
#include <TGUI/Widgets/Slider.hpp>*/
#include <TGUI/Widgets/SpinButton.hpp>/**
#include <TGUI/Widgets/Tab.hpp>
#include <TGUI/Widgets/TextBox.hpp>*/
@ -177,20 +177,6 @@ namespace tgui
rendererData->propertyValuePairs[pair.first] = {pair.second->value};
widget->setRenderer(rendererData);
/**
auto renderer = std::make_shared<WidgetRenderer>();
for (auto& pair : childNode->propertyValuePairs)
renderer->setProperty(pair.first, pair.second->value);
widget->setRenderer(renderer->getData());
*/
/**
widget->getRenderer()->getData()->propertyValuePairs = {};
for (auto& pair : childNode->propertyValuePairs)
widget->getRenderer()->setProperty(pair.first, pair.second->value);
*/
}
}
REMOVE_CHILD("renderer");
@ -244,7 +230,7 @@ namespace tgui
return button;
}
/**
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TGUI_API Widget::Ptr loadCanvas(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
@ -254,7 +240,7 @@ namespace tgui
else
return loadWidget(node, std::make_shared<Canvas>());
}
/**
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TGUI_API Widget::Ptr loadChatBox(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
@ -752,7 +738,7 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
*/
TGUI_API Widget::Ptr loadSpinButton(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
{
SpinButton::Ptr spinButton;
@ -775,7 +761,7 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
TGUI_API Widget::Ptr loadTab(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
{
Tab::Ptr tab;
@ -852,8 +838,8 @@ namespace tgui
// Using "std::shared_ptr<Widget>{}" instead of "nullptr" to work around internal compiler error with MinGW 4.7.1 TDM
{"widget", std::bind(loadWidget, std::placeholders::_1, std::shared_ptr<Widget>{})},
{"container", std::bind(loadContainer, std::placeholders::_1, std::shared_ptr<Container>{})},
{"button", std::bind(loadButton, std::placeholders::_1, std::shared_ptr<Button>{})},/**
{"canvas", std::bind(loadCanvas, std::placeholders::_1, std::shared_ptr<Canvas>{})},
{"button", std::bind(loadButton, std::placeholders::_1, std::shared_ptr<Button>{})},
{"canvas", std::bind(loadCanvas, std::placeholders::_1, std::shared_ptr<Canvas>{})},/**
{"chatbox", std::bind(loadChatBox, std::placeholders::_1, std::shared_ptr<ChatBox>{})},*/
{"checkbox", std::bind(loadCheckBox, std::placeholders::_1, std::shared_ptr<CheckBox>{})},/**
{"childwindow", std::bind(loadChildWindow, std::placeholders::_1, std::shared_ptr<ChildWindow>{})},*/
@ -866,10 +852,10 @@ namespace tgui
{"panel", std::bind(loadPanel, std::placeholders::_1, std::shared_ptr<Panel>{})},
{"picture", std::bind(loadPicture, std::placeholders::_1, std::shared_ptr<Picture>{})},
{"progressbar", std::bind(loadProgressBar, std::placeholders::_1, std::shared_ptr<ProgressBar>{})},
{"radiobutton", std::bind(loadRadioButton, std::placeholders::_1, std::shared_ptr<RadioButton>{})}/**,
{"radiobutton", std::bind(loadRadioButton, std::placeholders::_1, std::shared_ptr<RadioButton>{})},/**
{"scrollbar", std::bind(loadScrollbar, std::placeholders::_1, std::shared_ptr<Scrollbar>{})},
{"slider", std::bind(loadSlider, std::placeholders::_1, std::shared_ptr<Slider>{})},
{"spinbutton", std::bind(loadSpinButton, std::placeholders::_1, std::shared_ptr<SpinButton>{})},
{"slider", std::bind(loadSlider, std::placeholders::_1, std::shared_ptr<Slider>{})},*/
{"spinbutton", std::bind(loadSpinButton, std::placeholders::_1, std::shared_ptr<SpinButton>{})}/**,
{"tab", std::bind(loadTab, std::placeholders::_1, std::shared_ptr<Tab>{})},
{"textbox", std::bind(loadTextBox, std::placeholders::_1, std::shared_ptr<TextBox>{})}*/
};

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

@ -37,8 +37,8 @@
#include <TGUI/Widgets/ProgressBar.hpp>
#include <TGUI/Widgets/RadioButton.hpp>/**
#include <TGUI/Widgets/Scrollbar.hpp>
#include <TGUI/Widgets/Slider.hpp>
#include <TGUI/Widgets/SpinButton.hpp>
#include <TGUI/Widgets/Slider.hpp>*/
#include <TGUI/Widgets/SpinButton.hpp>/**
#include <TGUI/Widgets/Tab.hpp>
#include <TGUI/Widgets/TextBox.hpp>*/
@ -450,7 +450,7 @@ namespace tgui
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
*/
TGUI_API std::shared_ptr<DataIO::Node> saveSpinButton(SpinButton::Ptr spinButton)
{
auto node = saveWidget(spinButton);
@ -465,7 +465,7 @@ namespace tgui
SET_PROPERTY("Value", tgui::to_string(spinButton->getValue()));
return node;
}
/**
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TGUI_API std::shared_ptr<DataIO::Node> saveTab(Tab::Ptr tab)
@ -529,8 +529,8 @@ namespace tgui
{
{"widget", saveWidget},
{"container", saveContainer},
{"button", saveButton},/**
{"canvas", saveWidget},
{"button", saveButton},
{"canvas", saveWidget},/**
{"chatbox", saveChatBox},*/
{"checkbox", saveRadioButton},
{"clickablewidget", saveWidget},/**
@ -543,10 +543,10 @@ namespace tgui
{"panel", saveContainer},
{"picture", savePicture},
{"progressbar", saveProgressBar},
{"radiobutton", saveRadioButton}/**,
{"radiobutton", saveRadioButton},/**
{"scrollbar", saveScrollbar},
{"slider", saveSlider},
{"spinbutton", saveSpinButton},
{"slider", saveSlider},*/
{"spinbutton", saveSpinButton}/**,
{"tab", saveTab},
{"textbox", saveTextBox}*/
};

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

@ -39,7 +39,7 @@ namespace tgui
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, TextColorChecked, {})
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, TextColorCheckedHover, {})
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, TextColorCheckedDisabled, {})
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, BackgroundColor, sf::Color::Black)
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, BackgroundColor, sf::Color::White)
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, BackgroundColorHover, {})
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, BackgroundColorDisabled, {})
TGUI_RENDERER_PROPERTY_COLOR(RadioButtonRenderer, BackgroundColorChecked, {})

48
src/TGUI/Renderers/SpinButtonRenderer.cpp Normal file
View File

@ -0,0 +1,48 @@
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2016 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <TGUI/Renderers/SpinButtonRenderer.hpp>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace tgui
{
TGUI_RENDERER_PROPERTY_OUTLINE(SpinButtonRenderer, Borders)
TGUI_RENDERER_PROPERTY_NUMBER(SpinButtonRenderer, SpaceBetweenArrows, 0)
TGUI_RENDERER_PROPERTY_COLOR(SpinButtonRenderer, BackgroundColor, sf::Color::White)
TGUI_RENDERER_PROPERTY_COLOR(SpinButtonRenderer, BackgroundColorHover, {})
TGUI_RENDERER_PROPERTY_COLOR(SpinButtonRenderer, ArrowColor, sf::Color::Black)
TGUI_RENDERER_PROPERTY_COLOR(SpinButtonRenderer, ArrowColorHover, {})
TGUI_RENDERER_PROPERTY_COLOR(SpinButtonRenderer, BorderColor, sf::Color::Black)
TGUI_RENDERER_PROPERTY_TEXTURE(SpinButtonRenderer, TextureArrowUp)
TGUI_RENDERER_PROPERTY_TEXTURE(SpinButtonRenderer, TextureArrowUpHover)
TGUI_RENDERER_PROPERTY_TEXTURE(SpinButtonRenderer, TextureArrowDown)
TGUI_RENDERER_PROPERTY_TEXTURE(SpinButtonRenderer, TextureArrowDownHover)
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

5
src/TGUI/Texture.cpp
View File

@ -192,6 +192,8 @@ namespace tgui
m_size.x = std::max(size.x, 0.f);
m_size.y = std::max(size.y, 0.f);
setOrigin(std::min(m_size.x, m_size.y) / 2.0f, std::min(m_size.x, m_size.y) / 2.0f);
if (m_loaded)
updateVertices();
}
@ -219,7 +221,7 @@ namespace tgui
void Texture::setOpacity(float opacity)
{
m_opacity = opacity;
setColor(m_vertexColor);
setColor(getColor());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -515,6 +517,7 @@ namespace tgui
void Texture::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform.translate(getOrigin());
states.transform *= getTransform();
if (m_loaded)

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

@ -34,6 +34,7 @@ namespace tgui
Canvas::Canvas(const Layout2d& size)
{
m_callback.widgetType = "Canvas";
m_type = "Canvas";
setSize(size);
}
@ -60,7 +61,6 @@ namespace tgui
if (this != &right)
{
ClickableWidget::operator=(right);
setSize(right.getSize());
}
@ -79,15 +79,6 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Canvas::setPosition(const Layout2d& position)
{
Widget::setPosition(position);
m_sprite.setPosition(getPosition());
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Canvas::setSize(const Layout2d& size)
{
Widget::setSize(size);
@ -101,7 +92,7 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Canvas::clear(const Color& color)
void Canvas::clear(Color color)
{
m_renderTexture.clear(color);
}
@ -129,17 +120,19 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Canvas::setOpacity(float opacity)
void Canvas::rendererChanged(const std::string& property, ObjectConverter& value)
{
Widget::setOpacity(opacity);
m_sprite.setColor({255, 255, 255, static_cast<sf::Uint8>(m_opacity * 255)});
if (property == "opacity")
m_sprite.setColor(calcColorOpacity(sf::Color::White, value.getNumber()));
else
Widget::rendererChanged(property, value);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Canvas::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform.translate(getPosition());
target.draw(m_sprite, states);
}

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

@ -36,11 +36,19 @@ namespace tgui
SpinButton::SpinButton()
{
m_callback.widgetType = "SpinButton";
m_type = "SpinButton";
addSignal<int>("ValueChanged");
m_renderer = std::make_shared<SpinButtonRenderer>(this);
reload();
m_renderer = aurora::makeCopied<SpinButtonRenderer>();
setRenderer(m_renderer->getData());
getRenderer()->setBorders({2});
getRenderer()->setBackgroundColor({245, 245, 245});
getRenderer()->setBackgroundColorHover({255, 255, 255});
getRenderer()->setArrowColor({60, 60, 60});
getRenderer()->setArrowColorHover({0, 0, 0});
getRenderer()->setSpaceBetweenArrows(2);
setSize(20, 42);
}
@ -57,51 +65,15 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setPosition(const Layout2d& position)
{
Widget::setPosition(position);
if (m_verticalScroll)
{
getRenderer()->m_textureArrowUpNormal.setPosition(getPosition());
getRenderer()->m_textureArrowUpHover.setPosition(getPosition());
getRenderer()->m_textureArrowDownNormal.setPosition(getPosition().x, getPosition().y + getRenderer()->m_textureArrowUpNormal.getSize().y + getRenderer()->m_spaceBetweenArrows);
getRenderer()->m_textureArrowDownHover.setPosition(getPosition().x, getPosition().y + getRenderer()->m_textureArrowUpHover.getSize().y + getRenderer()->m_spaceBetweenArrows);
}
else // Horizontal orientation
{
getRenderer()->m_textureArrowUpNormal.setPosition(getPosition());
getRenderer()->m_textureArrowUpHover.setPosition(getPosition());
getRenderer()->m_textureArrowDownNormal.setPosition(getPosition().x + getRenderer()->m_textureArrowUpNormal.getSize().y + getRenderer()->m_spaceBetweenArrows, getPosition().y);
getRenderer()->m_textureArrowDownHover.setPosition(getPosition().x + getRenderer()->m_textureArrowUpHover.getSize().y + getRenderer()->m_spaceBetweenArrows, getPosition().y);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setSize(const Layout2d& size)
{
Widget::setSize(size);
if (m_verticalScroll)
getRenderer()->m_textureArrowUpNormal.setSize({getSize().x, (getSize().y - getRenderer()->m_spaceBetweenArrows) / 2.0f});
else
getRenderer()->m_textureArrowUpNormal.setSize({getSize().y, (getSize().x - getRenderer()->m_spaceBetweenArrows) / 2.0f});
getRenderer()->m_textureArrowUpHover.setSize(getRenderer()->m_textureArrowUpNormal.getSize());
getRenderer()->m_textureArrowDownNormal.setSize(getRenderer()->m_textureArrowUpNormal.getSize());
getRenderer()->m_textureArrowDownHover.setSize(getRenderer()->m_textureArrowUpNormal.getSize());
// Recalculate the position of the images
updatePosition();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sf::Vector2f SpinButton::getFullSize() const
{
return {getSize().x + getRenderer()->getBorders().left + getRenderer()->getBorders().right,
getSize().y + getRenderer()->getBorders().top + getRenderer()->getBorders().bottom};
sf::Vector2f arrowSize = getArrowSize();
getRenderer()->getTextureArrowUp().setSize(arrowSize);
getRenderer()->getTextureArrowUpHover().setSize(arrowSize);
getRenderer()->getTextureArrowDown().setSize(arrowSize);
getRenderer()->getTextureArrowDownHover().setSize(arrowSize);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -122,6 +94,13 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SpinButton::getMinimum() const
{
return m_minimum;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setMaximum(int maximum)
{
m_maximum = maximum;
@ -137,6 +116,13 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SpinButton::getMaximum() const
{
return m_maximum;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setValue(int value)
{
// When the value is below the minimum or above the maximum then adjust it
@ -156,23 +142,30 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SpinButton::getValue() const
{
return m_value;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setVerticalScroll(bool verticalScroll)
{
m_verticalScroll = verticalScroll;
if (verticalScroll)
{
getRenderer()->m_textureArrowUpNormal.setRotation(0);
getRenderer()->m_textureArrowUpHover.setRotation(0);
getRenderer()->m_textureArrowDownNormal.setRotation(0);
getRenderer()->m_textureArrowDownHover.setRotation(0);
getRenderer()->getTextureArrowUp().setRotation(0);
getRenderer()->getTextureArrowUpHover().setRotation(0);
getRenderer()->getTextureArrowDown().setRotation(0);
getRenderer()->getTextureArrowDownHover().setRotation(0);
}
else
{
getRenderer()->m_textureArrowUpNormal.setRotation(-90);
getRenderer()->m_textureArrowUpHover.setRotation(-90);
getRenderer()->m_textureArrowDownNormal.setRotation(-90);
getRenderer()->m_textureArrowDownHover.setRotation(-90);
getRenderer()->getTextureArrowUp().setRotation(-90);
getRenderer()->getTextureArrowUpHover().setRotation(-90);
getRenderer()->getTextureArrowDown().setRotation(-90);
getRenderer()->getTextureArrowDownHover().setRotation(-90);
}
updateSize();
@ -180,21 +173,9 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::setOpacity(float opacity)
bool SpinButton::getVerticalScroll() const
{
ClickableWidget::setOpacity(opacity);
getRenderer()->m_textureArrowUpNormal.setColor({255, 255, 255, static_cast<sf::Uint8>(m_opacity * 255)});
getRenderer()->m_textureArrowUpHover.setColor({255, 255, 255, static_cast<sf::Uint8>(m_opacity * 255)});
getRenderer()->m_textureArrowDownNormal.setColor({255, 255, 255, static_cast<sf::Uint8>(m_opacity * 255)});
getRenderer()->m_textureArrowDownHover.setColor({255, 255, 255, static_cast<sf::Uint8>(m_opacity * 255)});
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sf::Vector2f SpinButton::getWidgetOffset() const
{
return {getRenderer()->getBorders().left, getRenderer()->getBorders().top};
return m_verticalScroll;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -206,14 +187,14 @@ namespace tgui
// Check if the mouse is on top of the upper/right arrow
if (m_verticalScroll)
{
if (sf::FloatRect{getPosition().x - getRenderer()->getBorders().left, getPosition().y - getRenderer()->getBorders().top, getFullSize().x, getFullSize().y / 2.0f}.contains(x, y))
if (sf::FloatRect{getPosition().x, getPosition().y, getSize().x, getSize().y / 2.0f}.contains(x, y))
m_mouseDownOnTopArrow = true;
else
m_mouseDownOnTopArrow = false;
}
else
{
if (sf::FloatRect{getPosition().x - getRenderer()->getBorders().left, getPosition().y - getRenderer()->getBorders().top, getFullSize().x / 2.0f, getFullSize().y}.contains(x, y))
if (sf::FloatRect{getPosition().x, getPosition().y, getSize().x / 2.0f, getSize().y}.contains(x, y))
m_mouseDownOnTopArrow = false;
else
m_mouseDownOnTopArrow = true;
@ -224,8 +205,6 @@ namespace tgui
void SpinButton::leftMouseReleased(float x, float y)
{
ClickableWidget::leftMouseReleased(x, y);
// Check if the mouse went down on the spin button
if (m_mouseDown)
{
@ -261,6 +240,8 @@ namespace tgui
return;
}
}
ClickableWidget::leftMouseReleased(x, y);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -270,14 +251,14 @@ namespace tgui
// Check if the mouse is on top of the upper/right arrow
if (m_verticalScroll)
{
if (sf::FloatRect{getPosition().x - getRenderer()->getBorders().left, getPosition().y - getRenderer()->getBorders().top, getFullSize().x, getFullSize().y / 2.0f}.contains(x, y))
if (sf::FloatRect{getPosition().x, getPosition().y, getSize().x, getSize().y / 2.0f}.contains(x, y))
m_mouseHoverOnTopArrow = true;
else
m_mouseHoverOnTopArrow = false;
}
else
{
if (sf::FloatRect{getPosition().x - getRenderer()->getBorders().left, getPosition().y - getRenderer()->getBorders().top, getFullSize().x / 2.0f, getFullSize().y}.contains(x, y))
if (sf::FloatRect{getPosition().x, getPosition().y, getSize().x / 2.0f, getSize().y}.contains(x, y))
m_mouseHoverOnTopArrow = true;
else
m_mouseHoverOnTopArrow = false;
@ -297,458 +278,174 @@ namespace tgui
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::reload(const std::string& primary, const std::string& secondary, bool force)
void SpinButton::rendererChanged(const std::string& property, ObjectConverter& value)
{
getRenderer()->setBorders({2, 2, 2, 2});
getRenderer()->setBackgroundColorNormal({245, 245, 245});
getRenderer()->setBackgroundColorHover({255, 255, 255});
getRenderer()->setArrowColorNormal({60, 60, 60});
getRenderer()->setArrowColorHover({0, 0, 0});
getRenderer()->setBorderColor({0, 0, 0});
getRenderer()->setSpaceBetweenArrows(2);
getRenderer()->setArrowUpTexture({});
getRenderer()->setArrowDownTexture({});
getRenderer()->setArrowUpHoverTexture({});
getRenderer()->setArrowDownHoverTexture({});
if (m_theme && primary != "")
if ((property == "borders") || (property == "spacebetweenarrows"))
{
getRenderer()->setSpaceBetweenArrows(0);
getRenderer()->setBorders({0, 0, 0, 0});
Widget::reload(primary, secondary, force);
if (force)
{
// Use the size of the images when images were loaded
if (getRenderer()->m_textureArrowUpNormal.isLoaded() && getRenderer()->m_textureArrowDownNormal.isLoaded())
{
setSize({getRenderer()->m_textureArrowUpNormal.getSize().x,
getRenderer()->m_textureArrowUpNormal.getSize().y + getRenderer()->m_textureArrowDownNormal.getSize().y});
}
}
updateSize();
}
else if ((property == "texturearrowup") || (property == "texturearrowuphover") || (property == "texturearrowdown") || (property == "texturearrowdownhover"))
{
value.getTexture().setSize(getArrowSize());
value.getTexture().setOpacity(getRenderer()->getOpacity());
}
else if (property == "opacity")
{
float opacity = value.getNumber();
getRenderer()->getTextureArrowUp().setOpacity(opacity);
getRenderer()->getTextureArrowUpHover().setOpacity(opacity);
getRenderer()->getTextureArrowDown().setOpacity(opacity);
getRenderer()->getTextureArrowDownHover().setOpacity(opacity);
}
else if ((property != "bordercolor")
&& (property != "backgroundcolor")
&& (property != "backgroundcolorhover")
&& (property != "arrowcolor")
&& (property != "arrowcolorhover"))
{
Widget::rendererChanged(property, value);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sf::Vector2f SpinButton::getArrowSize() const
{
Borders borders = getRenderer()->getBorders();
if (m_verticalScroll)
return {getSize().x - borders.left - borders.right, (getSize().y - borders.top - borders.bottom - getRenderer()->getSpaceBetweenArrows()) / 2.0f};
else
return {getSize().y - borders.top - borders.bottom, (getSize().x - borders.left - borders.right - getRenderer()->getSpaceBetweenArrows()) / 2.0f};
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButton::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
getRenderer()->draw(target, states);
}
states.transform.translate(getPosition());
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setProperty(std::string property, const std::string& value)
{
property = toLower(property);
if (property == "borders")
setBorders(Deserializer::deserialize(ObjectConverter::Type::Borders, value).getBorders());
else if (property == "backgroundcolor")
setBackgroundColor(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "backgroundcolornormal")
setBackgroundColorNormal(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "backgroundcolorhover")
setBackgroundColorHover(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "arrowcolor")
setArrowColor(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "arrowcolornormal")
setArrowColorNormal(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "arrowcolorhover")
setArrowColorHover(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "bordercolor")
setBorderColor(Deserializer::deserialize(ObjectConverter::Type::Color, value).getColor());
else if (property == "arrowupimage")
setArrowUpTexture(Deserializer::deserialize(ObjectConverter::Type::Texture, value).getTexture());
else if (property == "arrowdownimage")
setArrowDownTexture(Deserializer::deserialize(ObjectConverter::Type::Texture, value).getTexture());
else if (property == "arrowuphoverimage")
setArrowUpHoverTexture(Deserializer::deserialize(ObjectConverter::Type::Texture, value).getTexture());
else if (property == "arrowdownhoverimage")
setArrowDownHoverTexture(Deserializer::deserialize(ObjectConverter::Type::Texture, value).getTexture());
else if (property == "spacebetweenarrows")
setSpaceBetweenArrows(tgui::stof(value));
else
WidgetRenderer::setProperty(property, value);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setProperty(std::string property, ObjectConverter&& value)
{
property = toLower(property);
if (value.getType() == ObjectConverter::Type::Borders)
// Draw the borders
Borders borders = getRenderer()->getBorders();
if (borders != Borders{0})
{
if (property == "borders")
setBorders(value.getBorders());
drawBorders(target, states, borders, getSize(), getRenderer()->getBorderColor());
states.transform.translate({borders.left, borders.top});
}
sf::Vector2f arrowSize = getArrowSize();
float spaceBetweenArrows = getRenderer()->getSpaceBetweenArrows();
// Draw the top/left arrow
if (getRenderer()->getTextureArrowUp().isLoaded() && getRenderer()->getTextureArrowDown().isLoaded())
{
if (m_mouseHover && m_mouseHoverOnTopArrow && getRenderer()->getTextureArrowUpHover().isLoaded())
getRenderer()->getTextureArrowUpHover().draw(target, states);
else
return WidgetRenderer::setProperty(property, std::move(value));
}
else if (value.getType() == ObjectConverter::Type::Color)
{
if (property == "backgroundcolor")
setBackgroundColor(value.getColor());
else if (property == "backgroundcolornormal")
setBackgroundColorNormal(value.getColor());
else if (property == "backgroundcolorhover")
setBackgroundColorHover(value.getColor());
else if (property == "arrowcolor")
setArrowColor(value.getColor());
else if (property == "arrowcolornormal")
setArrowColorNormal(value.getColor());
else if (property == "arrowcolorhover")
setArrowColorHover(value.getColor());
else if (property == "bordercolor")
setBorderColor(value.getColor());
else
WidgetRenderer::setProperty(property, std::move(value));
}
else if (value.getType() == ObjectConverter::Type::Texture)
{
if (property == "arrowupimage")
setArrowUpTexture(value.getTexture());
else if (property == "arrowdownimage")
setArrowDownTexture(value.getTexture());
else if (property == "arrowuphoverimage")
setArrowUpHoverTexture(value.getTexture());
else if (property == "arrowdownhoverimage")
setArrowDownHoverTexture(value.getTexture());
else
WidgetRenderer::setProperty(property, std::move(value));
}
else if (value.getType() == ObjectConverter::Type::Number)
{
if (property == "spacebetweenarrows")
setSpaceBetweenArrows(value.getNumber());
}
else
WidgetRenderer::setProperty(property, std::move(value));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ObjectConverter SpinButtonRenderer::getProperty(std::string property) const
{
property = toLower(property);
if (property == "borders")
return m_borders;
else if (property == "backgroundcolor")
return m_backgroundColorNormal;
else if (property == "backgroundcolornormal")
return m_backgroundColorNormal;
else if (property == "backgroundcolorhover")
return m_backgroundColorHover;
else if (property == "arrowcolor")
return m_arrowColorNormal;
else if (property == "arrowcolornormal")
return m_arrowColorNormal;
else if (property == "arrowcolorhover")
return m_arrowColorHover;
else if (property == "bordercolor")
return m_borderColor;
else if (property == "arrowupimage")
return m_textureArrowUpNormal;
else if (property == "arrowdownimage")
return m_textureArrowDownNormal;
else if (property == "arrowuphoverimage")
return m_textureArrowUpHover;
else if (property == "arrowdownhoverimage")
return m_textureArrowDownHover;
if (property == "spacebetweenarrows")
return m_spaceBetweenArrows;
else
return WidgetRenderer::getProperty(property);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::map<std::string, ObjectConverter> SpinButtonRenderer::getPropertyValuePairs() const
{
auto pairs = WidgetRenderer::getPropertyValuePairs();
if (m_textureArrowUpNormal.isLoaded() && m_textureArrowDownNormal.isLoaded())
{
pairs["ArrowUpImage"] = m_textureArrowUpNormal;
pairs["ArrowDownImage"] = m_textureArrowDownNormal;
if (m_textureArrowUpHover.isLoaded())
pairs["ArrowUpHoverImage"] = m_textureArrowUpHover;
if (m_textureArrowDownHover.isLoaded())
pairs["ArrowDownHoverImage"] = m_textureArrowDownHover;
getRenderer()->getTextureArrowUp().draw(target, states);
}
else
{
pairs["BackgroundColorNormal"] = m_backgroundColorNormal;
pairs["BackgroundColorHover"] = m_backgroundColorHover;
pairs["ArrowColorNormal"] = m_arrowColorNormal;
pairs["ArrowColorHover"] = m_arrowColorHover;
}
sf::ConvexShape arrow{3};
sf::RectangleShape arrowBack;
pairs["BorderColor"] = m_borderColor;
pairs["Borders"] = m_borders;
pairs["SpaceBetweenArrows"] = m_spaceBetweenArrows;
return pairs;
}
if (m_verticalScroll)
{
arrowBack.setSize(arrowSize);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
arrow.setPoint(0, {arrowBack.getSize().x / 5, arrowBack.getSize().y * 4/5});
arrow.setPoint(1, {arrowBack.getSize().x / 2, arrowBack.getSize().y / 5});
arrow.setPoint(2, {arrowBack.getSize().x * 4/5, arrowBack.getSize().y * 4/5});
}
else // Spin button lies horizontal
{
arrowBack.setSize({arrowSize.y, arrowSize.x});
void SpinButtonRenderer::setBackgroundColor(const Color& color)
{
setBackgroundColorNormal(color);
setBackgroundColorHover(color);
}
arrow.setPoint(0, {arrowBack.getSize().x * 4/5, arrowBack.getSize().y / 5});
arrow.setPoint(1, {arrowBack.getSize().x / 5, arrowBack.getSize().y / 2});
arrow.setPoint(2, {arrowBack.getSize().x * 4/5, arrowBack.getSize().y * 4/5});
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setBackgroundColorNormal(const Color& color)
{
m_backgroundColorNormal = color;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setBackgroundColorHover(const Color& color)
{
m_backgroundColorHover = color;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowColor(const Color& color)
{
setArrowColorNormal(color);
setArrowColorHover(color);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowColorNormal(const Color& color)
{
m_arrowColorNormal = color;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowColorHover(const Color& color)
{
m_arrowColorHover = color;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setBorderColor(const Color& color)
{
m_borderColor = color;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowUpTexture(const Texture& texture)
{
m_textureArrowUpNormal = texture;
if (m_textureArrowUpNormal.isLoaded())
{
m_textureArrowUpNormal.setColor({255, 255, 255, static_cast<sf::Uint8>(m_spinButton->getOpacity() * 255)});
if (m_textureArrowUpNormal.isLoaded() && m_textureArrowDownNormal.isLoaded())
m_spinButton->updateSize();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowDownTexture(const Texture& texture)
{
m_textureArrowDownNormal = texture;
if (m_textureArrowDownNormal.isLoaded())
{
m_textureArrowDownNormal.setColor({255, 255, 255, static_cast<sf::Uint8>(m_spinButton->getOpacity() * 255)});
if (m_textureArrowUpNormal.isLoaded() && m_textureArrowDownNormal.isLoaded())
m_spinButton->updateSize();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowUpHoverTexture(const Texture& texture)
{
m_textureArrowUpHover = texture;
if (m_textureArrowUpHover.isLoaded())
{
m_textureArrowUpHover.setColor({255, 255, 255, static_cast<sf::Uint8>(m_spinButton->getOpacity() * 255)});
if (m_textureArrowUpNormal.isLoaded() && m_textureArrowDownNormal.isLoaded())
m_spinButton->updateSize();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setArrowDownHoverTexture(const Texture& texture)
{
m_textureArrowDownHover = texture;
if (m_textureArrowDownHover.isLoaded())
{
m_textureArrowDownHover.setColor({255, 255, 255, static_cast<sf::Uint8>(m_spinButton->getOpacity() * 255)});
if (m_textureArrowUpNormal.isLoaded() && m_textureArrowDownNormal.isLoaded())
m_spinButton->updateSize();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::setSpaceBetweenArrows(float space)
{
m_spaceBetweenArrows = space;
m_spinButton->updateSize();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SpinButtonRenderer::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
sf::Vector2f position = m_spinButton->getPosition();
sf::Vector2f size = m_spinButton->getSize();
// Draw the arrows
if (m_textureArrowUpNormal.isLoaded() && m_textureArrowDownNormal.isLoaded())
{
if (m_spinButton->m_mouseHover && m_spinButton->m_mouseHoverOnTopArrow && m_textureArrowUpHover.isLoaded())
target.draw(m_textureArrowUpHover, states);
if (m_mouseHover && m_mouseHoverOnTopArrow)
{
arrowBack.setFillColor(calcColorOpacity(getRenderer()->getBackgroundColorHover(), getRenderer()->getOpacity()));
arrow.setFillColor(calcColorOpacity(getRenderer()->getArrowColorHover(), getRenderer()->getOpacity()));
}
else
target.draw(m_textureArrowUpNormal, states);
{
arrowBack.setFillColor(calcColorOpacity(getRenderer()->getBackgroundColor(), getRenderer()->getOpacity()));
arrow.setFillColor(calcColorOpacity(getRenderer()->getArrowColor(), getRenderer()->getOpacity()));
}
if (m_spinButton->m_mouseHover && !m_spinButton->m_mouseHoverOnTopArrow && m_textureArrowDownHover.isLoaded())
target.draw(m_textureArrowDownHover, states);
target.draw(arrowBack, states);
target.draw(arrow, states);
}
// Draw the space between the arrows (if there is space)
if (m_verticalScroll)
{
states.transform.translate({0, arrowSize.y});
if (spaceBetweenArrows > 0)
{
drawRectangleShape(target, states, {arrowSize.x, spaceBetweenArrows}, getRenderer()->getBorderColor());
states.transform.translate({0, spaceBetweenArrows});
}
}
else // Horizontal orientation
{
states.transform.translate({arrowSize.y, 0});
if (spaceBetweenArrows > 0)
{
drawRectangleShape(target, states, {spaceBetweenArrows, arrowSize.y}, getRenderer()->getBorderColor());
states.transform.translate({spaceBetweenArrows, 0});
}
}
// Draw the bottom/right arrow
if (getRenderer()->getTextureArrowUp().isLoaded() && getRenderer()->getTextureArrowDown().isLoaded())
{
if (m_mouseHover && !m_mouseHoverOnTopArrow && getRenderer()->getTextureArrowDownHover().isLoaded())
getRenderer()->getTextureArrowDownHover().draw(target, states);
else
target.draw(m_textureArrowDownNormal, states);
getRenderer()->getTextureArrowDown().draw(target, states);
}
else // There are no images
{
sf::ConvexShape arrow{3};
sf::RectangleShape arrowBack;
arrowBack.setPosition(position);
if (m_spinButton->m_mouseHover && m_spinButton->m_mouseHoverOnTopArrow)
if (m_verticalScroll)
{
arrowBack.setFillColor(calcColorOpacity(m_backgroundColorHover, m_spinButton->getOpacity()));
arrow.setFillColor(calcColorOpacity(m_arrowColorHover, m_spinButton->getOpacity()));
}
else
{
arrowBack.setFillColor(calcColorOpacity(m_backgroundColorNormal, m_spinButton->getOpacity()));
arrow.setFillColor(calcColorOpacity(m_arrowColorNormal, m_spinButton->getOpacity()));
}
arrowBack.setSize(arrowSize);
if (m_spinButton->m_verticalScroll)
{
arrowBack.setSize({size.x, (size.y - m_spaceBetweenArrows) / 2.0f});
arrow.setPoint(0, {arrowBack.getPosition().x + (arrowBack.getSize().x / 5), arrowBack.getPosition().y + (arrowBack.getSize().y * 4/5)});
arrow.setPoint(1, {arrowBack.getPosition().x + (arrowBack.getSize().x / 2), arrowBack.getPosition().y + (arrowBack.getSize().y / 5)});
arrow.setPoint(2, {arrowBack.getPosition().x + (arrowBack.getSize().x * 4/5), arrowBack.getPosition().y + (arrowBack.getSize().y * 4/5)});
arrow.setPoint(0, {arrowBack.getSize().x / 5, arrowBack.getSize().y / 5});
arrow.setPoint(1, {arrowBack.getSize().x / 2, arrowBack.getSize().y * 4/5});
arrow.setPoint(2, {arrowBack.getSize().x * 4/5, arrowBack.getSize().y / 5});
}
else // Spin button lies horizontal
{
arrowBack.setSize({(size.x - m_spaceBetweenArrows) / 2.0f, size.y});
arrowBack.setSize({arrowSize.y, arrowSize.x});
arrow.setPoint(0, {arrowBack.getPosition().x + (arrowBack.getSize().x * 4/5), arrowBack.getPosition().y + (arrowBack.getSize().y / 5)});
arrow.setPoint(1, {arrowBack.getPosition().x + (arrowBack.getSize().x / 5), arrowBack.getPosition().y + (arrowBack.getSize().y / 2)});
arrow.setPoint(2, {arrowBack.getPosition().x + (arrowBack.getSize().x * 4/5), arrowBack.getPosition().y + (arrowBack.getSize().y * 4/5)});
arrow.setPoint(0, {arrowBack.getSize().x / 5, arrowBack.getSize().y / 5});
arrow.setPoint(1, {arrowBack.getSize().x * 4/5, arrowBack.getSize().y / 2});
arrow.setPoint(2, {arrowBack.getSize().x / 5, arrowBack.getSize().y * 4/5});
}
target.draw(arrowBack, states);
target.draw(arrow, states);
if (m_spinButton->m_mouseHover && !m_spinButton->m_mouseHoverOnTopArrow)
if (m_mouseHover && !m_mouseHoverOnTopArrow)
{
arrowBack.setFillColor(calcColorOpacity(m_backgroundColorHover, m_spinButton->getOpacity()));
arrow.setFillColor(calcColorOpacity(m_arrowColorHover, m_spinButton->getOpacity()));
arrowBack.setFillColor(calcColorOpacity(getRenderer()->getBackgroundColorHover(), getRenderer()->getOpacity()));
arrow.setFillColor(calcColorOpacity(getRenderer()->getArrowColorHover(), getRenderer()->getOpacity()));
}
else
{
arrowBack.setFillColor(calcColorOpacity(m_backgroundColorNormal, m_spinButton->getOpacity()));
arrow.setFillColor(calcColorOpacity(m_arrowColorNormal, m_spinButton->getOpacity()));
}
if (m_spinButton->m_verticalScroll)
{
arrowBack.move({0, arrowBack.getSize().y + m_spaceBetweenArrows});
arrow.setPoint(0, {arrowBack.getPosition().x + (arrowBack.getSize().x / 5), arrowBack.getPosition().y + (arrowBack.getSize().y / 5)});
arrow.setPoint(1, {arrowBack.getPosition().x + (arrowBack.getSize().x / 2), arrowBack.getPosition().y + (arrowBack.getSize().y * 4/5)});
arrow.setPoint(2, {arrowBack.getPosition().x + (arrowBack.getSize().x * 4/5), arrowBack.getPosition().y + (arrowBack.getSize().y / 5)});
}
else // Spin button lies horizontal
{
arrowBack.move({arrowBack.getSize().x + m_spaceBetweenArrows, 0});
arrow.setPoint(0, {arrowBack.getPosition().x + (arrowBack.getSize().x / 5), arrowBack.getPosition().y + (arrowBack.getSize().y / 5)});
arrow.setPoint(1, {arrowBack.getPosition().x + (arrowBack.getSize().x * 4/5), arrowBack.getPosition().y + (arrowBack.getSize().y / 2)});
arrow.setPoint(2, {arrowBack.getPosition().x + (arrowBack.getSize().x / 5), arrowBack.getPosition().y + (arrowBack.getSize().y * 4/5)});
arrowBack.setFillColor(calcColorOpacity(getRenderer()->getBackgroundColor(), getRenderer()->getOpacity()));
arrow.setFillColor(calcColorOpacity(getRenderer()->getArrowColor(), getRenderer()->getOpacity()));
}
target.draw(arrowBack, states);
target.draw(arrow, states);
}
// Draw the space between the arrows if needed
if (m_spaceBetweenArrows > 0)
{
sf::RectangleShape space;
if (m_spinButton->m_verticalScroll)
{
space.setSize({size.x, m_spaceBetweenArrows});
space.setPosition(position.x, position.y + (size.y - m_spaceBetweenArrows) / 2.0f);
}
else // The spin button lies horizontal
{
space.setSize({m_spaceBetweenArrows, size.y});
space.setPosition(position.x + (size.x - m_spaceBetweenArrows) / 2.0f, position.y);
}
space.setFillColor(calcColorOpacity(m_borderColor, m_spinButton->getOpacity()));
target.draw(space, states);
}
// Draw the borders around the spin button
if (m_borders != Borders{0, 0, 0, 0})
{
// Draw left border
sf::RectangleShape border({m_borders.left, size.y + m_borders.top});
border.setPosition(position.x - m_borders.left, position.y - m_borders.top);
border.setFillColor(calcColorOpacity(m_borderColor, m_spinButton->getOpacity()));
target.draw(border, states);
// Draw top border
border.setSize({size.x + m_borders.right, m_borders.top});
border.setPosition(position.x, position.y - m_borders.top);
target.draw(border, states);
// Draw right border
border.setSize({m_borders.right, size.y + m_borders.bottom});
border.setPosition(position.x + size.x, position.y);
target.draw(border, states);
// Draw bottom border
border.setSize({size.x + m_borders.left, m_borders.bottom});
border.setPosition(position.x - m_borders.left, position.y + size.y);
target.draw(border, states);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<WidgetRenderer> SpinButtonRenderer::clone(Widget* widget)
{
auto renderer = std::make_shared<SpinButtonRenderer>(*this);
renderer->m_spinButton = static_cast<SpinButton*>(widget);
return renderer;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

4
tests/CMakeLists.txt
View File

@ -21,7 +21,7 @@ set(TEST_SOURCES
Loading/Theme.cpp
Loading/ThemeLoader.cpp
Widgets/Button.cpp
#Widgets/Canvas.cpp
Widgets/Canvas.cpp
#Widgets/ChatBox.cpp
Widgets/CheckBox.cpp
#Widgets/ChildWindow.cpp
@ -39,7 +39,7 @@ set(TEST_SOURCES
Widgets/RadioButton.cpp
#Widgets/Scrollbar.cpp
#Widgets/Slider.cpp
#Widgets/SpinButton.cpp
Widgets/SpinButton.cpp
#Widgets/Tab.cpp
#Widgets/TextBox.cpp
#Widgets/ToolTip.cpp

58
tests/Tests.hpp
View File

@ -40,26 +40,58 @@ void testClickableWidgetSignals(tgui::ClickableWidget::Ptr widget);
void testWidgetRenderer(tgui::WidgetRenderer* renderer);
void testSavingWidget(std::string name, tgui::Widget::Ptr widget);
template <typename WidgetType>
void copy(std::shared_ptr<tgui::Container> parent, std::shared_ptr<WidgetType> widget)
void testSavingWidget(std::string name, std::shared_ptr<WidgetType> widget, bool loadFromTheme = true)
{
REQUIRE(WidgetType::copy(nullptr) == nullptr);
if (loadFromTheme)
{
tgui::Theme theme{"resources/Black.txt"};
widget->setRenderer(theme.getRenderer(name));
}
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(widget);
REQUIRE_NOTHROW(parent->saveWidgetsToFile(name + "WidgetFile1.txt"));
parent->removeAllWidgets();
parent = std::make_shared<tgui::GuiContainer>();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile(name + "WidgetFile1.txt"));
// Copy constructor
WidgetType temp1(*widget);
REQUIRE_NOTHROW(parent->saveWidgetsToFile(name + "WidgetFile2.txt"));
REQUIRE(compareFiles(name + "WidgetFile1.txt", name + "WidgetFile2.txt"));
// Assignment operator
WidgetType temp2;
temp2 = temp1;
SECTION("Copying widget")
{
// Copy constructor
WidgetType temp1(*widget);
// Move constructor
WidgetType temp3 = std::move(temp2);
// Assignment operator
WidgetType temp2;
temp2 = temp1;
// Move assignment operator
WidgetType temp4;
temp4 = std::move(temp3);
// Move constructor
WidgetType temp3 = std::move(temp2);
parent->add(WidgetType::copy(std::make_shared<WidgetType>(temp4)));
// Move assignment operator
WidgetType temp4;
temp4 = std::move(temp3);
// copy function
std::shared_ptr<WidgetType> temp5 = std::make_shared<WidgetType>(temp4);
tgui::Widget::Ptr temp6 = WidgetType::copy(temp5);
REQUIRE(temp6 != nullptr);
REQUIRE(WidgetType::copy(nullptr) == nullptr);
// clone function
tgui::Widget::Ptr temp7 = temp6->clone();
parent = std::make_shared<tgui::GuiContainer>();
parent->add(temp7);
REQUIRE_NOTHROW(parent->saveWidgetsToFile(name + "WidgetFile2.txt"));
REQUIRE(compareFiles(name + "WidgetFile1.txt", name + "WidgetFile2.txt"));
}
}

24
tests/Widgets/Button.cpp
View File

@ -66,7 +66,7 @@ TEST_CASE("[Button]")
REQUIRE(button->getTextSize() == 25);
}
SECTION("Events")
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
@ -274,29 +274,9 @@ TEST_CASE("[Button]")
SECTION("Saving and loading from file")
{
tgui::Theme theme{"resources/Black.txt"};
button->setRenderer(theme.getRenderer("button"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(button);
button->setText("SomeText");
button->setTextSize(25);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileButton1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileButton1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileButton2.txt"));
REQUIRE(compareFiles("WidgetFileButton1.txt", "WidgetFileButton2.txt"));
SECTION("Copying widget")
{
copy(parent, button);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileButton2.txt"));
REQUIRE(compareFiles("WidgetFileButton1.txt", "WidgetFileButton2.txt"));
}
testSavingWidget("Button", button);
}
}

40
tests/Widgets/Canvas.cpp
View File

@ -25,44 +25,28 @@
#include "../Tests.hpp"
#include <TGUI/Widgets/Canvas.hpp>
TEST_CASE("[Canvas]") {
TEST_CASE("[Canvas]")
{
tgui::Canvas::Ptr canvas = std::make_shared<tgui::Canvas>();
canvas->setFont("resources/DroidSansArmenian.ttf");
canvas->getRenderer()->setFont("resources/DroidSansArmenian.ttf");
SECTION("WidgetType") {
SECTION("WidgetType")
{
REQUIRE(canvas->getWidgetType() == "Canvas");
}
SECTION("constructor") {
SECTION("constructor")
{
canvas = std::make_shared<tgui::Canvas>(200.f, 100.f);
REQUIRE(canvas->getSize() == sf::Vector2f(200, 100));
}
SECTION("Saving and loading from file") {
testWidgetRenderer(canvas->getRenderer());
SECTION("Saving and loading from file")
{
REQUIRE_NOTHROW(canvas = std::make_shared<tgui::Canvas>(60.f, 40.f));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(canvas);
canvas->setOpacity(0.8f);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileCanvas1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileCanvas1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileCanvas2.txt"));
REQUIRE(compareFiles("WidgetFileCanvas1.txt", "WidgetFileCanvas2.txt"));
SECTION("Copying widget") {
tgui::Canvas temp;
temp = *canvas;
parent->removeAllWidgets();
parent->add(tgui::Canvas::copy(std::make_shared<tgui::Canvas>(temp)));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileCanvas2.txt"));
REQUIRE(compareFiles("WidgetFileCanvas1.txt", "WidgetFileCanvas2.txt"));
}
testSavingWidget("Canvas", canvas, false);
}
}

54
tests/Widgets/CheckBox.cpp
View File

@ -165,7 +165,7 @@ TEST_CASE("[CheckBox]")
REQUIRE(!checkBox->isChecked());
}
SECTION("Events")
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
@ -182,19 +182,27 @@ TEST_CASE("[CheckBox]")
checkBox->connect("Checked", genericCallback, std::ref(checkCount));
checkBox->connect("Unchecked", genericCallback, std::ref(uncheckCount));
checkBox->leftMousePressed(65, 60);
REQUIRE(checkCount == 0);
REQUIRE(uncheckCount == 0);
checkBox->leftMouseReleased(65, 60);
checkBox->check();
REQUIRE(checkCount == 1);
REQUIRE(uncheckCount == 0);
checkBox->leftMousePressed(65, 60);
checkBox->leftMouseReleased(65, 60);
checkBox->uncheck();
REQUIRE(checkCount == 1);
REQUIRE(uncheckCount == 1);
checkBox->leftMousePressed(65, 60);
REQUIRE(checkCount == 1);
REQUIRE(uncheckCount == 1);
checkBox->leftMouseReleased(65, 60);
REQUIRE(checkCount == 2);
REQUIRE(uncheckCount == 1);
checkBox->leftMousePressed(65, 60);
checkBox->leftMouseReleased(65, 60);
REQUIRE(checkCount == 2);
REQUIRE(uncheckCount == 2);
SECTION("Key pressed")
{
sf::Event::KeyEvent keyEvent;
@ -205,44 +213,24 @@ TEST_CASE("[CheckBox]")
keyEvent.code = sf::Keyboard::Space;
checkBox->keyPressed(keyEvent);
REQUIRE(checkCount == 2);
REQUIRE(uncheckCount == 1);
REQUIRE(checkCount == 3);
REQUIRE(uncheckCount == 2);
keyEvent.code = sf::Keyboard::Return;
checkBox->keyPressed(keyEvent);
REQUIRE(checkCount == 2);
REQUIRE(uncheckCount == 2);
REQUIRE(checkCount == 3);
REQUIRE(uncheckCount == 3);
}
}
}
SECTION("Saving and loading from file")
{
tgui::Theme theme{"resources/Black.txt"};
checkBox->setRenderer(theme.getRenderer("CheckBox"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(checkBox);
checkBox->check();
checkBox->setText("SomeText");
checkBox->setTextSize(25);
checkBox->setTextClickable(false);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileCheckBox1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileCheckBox1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileCheckBox2.txt"));
REQUIRE(compareFiles("WidgetFileCheckBox1.txt", "WidgetFileCheckBox2.txt"));
SECTION("Copying widget")
{
copy(parent, checkBox);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileCheckBox2.txt"));
REQUIRE(compareFiles("WidgetFileCheckBox1.txt", "WidgetFileCheckBox2.txt"));
}
testSavingWidget("CheckBox", checkBox);
}
}

21
tests/Widgets/ClickableWidget.cpp
View File

@ -63,7 +63,7 @@ TEST_CASE("[ClickableWidget]")
REQUIRE(widget->getWidgetOffset() == sf::Vector2f(0, 0));
}
SECTION("Events")
SECTION("Events / Signals")
{
testClickableWidgetSignals(widget);
}
@ -95,23 +95,6 @@ TEST_CASE("[ClickableWidget]")
SECTION("Saving and loading from file")
{
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(widget);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileClickableWidget1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileClickableWidget1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileClickableWidget2.txt"));
REQUIRE(compareFiles("WidgetFileClickableWidget1.txt", "WidgetFileClickableWidget2.txt"));
SECTION("Copying widget")
{
copy(parent, widget);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileClickableWidget2.txt"));
REQUIRE(compareFiles("WidgetFileClickableWidget1.txt", "WidgetFileClickableWidget2.txt"));
}
testSavingWidget("ClickableWidget", widget, false);
}
}

24
tests/Widgets/EditBox.cpp
View File

@ -285,7 +285,7 @@ TEST_CASE("[EditBox]")
}
}
SECTION("Events")
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
@ -525,12 +525,6 @@ TEST_CASE("[EditBox]")
SECTION("Saving and loading from file")
{
tgui::Theme theme{"resources/Black.txt"};
editBox->setRenderer(theme.getRenderer("editbox"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(editBox);
editBox->setText("SomeText");
editBox->setDefaultText("SomeDefaultText");
editBox->setTextSize(25);
@ -540,21 +534,7 @@ TEST_CASE("[EditBox]")
editBox->limitTextWidth();
editBox->setInputValidator("[0-9a-zA-Z]*");
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileEditBox1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileEditBox1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileEditBox2.txt"));
REQUIRE(compareFiles("WidgetFileEditBox1.txt", "WidgetFileEditBox2.txt"));
SECTION("Copying widget")
{
copy(parent, editBox);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileEditBox2.txt"));
REQUIRE(compareFiles("WidgetFileEditBox1.txt", "WidgetFileEditBox2.txt"));
}
testSavingWidget("EditBox", editBox);
}
SECTION("Bug Fixes")

26
tests/Widgets/Label.cpp
View File

@ -124,14 +124,14 @@ TEST_CASE("[Label]")
REQUIRE(label->getMaximumTextWidth() == 500);
}
SECTION("Events")
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
testClickableWidgetSignals(label);
}
SECTION("double click")
SECTION("Double click")
{
unsigned int doubleClickedCount = 0;
label->connect("DoubleClicked", genericCallback, std::ref(doubleClickedCount));
@ -210,32 +210,12 @@ TEST_CASE("[Label]")
SECTION("Saving and loading from file")
{
tgui::Theme theme{"resources/Black.txt"};
label->setRenderer(theme.getRenderer("label"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(label);
label->setText("SomeText");
label->setTextSize(25);
label->setHorizontalAlignment(tgui::Label::HorizontalAlignment::Center);
label->setVerticalAlignment(tgui::Label::VerticalAlignment::Bottom);
label->setMaximumTextWidth(300);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileLabel1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileLabel1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileLabel2.txt"));
REQUIRE(compareFiles("WidgetFileLabel1.txt", "WidgetFileLabel2.txt"));
SECTION("Copying widget")
{
copy(parent, label);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileLabel2.txt"));
REQUIRE(compareFiles("WidgetFileLabel1.txt", "WidgetFileLabel2.txt"));
}
testSavingWidget("Label", label);
}
}

21
tests/Widgets/Panel.cpp
View File

@ -72,7 +72,7 @@ TEST_CASE("[Panel]")
}
}
SECTION("Events")
SECTION("Events / Signals")
{
unsigned int mousePressedCount = 0;
unsigned int mouseReleasedCount = 0;
@ -203,28 +203,11 @@ TEST_CASE("[Panel]")
SECTION("panel inside gui")
{
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(panel);
auto widget = std::make_shared<tgui::ClickableWidget>();
widget->setPosition(40, 20);
panel->add(widget);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFilePanel3.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFilePanel3.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFilePanel4.txt"));
REQUIRE(compareFiles("WidgetFilePanel3.txt", "WidgetFilePanel4.txt"));
SECTION("Copying widget")
{
copy(parent, panel);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFilePanel4.txt"));
REQUIRE(compareFiles("WidgetFilePanel3.txt", "WidgetFilePanel4.txt"));
}
testSavingWidget("Panel", panel, false);
}
}
}

26
tests/Widgets/Picture.cpp
View File

@ -24,7 +24,6 @@
#include "../Tests.hpp"
#include <TGUI/Widgets/Picture.hpp>
#include <TGUI/Widgets/Panel.hpp>
#include <TGUI/Gui.hpp>
TEST_CASE("[Picture]")
@ -121,7 +120,7 @@ TEST_CASE("[Picture]")
REQUIRE(!picture->isSmooth());
}
SECTION("Events")
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
@ -183,28 +182,7 @@ TEST_CASE("[Picture]")
SECTION("Saving and loading from file")
{
REQUIRE_NOTHROW(picture = std::make_shared<tgui::Picture>("resources/Black.png"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(picture);
picture->setSmooth();
picture->getRenderer()->setOpacity(0.8f);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFilePicture1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFilePicture1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFilePicture2.txt"));
REQUIRE(compareFiles("WidgetFilePicture1.txt", "WidgetFilePicture2.txt"));
SECTION("Copying widget")
{
copy(parent, picture);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFilePicture2.txt"));
REQUIRE(compareFiles("WidgetFilePicture1.txt", "WidgetFilePicture2.txt"));
}
testSavingWidget("Picture", picture, false);
}
}

99
tests/Widgets/ProgressBar.cpp
View File

@ -47,6 +47,18 @@ TEST_CASE("[ProgressBar]")
REQUIRE(progressBar->getWidgetType() == "ProgressBar");
}
SECTION("Position and Size")
{
progressBar->setPosition(40, 30);
progressBar->setSize(300, 40);
progressBar->getRenderer()->setBorders(2);
REQUIRE(progressBar->getPosition() == sf::Vector2f(40, 30));
REQUIRE(progressBar->getSize() == sf::Vector2f(300, 40));
REQUIRE(progressBar->getFullSize() == progressBar->getSize());
REQUIRE(progressBar->getWidgetOffset() == sf::Vector2f(0, 0));
}
SECTION("Minimum")
{
REQUIRE(progressBar->getMinimum() == 10);
@ -90,13 +102,13 @@ TEST_CASE("[ProgressBar]")
SECTION("Value")
{
REQUIRE(progressBar->getValue() == 15);
progressBar->setValue(14);
REQUIRE(progressBar->getValue() == 14);
progressBar->setValue(7);
REQUIRE(progressBar->getValue() == 10);
progressBar->setValue(23);
REQUIRE(progressBar->getValue() == 20);
}
@ -125,7 +137,7 @@ TEST_CASE("[ProgressBar]")
progressBar->setTextSize(25);
REQUIRE(progressBar->getTextSize() == 25);
}
SECTION("FillDirection")
{
REQUIRE(progressBar->getFillDirection() == tgui::ProgressBar::FillDirection::LeftToRight);
@ -139,6 +151,63 @@ TEST_CASE("[ProgressBar]")
REQUIRE(progressBar->getFillDirection() == tgui::ProgressBar::FillDirection::LeftToRight);
}
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
testClickableWidgetSignals(progressBar);
}
SECTION("ValueChanged")
{
unsigned int valueChangedCount = 0;
progressBar->connect("ValueChanged", genericCallback, std::ref(valueChangedCount));
progressBar->setValue(4);
REQUIRE(valueChangedCount == 1);
progressBar->setValue(20);
REQUIRE(valueChangedCount == 2);
progressBar->setValue(20);
REQUIRE(valueChangedCount == 2);
progressBar->setValue(18);
progressBar->incrementValue();
progressBar->incrementValue();
REQUIRE(valueChangedCount == 5);
progressBar->incrementValue();
REQUIRE(valueChangedCount == 5);
}
SECTION("Full")
{
unsigned int fullCount = 0;
progressBar->connect("Full", genericCallback, std::ref(fullCount));
progressBar->setValue(4);
REQUIRE(fullCount == 0);
progressBar->setValue(20);
REQUIRE(fullCount == 1);
progressBar->setValue(20);
REQUIRE(fullCount == 1);
progressBar->setValue(18);
progressBar->incrementValue();
REQUIRE(fullCount == 1);
progressBar->incrementValue();
REQUIRE(fullCount == 2);
progressBar->incrementValue();
REQUIRE(fullCount == 2);
}
}
testWidgetRenderer(progressBar->getRenderer());
SECTION("Renderer")
{
auto renderer = progressBar->getRenderer();
@ -231,30 +300,10 @@ TEST_CASE("[ProgressBar]")
SECTION("Saving and loading from file")
{
tgui::Theme theme{"resources/Black.txt"};
progressBar->setRenderer(theme.getRenderer("ProgressBar"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(progressBar);
progressBar->setText("SomeText");
progressBar->setTextSize(25);
progressBar->setFillDirection(tgui::ProgressBar::FillDirection::RightToLeft);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileProgressBar1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileProgressBar1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileProgressBar2.txt"));
REQUIRE(compareFiles("WidgetFileProgressBar1.txt", "WidgetFileProgressBar2.txt"));
SECTION("Copying widget")
{
copy(parent, progressBar);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileProgressBar2.txt"));
REQUIRE(compareFiles("WidgetFileProgressBar1.txt", "WidgetFileProgressBar2.txt"));
}
testSavingWidget("ProgressBar", progressBar);
}
}

24
tests/Widgets/RadioButton.cpp
View File

@ -141,7 +141,7 @@ TEST_CASE("[RadioButton]")
}
}
SECTION("Events")
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
@ -402,31 +402,11 @@ TEST_CASE("[RadioButton]")
SECTION("Saving and loading from file")
{
tgui::Theme theme{"resources/Black.txt"};
radioButton->setRenderer(theme.getRenderer("RadioButton"));
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(radioButton);
radioButton->check();
radioButton->setText("SomeText");
radioButton->setTextSize(25);
radioButton->setTextClickable(false);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileRadioButton1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileRadioButton1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileRadioButton2.txt"));
REQUIRE(compareFiles("WidgetFileRadioButton1.txt", "WidgetFileRadioButton2.txt"));
SECTION("Copying widget")
{
copy(parent, radioButton);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileRadioButton2.txt"));
REQUIRE(compareFiles("WidgetFileRadioButton1.txt", "WidgetFileRadioButton2.txt"));
}
testSavingWidget("RadioButton", radioButton);
}
}

260
tests/Widgets/SpinButton.cpp
View File

@ -25,23 +25,39 @@
#include "../Tests.hpp"
#include <TGUI/Widgets/SpinButton.hpp>
TEST_CASE("[SpinButton]") {
TEST_CASE("[SpinButton]")
{
tgui::SpinButton::Ptr spinButton = std::make_shared<tgui::SpinButton>();
spinButton->setFont("resources/DroidSansArmenian.ttf");
spinButton->getRenderer()->setFont("resources/DroidSansArmenian.ttf");
spinButton->setMinimum(10);
spinButton->setMaximum(20);
spinButton->setValue(15);
SECTION("Signals") {
SECTION("Signals")
{
REQUIRE_NOTHROW(spinButton->connect("ValueChanged", [](){}));
REQUIRE_NOTHROW(spinButton->connect("ValueChanged", [](int){}));
}
SECTION("WidgetType") {
SECTION("WidgetType")
{
REQUIRE(spinButton->getWidgetType() == "SpinButton");
}
SECTION("Minimum") {
SECTION("Position and Size")
{
spinButton->setPosition(40, 30);
spinButton->setSize(25, 60);
spinButton->getRenderer()->setBorders(2);
REQUIRE(spinButton->getPosition() == sf::Vector2f(40, 30));
REQUIRE(spinButton->getSize() == sf::Vector2f(25, 60));
REQUIRE(spinButton->getFullSize() == spinButton->getSize());
REQUIRE(spinButton->getWidgetOffset() == sf::Vector2f(0, 0));
}
SECTION("Minimum")
{
REQUIRE(spinButton->getMinimum() == 10);
spinButton->setMinimum(12);
@ -60,7 +76,8 @@ TEST_CASE("[SpinButton]") {
REQUIRE(spinButton->getMaximum() == 22);
}
SECTION("Maximum") {
SECTION("Maximum")
{
REQUIRE(spinButton->getMaximum() == 20);
spinButton->setMaximum(17);
@ -79,7 +96,8 @@ TEST_CASE("[SpinButton]") {
REQUIRE(spinButton->getMaximum() == 9);
}
SECTION("Value") {
SECTION("Value")
{
REQUIRE(spinButton->getValue() == 15);
spinButton->setValue(14);
@ -92,185 +110,167 @@ TEST_CASE("[SpinButton]") {
REQUIRE(spinButton->getValue() == 20);
}
SECTION("VerticalScroll") {
SECTION("VerticalScroll")
{
spinButton->setVerticalScroll(false);
REQUIRE(!spinButton->getVerticalScroll());
spinButton->setVerticalScroll(true);
REQUIRE(spinButton->getVerticalScroll());
}
SECTION("Renderer") {
SECTION("Events / Signals")
{
SECTION("ClickableWidget")
{
testClickableWidgetSignals(spinButton);
}
SECTION("ValueChanged")
{
spinButton->setPosition(40, 30);
spinButton->setSize(25, 60);
unsigned int valueChangedCount = 0;
spinButton->connect("ValueChanged", genericCallback, std::ref(valueChangedCount));
spinButton->setValue(10);
REQUIRE(valueChangedCount == 1);
spinButton->setValue(10);
REQUIRE(valueChangedCount == 1);
spinButton->leftMousePressed(50, 45);
REQUIRE(valueChangedCount == 1);
REQUIRE(spinButton->getValue() == 10);
spinButton->leftMouseReleased(50, 45);
REQUIRE(valueChangedCount == 2);
REQUIRE(spinButton->getValue() == 11);
spinButton->leftMousePressed(50, 75);
spinButton->leftMouseReleased(50, 75);
REQUIRE(valueChangedCount == 3);
REQUIRE(spinButton->getValue() == 10);
spinButton->leftMousePressed(50, 75);
spinButton->leftMouseReleased(50, 75);
REQUIRE(valueChangedCount == 3);
REQUIRE(spinButton->getValue() == 10);
}
}
testWidgetRenderer(spinButton->getRenderer());
SECTION("Renderer")
{
auto renderer = spinButton->getRenderer();
SECTION("colored") {
SECTION("set serialized property") {
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColor", "rgb(10, 20, 30)"));
REQUIRE(renderer->getProperty("BackgroundColor").getColor() == sf::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BackgroundColorNormal").getColor() == sf::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BackgroundColorHover").getColor() == sf::Color(10, 20, 30));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColor", "rgb(20, 30, 40)"));
REQUIRE(renderer->getProperty("ArrowColor").getColor() == sf::Color(20, 30, 40));
REQUIRE(renderer->getProperty("ArrowColorNormal").getColor() == sf::Color(20, 30, 40));
REQUIRE(renderer->getProperty("ArrowColorHover").getColor() == sf::Color(20, 30, 40));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorNormal", "rgb(30, 40, 50)"));
SECTION("Colored")
{
SECTION("Set serialized property")
{
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColor", "rgb(30, 40, 50)"));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorHover", "rgb(40, 50, 60)"));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColorNormal", "rgb(50, 60, 70)"));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColor", "rgb(50, 60, 70)"));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColorHover", "rgb(60, 70, 80)"));
REQUIRE_NOTHROW(renderer->setProperty("BorderColor", "rgb(70, 80, 90)"));
REQUIRE_NOTHROW(renderer->setProperty("Borders", "(1, 2, 3, 4)"));
REQUIRE_NOTHROW(renderer->setProperty("SpaceBetweenArrows", "2"));
}
SECTION("set object property") {
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColor", sf::Color{10, 20, 30}));
REQUIRE(renderer->getProperty("BackgroundColor").getColor() == sf::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BackgroundColorNormal").getColor() == sf::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BackgroundColorHover").getColor() == sf::Color(10, 20, 30));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColor", sf::Color{20, 30, 40}));
REQUIRE(renderer->getProperty("ArrowColor").getColor() == sf::Color(20, 30, 40));
REQUIRE(renderer->getProperty("ArrowColorNormal").getColor() == sf::Color(20, 30, 40));
REQUIRE(renderer->getProperty("ArrowColorHover").getColor() == sf::Color(20, 30, 40));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorNormal", sf::Color{30, 40, 50}));
SECTION("Set object property")
{
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColor", sf::Color{30, 40, 50}));
REQUIRE_NOTHROW(renderer->setProperty("BackgroundColorHover", sf::Color{40, 50, 60}));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColorNormal", sf::Color{50, 60, 70}));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColor", sf::Color{50, 60, 70}));
REQUIRE_NOTHROW(renderer->setProperty("ArrowColorHover", sf::Color{60, 70, 80}));
REQUIRE_NOTHROW(renderer->setProperty("BorderColor", sf::Color{70, 80, 90}));
REQUIRE_NOTHROW(renderer->setProperty("Borders", tgui::Borders{1, 2, 3, 4}));
REQUIRE_NOTHROW(renderer->setProperty("SpaceBetweenArrows", 2));
}
SECTION("functions") {
renderer->setBackgroundColor({10, 20, 30});
REQUIRE(renderer->getProperty("BackgroundColor").getColor() == sf::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BackgroundColorNormal").getColor() == sf::Color(10, 20, 30));
REQUIRE(renderer->getProperty("BackgroundColorHover").getColor() == sf::Color(10, 20, 30));
renderer->setArrowColor({20, 30, 40});
REQUIRE(renderer->getProperty("ArrowColor").getColor() == sf::Color(20, 30, 40));
REQUIRE(renderer->getProperty("ArrowColorNormal").getColor() == sf::Color(20, 30, 40));
REQUIRE(renderer->getProperty("ArrowColorHover").getColor() == sf::Color(20, 30, 40));
renderer->setBackgroundColorNormal({30, 40, 50});
SECTION("Functions")
{
renderer->setBackgroundColor({30, 40, 50});
renderer->setBackgroundColorHover({40, 50, 60});
renderer->setArrowColorNormal({50, 60, 70});
renderer->setArrowColor({50, 60, 70});
renderer->setArrowColorHover({60, 70, 80});
renderer->setBorderColor({70, 80, 90});
renderer->setBorders({1, 2, 3, 4});
renderer->setSpaceBetweenArrows(2);
SECTION("getPropertyValuePairs") {
auto pairs = renderer->getPropertyValuePairs();
REQUIRE(pairs.size() == 7);
REQUIRE(pairs["BackgroundColorNormal"].getColor() == sf::Color(30, 40, 50));
REQUIRE(pairs["BackgroundColorHover"].getColor() == sf::Color(40, 50, 60));
REQUIRE(pairs["ArrowColorNormal"].getColor() == sf::Color(50, 60, 70));
REQUIRE(pairs["ArrowColorHover"].getColor() == sf::Color(60, 70, 80));
REQUIRE(pairs["BorderColor"].getColor() == sf::Color(70, 80, 90));
REQUIRE(pairs["Borders"].getOutline() == tgui::Borders(1, 2, 3, 4));
REQUIRE(pairs["SpaceBetweenArrows"].getNumber() == 2);
}
}
REQUIRE(renderer->getProperty("BackgroundColorNormal").getColor() == sf::Color(30, 40, 50));
REQUIRE(renderer->getProperty("BackgroundColor").getColor() == sf::Color(30, 40, 50));
REQUIRE(renderer->getProperty("BackgroundColorHover").getColor() == sf::Color(40, 50, 60));
REQUIRE(renderer->getProperty("ArrowColorNormal").getColor() == sf::Color(50, 60, 70));
REQUIRE(renderer->getProperty("ArrowColor").getColor() == sf::Color(50, 60, 70));
REQUIRE(renderer->getProperty("ArrowColorHover").getColor() == sf::Color(60, 70, 80));
REQUIRE(renderer->getProperty("BorderColor").getColor() == sf::Color(70, 80, 90));
REQUIRE(renderer->getProperty("Borders").getOutline() == tgui::Borders(1, 2, 3, 4));
REQUIRE(renderer->getProperty("SpaceBetweenArrows").getNumber() == 2);
REQUIRE(renderer->getBackgroundColor() == sf::Color(30, 40, 50));
REQUIRE(renderer->getBackgroundColorHover() == sf::Color(40, 50, 60));
REQUIRE(renderer->getArrowColor() == sf::Color(50, 60, 70));
REQUIRE(renderer->getArrowColorHover() == sf::Color(60, 70, 80));
REQUIRE(renderer->getBorderColor() == sf::Color(70, 80, 90));
REQUIRE(renderer->getBorders() == tgui::Borders(1, 2, 3, 4));
REQUIRE(renderer->getSpaceBetweenArrows() == 2);
}
SECTION("textured") {
SECTION("textured")
{
tgui::Texture textureArrowUpNormal("resources/Black.png", {163, 154, 20, 20}, {0, 0, 20, 19});
tgui::Texture textureArrowUpHover("resources/Black.png", {183, 154, 20, 20}, {0, 0, 20, 19});
tgui::Texture textureArrowDownNormal("resources/Black.png", {163, 174, 20, 20}, {0, 1, 20, 19});
tgui::Texture textureArrowDownHover("resources/Black.png", {183, 174, 20, 20}, {0, 1, 20, 19});
REQUIRE(!renderer->getProperty("ArrowUpImage").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("ArrowUpHoverImage").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("ArrowDownImage").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("ArrowDownHoverImage").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("TextureArrowUp").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("TextureArrowUpHover").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("TextureArrowDown").getTexture().isLoaded());
REQUIRE(!renderer->getProperty("TextureArrowDownHover").getTexture().isLoaded());
SECTION("set serialized property") {
REQUIRE_NOTHROW(renderer->setProperty("ArrowUpImage", tgui::Serializer::serialize(textureArrowUpNormal)));
REQUIRE_NOTHROW(renderer->setProperty("ArrowUpHoverImage", tgui::Serializer::serialize(textureArrowUpHover)));
REQUIRE_NOTHROW(renderer->setProperty("ArrowDownImage", tgui::Serializer::serialize(textureArrowDownNormal)));
REQUIRE_NOTHROW(renderer->setProperty("ArrowDownHoverImage", tgui::Serializer::serialize(textureArrowDownHover)));
SECTION("set serialized property")
{
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowUp", tgui::Serializer::serialize(textureArrowUpNormal)));
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowUpHover", tgui::Serializer::serialize(textureArrowUpHover)));
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowDown", tgui::Serializer::serialize(textureArrowDownNormal)));
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowDownHover", tgui::Serializer::serialize(textureArrowDownHover)));
}
SECTION("set object property") {
REQUIRE_NOTHROW(renderer->setProperty("ArrowUpImage", textureArrowUpNormal));
REQUIRE_NOTHROW(renderer->setProperty("ArrowUpHoverImage", textureArrowUpHover));
REQUIRE_NOTHROW(renderer->setProperty("ArrowDownImage", textureArrowDownNormal));
REQUIRE_NOTHROW(renderer->setProperty("ArrowDownHoverImage", textureArrowDownHover));
SECTION("set object property")
{
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowUp", textureArrowUpNormal));
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowUpHover", textureArrowUpHover));
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowDown", textureArrowDownNormal));
REQUIRE_NOTHROW(renderer->setProperty("TextureArrowDownHover", textureArrowDownHover));
}
SECTION("functions") {
renderer->setArrowUpTexture(textureArrowUpNormal);
renderer->setArrowUpHoverTexture(textureArrowUpHover);
renderer->setArrowDownTexture(textureArrowDownNormal);
renderer->setArrowDownHoverTexture(textureArrowDownHover);
SECTION("getPropertyValuePairs") {
auto pairs = renderer->getPropertyValuePairs();
REQUIRE(pairs.size() == 7);
REQUIRE(pairs["ArrowUpImage"].getTexture().getData() == textureArrowUpNormal.getData());
REQUIRE(pairs["ArrowUpHoverImage"].getTexture().getData() == textureArrowUpHover.getData());
REQUIRE(pairs["ArrowDownImage"].getTexture().getData() == textureArrowDownNormal.getData());
REQUIRE(pairs["ArrowDownHoverImage"].getTexture().getData() == textureArrowDownHover.getData());
}
SECTION("functions")
{
renderer->setTextureArrowUp(textureArrowUpNormal);
renderer->setTextureArrowUpHover(textureArrowUpHover);
renderer->setTextureArrowDown(textureArrowDownNormal);
renderer->setTextureArrowDownHover(textureArrowDownHover);
}
REQUIRE(renderer->getProperty("ArrowUpImage").getTexture().isLoaded());
REQUIRE(renderer->getProperty("ArrowUpHoverImage").getTexture().isLoaded());
REQUIRE(renderer->getProperty("ArrowDownImage").getTexture().isLoaded());
REQUIRE(renderer->getProperty("ArrowDownHoverImage").getTexture().isLoaded());
REQUIRE(renderer->getProperty("TextureArrowUp").getTexture().isLoaded());
REQUIRE(renderer->getProperty("TextureArrowUpHover").getTexture().isLoaded());
REQUIRE(renderer->getProperty("TextureArrowDown").getTexture().isLoaded());
REQUIRE(renderer->getProperty("TextureArrowDownHover").getTexture().isLoaded());
REQUIRE(renderer->getProperty("ArrowUpImage").getTexture().getData() == textureArrowUpNormal.getData());
REQUIRE(renderer->getProperty("ArrowUpHoverImage").getTexture().getData() == textureArrowUpHover.getData());
REQUIRE(renderer->getProperty("ArrowDownImage").getTexture().getData() == textureArrowDownNormal.getData());
REQUIRE(renderer->getProperty("ArrowDownHoverImage").getTexture().getData() == textureArrowDownHover.getData());
REQUIRE(renderer->getTextureArrowUp().getData() == textureArrowUpNormal.getData());
REQUIRE(renderer->getTextureArrowUpHover().getData() == textureArrowUpHover.getData());
REQUIRE(renderer->getTextureArrowDown().getData() == textureArrowDownNormal.getData());
REQUIRE(renderer->getTextureArrowDownHover().getData() == textureArrowDownHover.getData());
}
}
SECTION("Saving and loading from file") {
REQUIRE_NOTHROW(spinButton = std::make_shared<tgui::Theme>()->load("SpinButton"));
auto theme = std::make_shared<tgui::Theme>("resources/Black.txt");
REQUIRE_NOTHROW(spinButton = theme->load("SpinButton"));
REQUIRE(spinButton->getPrimaryLoadingParameter() == "resources/Black.txt");
REQUIRE(spinButton->getSecondaryLoadingParameter() == "spinbutton");
auto parent = std::make_shared<tgui::GuiContainer>();
parent->add(spinButton);
spinButton->setOpacity(0.8f);
SECTION("Saving and loading from file")
{
spinButton->setMinimum(10);
spinButton->setMaximum(50);
spinButton->setValue(20);
spinButton->setVerticalScroll(false);
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileSpinButton1.txt"));
parent->removeAllWidgets();
REQUIRE_NOTHROW(parent->loadWidgetsFromFile("WidgetFileSpinButton1.txt"));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileSpinButton2.txt"));
REQUIRE(compareFiles("WidgetFileSpinButton1.txt", "WidgetFileSpinButton2.txt"));
SECTION("Copying widget") {
tgui::SpinButton temp;
temp = *spinButton;
parent->removeAllWidgets();
parent->add(tgui::SpinButton::copy(std::make_shared<tgui::SpinButton>(temp)));
REQUIRE_NOTHROW(parent->saveWidgetsToFile("WidgetFileSpinButton2.txt"));
REQUIRE(compareFiles("WidgetFileSpinButton1.txt", "WidgetFileSpinButton2.txt"));
}
testSavingWidget("SpinButton", spinButton);
}
}

10
widgets/Black.txt
View File

@ -128,11 +128,11 @@ Slider {
}
SpinButton {
ArrowUpImage : "Black.png" Part(163, 154, 20, 20) Middle(0, 0, 20, 19);
ArrowUpHoverImage : "Black.png" Part(183, 154, 20, 20) Middle(0, 0, 20, 19);
ArrowDownImage : "Black.png" Part(163, 174, 20, 20) Middle(0, 1, 20, 19);
ArrowDownHoverImage : "Black.png" Part(183, 174, 20, 20) Middle(0, 1, 20, 19);
SpaceBetweenArrows : 0;
TextureArrowUp : "Black.png" Part(163, 154, 20, 20) Middle(0, 0, 20, 19);
TextureArrowUpHover : "Black.png" Part(183, 154, 20, 20) Middle(0, 0, 20, 19);
TextureArrowDown : "Black.png" Part(163, 174, 20, 20) Middle(0, 1, 20, 19);
TextureArrowDownHover : "Black.png" Part(183, 174, 20, 20) Middle(0, 1, 20, 19);
SpaceBetweenArrows : 0;
}
Tab {