EventManager.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_EVENT_MANAGER_INCLUDED_
#define _TGUI_EVENT_MANAGER_INCLUDED_


namespace tgui
{
 // Keeps track of all objects and passes the events to them.
 struct TGUI_API EventManager : public sf::NonCopyable
 {
 // The default constructor.
 EventManager();


 protected:

 // When this function is called then all the objects receive the event (if there are objects).
 virtual void handleEvent(sf::Event& event);


 // You can use this function to change the focus to another object.
 // You cannot manually call this function. You should call the focus function from the object's parent instead.
 virtual void focusObject(OBJECT* const object);


 // Unfocuses the given object.
 virtual void unfocusObject(OBJECT* const object);


 // Unfocuses all the objects.
 virtual void unfocusAllObjects();


 // Places an object before all other objects.
 virtual void updateTime(const sf::Time& elapsedTime);


 // When the tab key is pressed then this function is called. The focus will move to the next object (if there is one).
 // This function will only work when tabKeyUsageEnabled is true.
 virtual void tabKeyPressed();


 // Checks above which object the mouse is standing.
 // The object can be signaled through Objects[ObjectNr] on condition that this function returned true.
 //
 // return: true when the mouse is standing on an object
 // false if the mouse isn't on any object
 virtual bool mouseOnObject(unsigned int& objectNr, float x, float y);


 // Tells all the objects that the mouse is not on top of them.
 virtual void mouseNotOnObject();


 // Tells all the objects that the mouse is no longer down.
 virtual void mouseNoLongerDown();


 // This function is similar to the tabKeyPressed function.
 // The difference is that this function will return false and unfocus all objects when the last object was focused.
 // The tabKeyPressed function on the other hand would just focus the first object.
 virtual bool focusNextObject();


 protected:

 // This vector will hold all objects
 std::vector<OBJECT*> m_Objects;

 // The id of the focused object
 unsigned int m_FocusedObject;

 // When one of the elements of the array becomes true then the key is held down.
 // When nothing happend (e.g. focus another object) and it goes up again then the focused object receives a signal.
 // When something happens then this key will also becomes false again (while the key is still down).
 // Not all elements are used, only a few elements of the array are changed.
 bool m_KeyPress[sf::Keyboard::KeyCount];

 // A pointer to the struct that owns the event manager (NULL when it is the window)
 OBJECT* m_Parent;


 // The event handler can only be used by objects and by the window
 friend struct Group;
 friend struct GroupObject;
 friend struct Panel;
 friend struct ChildWindow;
 friend struct Grid;
 friend struct Window;
 friend struct Form;

 };


}


#endif //_TGUI_EVENT_MANAGER_INCLUDED_