Objects.hpp

//
// TGUI - Texus's Graphical User Interface
// Copyright (C) 2012 Bruno Van de Velde (VDV_B@hotmail.com)
//
// 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_OBJECTS_INCLUDED_
#define _TGUI_OBJECTS_INCLUDED_


namespace tgui
{
 struct TGUI_API OBJECT : public sf::Drawable, sf::Transformable
 {
 OBJECT();


 OBJECT(const OBJECT& copy);


 virtual ~OBJECT();


 OBJECT& operator= (const OBJECT& right);


 // This function is called when the object is created (when it is added to a group).
 virtual void initialize();


 // Makes a copy of the object by just calling the copy constructor.
 virtual OBJECT* clone() = 0;


 virtual void setSize(float width, float height) = 0;


 virtual Vector2u getSize() const = 0;


 virtual Vector2f getScaledSize() const = 0;


 virtual void show();


 virtual void hide();


 virtual bool isVisible() const;


 virtual void enable();


 virtual void disable();


 virtual bool isEnabled() const;


 virtual bool isDisabled() const;


 virtual bool isLoaded() const;


 // Get the ObjectPhases from the string read from the info file
 virtual void extractPhases(std::string phases);


 void focus();


 void unfocus();


 void focusNextObject();


 virtual bool isFocused() const;


 virtual ObjectTypes getObjectType() const;


 virtual void moveToFront();


 virtual void moveToBack();


 // These functions are used to receive callback from the EventManager.
 // You normally don't need them, but you can use them to simulate an event.
 virtual bool mouseOnObject(float x, float y);
 virtual void leftMousePressed(float x, float y);
 virtual void leftMouseReleased(float x, float y);
 virtual void mouseMoved(float x, float y);
 virtual void keyPressed(sf::Keyboard::Key key);
 virtual void textEntered(sf::Uint32 key);
 virtual void mouseWheelMoved(int delta);
 virtual void objectFocused();
 virtual void objectUnfocused();

 virtual void mouseNotOnObject();
 virtual void mouseNoLongerDown();


 public:

 // When the id is 0 then there will be no callback. Otherwise, this will be the callbackID inside the Callback struct.
 unsigned int callbackID;


 protected:

 // When an object is disabled, it will no longer receive events
 bool m_Enabled;

 // Is the object visible? When it is invisible it will not receive events and it won't be drawn.
 bool m_Visible;

 // This bool will be true from the moment that the load function is completed successfully.
 bool m_Loaded;

 // This will store the different phases that the object can have
 // e.g. if there isn't a mouse down image then a button should not try to change its image on mouse down
 unsigned char m_ObjectPhase;

 // This will point to our parent object. If there is no parent then this will be NULL.
 Group* m_Parent;

 // Is the mouse on top of the object? Did the mouse go down on the object?
 bool m_MouseHover;
 bool m_MouseDown;

 // Are you focused on the object?
 bool m_Focused;

 // Can the object be focused?
 bool m_AllowFocus;

 // Is the object a button, an edit box, a checkbox, ...
 ObjectTypes m_ObjectType;

 // This is set to true for objects that are also derived from OBJECT_ANIMATION.
 bool m_AnimatedObject;

 // This is set to true for objects that have something to be dragged around (e.g. sliders and scrollbars)
 bool m_DraggableObject;

 // This is set to true for objects that store other objects inside them
 bool m_GroupObject;



 friend struct EventManager;
 friend struct Group;
 };


 struct TGUI_API OBJECT_BORDERS
 {
 OBJECT_BORDERS();


 virtual void setBorders(unsigned int leftBorder = 0, unsigned int topBorder = 0,
 unsigned int rightBorder = 0, unsigned int bottomBorder = 0) = 0;


 virtual Vector4u getBorders() const;


 protected:

 unsigned int m_LeftBorder;
 unsigned int m_TopBorder;
 unsigned int m_RightBorder;
 unsigned int m_BottomBorder;

 };


 struct TGUI_API OBJECT_ANIMATION
 {
 // The event manager will be able to change the elapsed time from any object
 friend struct EventManager;

 protected:

 // This function is called right after the elapsed time is changed.
 virtual void update() = 0;

 protected:

 // This will store the elapsed time since the last animation
 sf::Time m_AnimationTimeElapsed;
 };


 struct Callback
 {
 // All objects

 // The id that was passed to the object. It is used to identify from what object the callback came from. It can'b be 0.
 unsigned int callbackID;

 // How did the callbak occur? (one of the elements from the Triggers enum)
 unsigned int trigger;

 // Pointer to the object
 OBJECT* object;


 // Checkbox and RadioButton

 // True when the checkbox is checked, false otherwise.
 bool checked;


 // Button (these members are still in there because of what I did in v0.1, but they shouldn't be used)

 // This will store the mouse position. Only used on mouse clicks.
 float mouseX;
 float mouseY;

 // When you click on an object then this contains the button
 sf::Mouse::Button mouseButton;


 // Editbox and ListBox

 // This string will contain the new string inside the editbox
 sf::String text;


 // Slider, ListBox and LoadingBar

 unsigned int value;


 // This enum contains the different values for Trigger.
 enum triggers
 {
 mouseDown, // Button
 mouseClick, // Button, Checkbox, RadioButton
 keyPress_Space, // Button, Checkbox, RadioButton
 keyPress_Return, // Button, Checkbox, RadioButton
 textChanged, // EditBox
 valueChanged, // Slider, LoadingBar
 itemSelected, // ListBox, ComboBox
 animationFinished, // AnimatedPicture
 closed, // ChildWindow

 count // Keep this one last
 };
 };


 // Get a sf::Color from a string. The string must look like: "(r, g, b)" or "(r, g, b, a)".
 // When this function fails then it will return black.
 TGUI_API sf::Color extractColor(std::string string);


 // This function does exactly the opposite of extractColor.
 // The returned string will be "(r,g,b)" when a=255 or "(r,g,b,a)" when a<255.
 TGUI_API std::string convertColorToString(const sf::Color& color);


 // Get a Vector2f from a string. The string must look like: "(x, y)".
 TGUI_API bool extractVector2f(std::string string, Vector2f& vector);


 // Get a Vector2u from a string. The string must look like: "(x, y)".
 TGUI_API bool extractVector2u(std::string string, Vector2u& vector);


 // Get a Vector4u from a string. The string must look like: "(x1, x2, x3, x4)".
 TGUI_API bool extractVector4u(std::string string, Vector4u& vector);
}


#endif //_TGUI_OBJECTS_INCLUDED_