Yep, I am using the files from the .zip. My Button.hpp looks like this:
Code Select
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// TGUI - Texus's Graphical User Interface
// Copyright (C) 2012-2013 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_BUTTON_HPP
#define TGUI_BUTTON_HPP
#include <TGUI/ClickableWidget.hpp>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace tgui
{
class Container;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class TGUI_API Button : public ClickableWidget
{
public:
typedef SharedWidgetPtr<Button> Ptr;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Default constructor
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Button();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Copy constructor
///
/// \param copy Instance to copy
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Button(const Button& copy);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Destructor
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual ~Button();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Overload of assignment operator
///
/// \param right Instance to assign
///
/// \return Reference to itself
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Button& operator= (const Button& right);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
// Makes a copy of the widget by calling the copy constructor.
// This function calls new and if you use this function then you are responsible for calling delete.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual Button* clone();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Loads the widget.
///
/// \param configFileFilename Filename of the config file.
///
/// The config file must contain a Button section with the needed information.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool load(const std::string& configFileFilename);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Returns the filename of the config file that was used to load the widget.
///
/// \return Filename of loaded config file.
/// Empty string when no config file was loaded yet.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const std::string& getLoadedConfigFile() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Set 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 x X coordinate of the new position
/// \param y Y coordinate of the new position
///
/// \see move, getPosition
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setPosition(float x, float y);
using Transformable::setPosition;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Changes the size of the button.
///
/// \param width The new width of the button
/// \param height The new height of the button
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setSize(float width, float height);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Changes the caption of the button.
///
/// \param text New text to draw on top of the button.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setText(const sf::String& text);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Returns the caption of the button.
///
/// \return Text that is drawn on top of the button.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sf::String getText() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Changes the font of the text.
///
/// When you don't call this function then the global font will be use.
/// This global font can be changed with the setGlobalFont function from the parent.
///
/// \param font The new font
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextFont(const sf::Font& font);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Returns the font of the text.
///
/// \return Pointer to the font that is currently being used
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const sf::Font* getTextFont() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Changes the color of the text.
///
/// \param color New text color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextColor(const sf::Color& color);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Returns the color of the text.
///
/// \return The current text color
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const sf::Color& getTextColor() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Changes the character size of the text.
///
/// \param size The new text size.
/// If the size is set to 0 then the text will be auto-sized to fit inside the button.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setTextSize(unsigned int size);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Returns the character size of the text.
///
/// \return The current text size.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned int getTextSize() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \brief Changes the transparency of the widget.
///
/// \param transparency The transparency of the widget.
/// 0 is completely transparent, while 255 (default) means fully opaque.
///
/// Note that this will only change the transparency of the images. The parts of the widgets that use a color will not
/// be changed. You must change them yourself by setting the alpha channel of the color.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void setTransparency(unsigned char transparency);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void keyPressed(sf::Keyboard::Key key);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void widgetFocused();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
// This function is a (slow) way to set properties on the widget, no matter what type it is.
// When the requested property doesn't exist in the widget then the functions will return false.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual bool setProperty(std::string property, const std::string& value);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
// This function is a (slow) way to get properties of the widget, no matter what type it is.
// When the requested property doesn't exist in the widget then the functions will return false.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual bool getProperty(std::string property, std::string& value) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
// Returns a list of all properties that can be used in setProperty and getProperty.
// The second value in the pair is the type of the property (e.g. int, uint, string, ...).
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual std::list< std::pair<std::string, std::string> > getPropertyList() const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
// This function is called when the widget is added to a container.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void initialize(Container *const container);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \internal
// Draws the widget on the render target.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Defines specific triggers to Button.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum ButtonCallbacks
{
SpaceKeyPressed = ClickableWidgetCallbacksCount * 1, ///< Space key was pressed
ReturnKeyPressed = ClickableWidgetCallbacksCount * 2, ///< Return key was pressed
AllButtonCallbacks = ClickableWidgetCallbacksCount * 4 - 1, ///< All triggers defined in Button and its base classes
ButtonCallbacksCount = ClickableWidgetCallbacksCount * 4
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected:
std::string m_LoadedConfigFile;
Texture m_TextureNormal_L;
Texture m_TextureHover_L;
Texture m_TextureDown_L;
Texture m_TextureFocused_L;
Texture m_TextureNormal_M;
Texture m_TextureHover_M;
Texture m_TextureDown_M;
Texture m_TextureFocused_M;
Texture m_TextureNormal_R;
Texture m_TextureHover_R;
Texture m_TextureDown_R;
Texture m_TextureFocused_R;
// If this is true then the L, M and R images will be used.
// If it is false then the button is just one big image that will be stored in the M image.
bool m_SplitImage;
// Is there a separate hover image, or is it a semi-transparent image that is drawn on top of the others?
bool m_SeparateHoverImage;
// The SFML text
sf::Text m_Text;
// This will store the size of the text ( 0 to auto size )
unsigned int m_TextSize;
friend class ChildWindow;
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#endif // TGUI_BUTTON_HPP