khanat-opennel-code/code/nel/src/gui/widget_manager.cpp

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "nel/gui/db_manager.h"
#include "nel/gui/view_renderer.h"
#include "nel/gui/widget_manager.h"
#include "nel/gui/view_pointer_base.h"
#include "nel/gui/ctrl_draggable.h"
#include "nel/gui/interface_group.h"
#include "nel/gui/group_container_base.h"
#include "nel/gui/group_modal.h"
#include "nel/gui/group_editbox_base.h"
#include "nel/gui/interface_options.h"

namespace NLGUI
{
	void LinkHack();
}

namespace
{
	const uint DOUBLE_CLICK_MIN = 50;
	const uint DOUBLE_CLICK_MAX = 750;
	const float ROLLOVER_MIN_DELTA_PER_MS = 0.28f;
	const float ROLLOVER_MAX_DELTA_PER_MS = 0.12f;

	void Hack()
	{
		NLGUI::LinkHack();
	}
}

namespace NLGUI
{
	CWidgetManager* CWidgetManager::instance = NULL;
	std::string CWidgetManager::_CtrlLaunchingModalId= "ctrl_launch_modal";
	IParser* CWidgetManager::parser = NULL;

	// ----------------------------------------------------------------------------
	// SMasterGroup
	// ----------------------------------------------------------------------------

	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::addWindow(CInterfaceGroup *pIG, uint8 nPrio)
	{
		nlassert(nPrio<WIN_PRIORITY_MAX);

		// Priority WIN_PRIORITY_WORLD_SPACE is only for CGroupInScene !
		// Add this group in another priority list
		nlassert ((nPrio!=WIN_PRIORITY_MAX) || pIG->isGroupInScene() );

		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				// If the element already exists in the list return !
				if (*it == pIG)
					return;
				it++;
			}
		}
		PrioritizedWindows[nPrio].push_back(pIG);
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::delWindow(CInterfaceGroup *pIG)
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				if ((*it) == pIG)
				{
					PrioritizedWindows[i].erase(it);
					return;
				}
				it++;
			}
		}
	}

	// ----------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::SMasterGroup::getWindowFromId(const std::string &winID)
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				if ((*it)->getId() == winID)
					return *it;
				it++;
			}
		}
		return NULL;
	}

	// ----------------------------------------------------------------------------
	bool CWidgetManager::SMasterGroup::isWindowPresent(CInterfaceGroup *pIG)
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				if ((*it) == pIG)
					return true;
				it++;
			}
		}
		return false;
	}

	// Set a window top in its priority queue
	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::setTopWindow(CInterfaceGroup *pIG)
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				if (*it == pIG)
				{
					PrioritizedWindows[i].erase(it);
					PrioritizedWindows[i].push_back(pIG);
					LastTopWindowPriority= i;
					return;
				}
				it++;
			}
		}
		// todo hulud interface syntax error
		nlwarning("window %s do not exist in a priority list", pIG->getId().c_str());
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::setBackWindow(CInterfaceGroup *pIG)
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				if (*it == pIG)
				{
					PrioritizedWindows[i].erase(it);
					PrioritizedWindows[i].push_front(pIG);
					return;
				}
				it++;
			}
		}
		// todo hulud interface syntax error
		nlwarning("window %s do not exist in a priority list", pIG->getId().c_str());
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::deactiveAllContainers()
	{
		std::vector<CGroupContainerBase*> gcs;

		// Make first a list of all window (Warning: all group container are not window!)
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(*it);
				if (pGC != NULL)
					gcs.push_back(pGC);
				it++;
			}
		}

		// Then hide them. Must do this in 2 times, because setActive(false) change PrioritizedWindows,
		// and hence invalidate its.
		for (uint32 i = 0; i < gcs.size(); ++i)
		{
			gcs[i]->setActive(false);
		}
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::centerAllContainers()
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(*it);
				if ((pGC != NULL) && (pGC->getParent() != NULL))
				{
					sint32 wParent = pGC->getParent()->getW(false);
					sint32 w = pGC->getW(false);
					pGC->setXAndInvalidateCoords((wParent - w) / 2);
					sint32 hParent = pGC->getParent()->getH(false);
					sint32 h = pGC->getH(false);
					pGC->setYAndInvalidateCoords(h+(hParent - h) / 2);
				}

				it++;
			}
		}
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::SMasterGroup::unlockAllContainers()
	{
		for (uint8 i = 0; i < WIN_PRIORITY_MAX; ++i)
		{
			std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[i].begin();
			while (it != PrioritizedWindows[i].end())
			{
				CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(*it);
				if (pGC != NULL)
					pGC->setLocked(false);

				it++;
			}
		}
	}

	class CElementToSort
	{
	public:
		CInterfaceGroup *pIG;
		float	Distance;
		bool operator< (const CElementToSort& other) const
		{
			// We want first farest views
			return Distance > other.Distance;
		}
	};

	void CWidgetManager::SMasterGroup::sortWorldSpaceGroup ()
	{
		static std::vector<CElementToSort> sortTable;
		sortTable.clear ();

		// Fill the sort table
		std::list<CInterfaceGroup*>::iterator it = PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].begin();
		while (it != PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].end())
		{
			sortTable.push_back (CElementToSort ());
			CElementToSort &elm = sortTable.back();
			elm.pIG = *it;
			elm.Distance = (*it)->getDepthForZSort();

			it++;
		}

		// Sort the table
		std::sort (sortTable.begin(), sortTable.end());

		// Fill the final table
		uint i = 0;
		it = PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].begin();
		while (it != PrioritizedWindows[WIN_PRIORITY_WORLD_SPACE].end())
		{
			*it = sortTable[i].pIG;

			it++;
			i++;
		}
	}


	CWidgetManager* CWidgetManager::getInstance()
	{
		if( instance == NULL )
			instance = new CWidgetManager;

		return instance;
	}

	void CWidgetManager::release()
	{
		delete instance;
		instance = NULL;
	}

	// ----------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getMasterGroupFromId (const std::string &MasterGroupName)
	{
		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
		{
			if (_MasterGroups[i].Group->getId() == MasterGroupName)
				return _MasterGroups[i].Group;
		}
		return NULL;
	}

	// ----------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getWindowFromId (const std::string & groupId)
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			CInterfaceGroup *pIG = rMG.getWindowFromId(groupId);
			if (pIG != NULL)
				return pIG;
		}
		return NULL;
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::addWindowToMasterGroup (const std::string &sMasterGroupName, CInterfaceGroup *pIG)
	{
		// Warning this function is not smart : its a o(n) !
		if (pIG == NULL) return;
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); ++nMasterGroup)
		{
			SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getId() == sMasterGroupName)
			{
				rMG.addWindow(pIG, pIG->getPriority());
			}
		}
	}

	// ----------------------------------------------------------------------------
	void CWidgetManager::removeWindowFromMasterGroup(const std::string &sMasterGroupName,CInterfaceGroup *pIG)
	{
		// Warning this function is not smart : its a o(n) !
		if (pIG == NULL) return;
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); ++nMasterGroup)
		{
			SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getId() == sMasterGroupName)
			{
				rMG.delWindow(pIG);
			}
		}
	}

	void unlinkAllContainers (CInterfaceGroup *pIG)
	{
		const std::vector<CInterfaceGroup*> &rG = pIG->getGroups();
		for(uint i = 0; i < rG.size(); ++i)
			unlinkAllContainers (rG[i]);

		CGroupContainerBase *pGC = dynamic_cast<CGroupContainerBase*>(pIG);
		if (pGC != NULL)
			pGC->removeAllContainers();
	}

	// ***************************************************************************
	void CWidgetManager::removeAllMasterGroups()
	{
		uint i;

		for (i = 0; i < _MasterGroups.size(); ++i)
			unlinkAllContainers (_MasterGroups[i].Group);

		// Yoyo: important to not Leave NULL in the array, because of CGroupHTML and LibWWW callback
		// that may call CInterfaceManager::getElementFromId() (and this method hates having NULL in the arrays ^^)
		while(!_MasterGroups.empty())
		{
			delete _MasterGroups.back().Group;
			_MasterGroups.pop_back();
		}

	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::activateMasterGroup (const std::string &sMasterGroupName, bool bActive)
	{
		CInterfaceGroup *pIG = CWidgetManager::getInstance()->getMasterGroupFromId (sMasterGroupName);
		if (pIG != NULL)
		{
			pIG->setActive(bActive);
			pIG->invalidateCoords();
		}
	}

	// ------------------------------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getWindow(CInterfaceElement *pIE)
	{
		CInterfaceGroup *pIG = pIE->getParent();
		if (pIG == NULL) return NULL;
		if (pIG->getParent() == NULL) return NULL;
		while (pIG->getParent()->getParent() != NULL)
		{
			pIG = pIG->getParent();
		}
		return pIG;
	}


	// ------------------------------------------------------------------------------------------------
	CInterfaceElement* CWidgetManager::getElementFromId (const std::string &sEltId)
	{
		// System special
		if(sEltId == _CtrlLaunchingModalId)
			return getCtrlLaunchingModal();

		// Search for all elements
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			CInterfaceElement *pIEL = rMG.Group->getElement (sEltId);
			if (pIEL != NULL)
				return pIEL;
		}
		return NULL;
	}

	// ------------------------------------------------------------------------------------------------
	CInterfaceElement* CWidgetManager::getElementFromId (const std::string &sStart, const std::string &sEltId)
	{
		CInterfaceElement *pIEL = getElementFromId (sEltId);
		if (pIEL == NULL)
		{
			std::string sZeStart = sStart, sTmp;
			if (sZeStart[sZeStart.size()-1] == ':')
				sZeStart = sZeStart.substr(0, sZeStart.size()-1);

			while (sZeStart != "")
			{
				if (sEltId[0] == ':')
					sTmp = sZeStart	+ sEltId;
				else
					sTmp = sZeStart	+ ":" + sEltId;
				pIEL = getElementFromId (sTmp);
				if (pIEL != NULL)
					return pIEL;
				std::string::size_type nextPos = sZeStart.rfind(':');
				if (nextPos == std::string::npos) break;
				sZeStart = sZeStart.substr(0, nextPos);
			}
		}
		return pIEL;
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::setTopWindow (CInterfaceGroup* win)
	{
		//find the window in the window list
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
				rMG.setTopWindow(win);
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::setBackWindow(CInterfaceGroup* win)
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
				rMG.setBackWindow(win);
		}
	}

	// ------------------------------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getTopWindow (uint8 nPriority) const
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				// return the first.
				if(rMG.PrioritizedWindows[nPriority].empty())
					return NULL;
				else
					return rMG.PrioritizedWindows[nPriority].back();
			}
		}
		return NULL;
	}


	// ------------------------------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getBackWindow (uint8 nPriority) const
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				// return the first.
				if(rMG.PrioritizedWindows[nPriority].empty())
					return NULL;
				else
					return rMG.PrioritizedWindows[nPriority].front();
			}
		}
		return NULL;
	}

	// ***************************************************************************
	CInterfaceGroup* CWidgetManager::getLastEscapableTopWindow() const
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
				{
					const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
					std::list<CInterfaceGroup*>::const_reverse_iterator	it;
					it= rList.rbegin();
					for(;it!=rList.rend();it++)
					{
						if((*it)->getActive() && (*it)->getEscapable())
							return *it;
					}
				}
			}
		}
		return NULL;
	}

	// ***************************************************************************
	void CWidgetManager::setWindowPriority (CInterfaceGroup *pWin, uint8 nNewPriority)
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				if (rMG.isWindowPresent(pWin))
				{
					rMG.delWindow(pWin);
					rMG.addWindow(pWin, nNewPriority);
				}
			}
		}
	}

	// ***************************************************************************
	uint8 CWidgetManager::getLastTopWindowPriority() const
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			const CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				return rMG.LastTopWindowPriority;
			}
		}
		return 0;
	}

	bool CWidgetManager::hasModal() const
	{
		if( !_ModalStack.empty() )
			return true;
		else
			return false;
	}

	CWidgetManager::SModalWndInfo& CWidgetManager::getModal()
	{
		return _ModalStack.back();
	}

	bool CWidgetManager::isPreviousModal( CInterfaceGroup *wnd ) const
	{
		std::vector< SModalWndInfo >::size_type s = _ModalStack.size();
		for( std::vector< SModalWndInfo >::size_type i = 0; i < s; i++ )
			if( _ModalStack[ i ].ModalWindow == wnd )
				return true;

		return false;
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::enableModalWindow (CCtrlBase *ctrlLaunchingModal, CInterfaceGroup *pIG)
	{
		// disable any modal before. release keyboard
		disableModalWindow();
		pushModalWindow(ctrlLaunchingModal, pIG);
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::enableModalWindow (CCtrlBase *CtrlLaunchingModal, const std::string &groupName)
	{
		CInterfaceGroup	*group= dynamic_cast<CGroupModal*>( getElementFromId(groupName) );
		if(group)
		{
			// enable the modal
			enableModalWindow(CtrlLaunchingModal, group);
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::disableModalWindow ()
	{
		while (!_ModalStack.empty())
		{
			SModalWndInfo winInfo = _ModalStack.back();
			_ModalStack.pop_back(); // must pop back as early as possible because 'setActive' may trigger another 'popModalWindow', leading to a crash
			// disable old modal window
			if(winInfo.ModalWindow)
			{
				setBackWindow(winInfo.ModalWindow);
				winInfo.ModalWindow->setActive(false);
			}
		}

		// disable any context help
		setCurContextHelp( NULL );
		CWidgetManager::getInstance()->_DeltaTimeStopingContextHelp = 0;
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::pushModalWindow(CCtrlBase *ctrlLaunchingModal, CInterfaceGroup *pIG)
	{
		// enable the wanted modal
		if(pIG)
		{
			SModalWndInfo mwi;
			mwi.ModalWindow = pIG;
			mwi.CtrlLaunchingModal = ctrlLaunchingModal;
			// setup special group
			CGroupModal		*groupModal= dynamic_cast<CGroupModal*>(pIG);
			if(groupModal)
			{
				mwi.ModalExitClickOut = groupModal->ExitClickOut;
				mwi.ModalExitClickL = groupModal->ExitClickL;
				mwi.ModalExitClickR = groupModal->ExitClickR;
				mwi.ModalHandlerClickOut = groupModal->OnClickOut;
				mwi.ModalClickOutParams = groupModal->OnClickOutParams;
				mwi.ModalExitKeyPushed = groupModal->ExitKeyPushed;
				// update coords of the modal
				if(groupModal->SpawnOnMousePos)
				{
					groupModal->SpawnMouseX = _Pointer->getX();
					groupModal->SpawnMouseY = _Pointer->getY();
				}
			}
			else
			{
				// default for group not modal. Backward compatibility
				mwi.ModalExitClickOut = false;
				mwi.ModalExitClickL = false;
				mwi.ModalExitClickR = false;
				mwi.ModalExitKeyPushed = false;
			}

			_ModalStack.push_back(mwi);

			// update coords and activate the modal
			mwi.ModalWindow->invalidateCoords();
			mwi.ModalWindow->setActive(true);
			setTopWindow(mwi.ModalWindow);
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::pushModalWindow(CCtrlBase *ctrlLaunchingModal, const std::string &groupName)
	{
		CInterfaceGroup	*group= dynamic_cast<CGroupModal*>( getElementFromId(groupName) );
		if(group)
		{
			// enable the modal
			enableModalWindow(ctrlLaunchingModal, group);
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::popModalWindow()
	{
		if (!_ModalStack.empty())
		{
			SModalWndInfo winInfo = _ModalStack.back();
			_ModalStack.pop_back(); // must pop back as early as possible because 'setActive' may trigger another 'popModalWindow', leading to a crash
			if(winInfo.ModalWindow)
			{
				setBackWindow(winInfo.ModalWindow);
				winInfo.ModalWindow->setActive(false);
			}
			if (!_ModalStack.empty())
			{
				if(_ModalStack.back().ModalWindow)
				{
					_ModalStack.back().ModalWindow->setActive(true);
					setTopWindow(_ModalStack.back().ModalWindow);
				}
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::popModalWindowCategory(const std::string &category)
	{
		for(;;)
		{
			if (_ModalStack.empty()) break;
			if (!_ModalStack.back().ModalWindow) break;
			CGroupModal *gm = dynamic_cast<CGroupModal *>((CInterfaceGroup*)(_ModalStack.back().ModalWindow));
			if (gm && gm->Category == category)
			{
				_ModalStack.back().ModalWindow->setActive(false);
				_ModalStack.pop_back();
			}
			else
			{
				break;
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getWindowUnder (sint32 x, sint32 y)
	{
		H_AUTO (RZ_Interface_Window_Under )

		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
				{
					const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
					std::list<CInterfaceGroup*>::const_reverse_iterator itw;
					for (itw = rList.rbegin(); itw != rList.rend(); itw++)
					{
						CInterfaceGroup *pIG = *itw;
						if (pIG->getActive() && pIG->getUseCursor())
						{
							if (pIG->isWindowUnder (x, y))
								return pIG;
						}
					}
				}
			}
		}
		return NULL;
	}

	// ------------------------------------------------------------------------------------------------
	CInterfaceGroup* CWidgetManager::getGroupUnder (sint32 x, sint32 y)
	{
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
				{
					const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
					std::list<CInterfaceGroup*>::const_reverse_iterator itw;
					for (itw = rList.rbegin(); itw != rList.rend(); itw++)
					{
						CInterfaceGroup *pIG = *itw;
						if (pIG->getActive() && pIG->getUseCursor())
						{
							CInterfaceGroup *pIGunder = pIG->getGroupUnder (x ,y);
							if (pIGunder != NULL)
								return pIGunder;
						}
					}
				}
			}
		}
		return NULL;
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::getViewsUnder (sint32 x, sint32 y, std::vector<CViewBase*> &vVB)
	{
		vVB.clear ();

		// No Op if screen minimized
		if(CViewRenderer::getInstance()->isMinimized())
			return;

		uint32 sw, sh;
		CViewRenderer::getInstance()->getScreenSize(sw, sh);
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0; nPriority--)
				{
					const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
					std::list<CInterfaceGroup*>::const_reverse_iterator itw;
					for (itw = rList.rbegin(); itw != rList.rend(); itw++)
					{
						CInterfaceGroup *pIG = *itw;

						// Accecpt if not modal clip
						if (pIG->getActive() && pIG->getUseCursor())
						{
							if (pIG->getViewsUnder (x, y, 0, 0, (sint32) sw, (sint32) sh, vVB))
								return ;
						}
					}
				}
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::getCtrlsUnder (sint32 x, sint32 y, std::vector<CCtrlBase*> &vICL)
	{
		vICL.clear ();

		// No Op if screen minimized
		if(CViewRenderer::getInstance()->isMinimized())
			return;

		uint32 sw, sh;
		CViewRenderer::getInstance()->getScreenSize(sw, sh);
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0 ; nPriority--)
				{
					const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
					std::list<CInterfaceGroup*>::const_reverse_iterator itw;
					for (itw = rList.rbegin(); itw != rList.rend(); itw++)
					{
						CInterfaceGroup *pIG = *itw;

						// Accecpt if not modal clip
						if (!CWidgetManager::getInstance()->hasModal() || CWidgetManager::getInstance()->getModal().ModalWindow == pIG || CWidgetManager::getInstance()->getModal().ModalExitClickOut)
						if (pIG->getActive() && pIG->getUseCursor())
						{
							if (pIG->getCtrlsUnder (x, y, 0, 0, (sint32) sw, (sint32) sh, vICL))
								return;
						}
					}
				}
			}
		}
	}


	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::getGroupsUnder (sint32 x, sint32 y, std::vector<CInterfaceGroup *> &vIGL)
	{
		vIGL.clear ();

		// No Op if screen minimized
		if(CViewRenderer::getInstance()->isMinimized())
			return;

		uint32 sw, sh;
		CViewRenderer::getInstance()->getScreenSize(sw, sh);
		for (uint32 nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
		{
			CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
			if (rMG.Group->getActive())
			{
				for (uint8 nPriority = WIN_PRIORITY_MAX; nPriority > 0 ; nPriority--)
				{
					const std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority-1];
					std::list<CInterfaceGroup*>::const_reverse_iterator itw;
					for (itw = rList.rbegin(); itw != rList.rend(); itw++)
					{
						CInterfaceGroup *pIG = *itw;

						// Accecpt if not modal clip
						if (!CWidgetManager::getInstance()->hasModal() || CWidgetManager::getInstance()->getModal().ModalWindow == pIG ||
							CWidgetManager::getInstance()->getModal().ModalExitClickOut)
						if (pIG->getActive() && pIG->getUseCursor())
						{
							if (pIG->isIn(x, y))
							{
								vIGL.push_back(pIG);
								pIG->getGroupsUnder (x, y, 0, 0, (sint32) sw, (sint32) sh, vIGL);
								return;
							}
						}
					}
				}
			}
		}
	}


	// ***************************************************************************
	void CWidgetManager::removeRefOnView( CViewBase *viewBase )
	{
		uint i;
		for (i=0; i<_ViewsUnderPointer.size(); i++)
		{
			if (_ViewsUnderPointer[i] == viewBase)
			{
				_ViewsUnderPointer.erase (_ViewsUnderPointer.begin()+i);
				i--;
			}
		}
	}

	// ***************************************************************************
	void CWidgetManager::removeRefOnCtrl(CCtrlBase *ctrlBase)
	{
		if ( getCurContextHelp()  == ctrlBase)
			setCurContextHelp( NULL );
		if (getCapturePointerLeft() == ctrlBase)
			setCapturePointerLeft(NULL);
		if (getCapturePointerRight() == ctrlBase)
			setCapturePointerRight (NULL);
		if (getCaptureKeyboard() == ctrlBase)
			setCaptureKeyboard(NULL);
		if (getOldCaptureKeyboard() == ctrlBase)
			setOldCaptureKeyboard(NULL);
		if (getDefaultCaptureKeyboard() == ctrlBase)
			setDefaultCaptureKeyboard(NULL);
		uint i;
		for (i=0; i<_CtrlsUnderPointer.size(); i++)
		{
			if (_CtrlsUnderPointer[i] == ctrlBase)
			{
				_CtrlsUnderPointer.erase (_CtrlsUnderPointer.begin()+i);
				i--;
			}
		}

		// Unregister from ClockMsgTargets
		unregisterClockMsgTarget(ctrlBase);
	}


	// ***************************************************************************
	void CWidgetManager::removeRefOnGroup (CInterfaceGroup *group)
	{
		uint i;
		for (i=0; i<_GroupsUnderPointer.size(); i++)
		{
			if (_GroupsUnderPointer[i] == group)
			{
				_GroupsUnderPointer.erase (_GroupsUnderPointer.begin()+i);
				i--;
			}
		}
	}


	void CWidgetManager::reset()
	{
		setCurContextHelp( NULL );
		
		_ViewsUnderPointer.clear();
		_CtrlsUnderPointer.clear();
		_GroupsUnderPointer.clear();

		_CaptureKeyboard = NULL;
		_OldCaptureKeyboard = NULL;
		setCapturePointerLeft(NULL);
		setCapturePointerRight(NULL);
		
		resetColorProps();

		_AlphaRolloverSpeedDB = NULL;
	}


	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::checkCoords()
	{
		H_AUTO ( RZ_Interface_validateCoords )

		uint32 nMasterGroup;

		{
			H_AUTO ( RZ_Interface_checkCoords )

			// checkCoords all the windows
			for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
			{
				CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
				if (rMG.Group->getActive())
				{
					for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
					{
						std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
						std::list<CInterfaceGroup*>::const_iterator itw;
						for (itw = rList.begin(); itw!= rList.end();)
						{
							CInterfaceGroup *pIG = *itw;
							itw++;	// since checkCoords invalidate the iterator, be sure we move to the next one before
							if (pIG->getActive())
								pIG->checkCoords ();
						}
					}
				}
			}
		}

		bool bRecomputeCtrlUnderPtr = false;
		{
			H_AUTO ( RZ_Interface_updateCoords )

			// updateCoords all the needed windows
			for (nMasterGroup = 0; nMasterGroup < _MasterGroups.size(); nMasterGroup++)
			{
				CWidgetManager::SMasterGroup &rMG = _MasterGroups[nMasterGroup];
				if (rMG.Group->getActive())
				{
					for (uint8 nPriority = 0; nPriority < WIN_PRIORITY_MAX; nPriority++)
					{
						std::list<CInterfaceGroup*> &rList = rMG.PrioritizedWindows[nPriority];
						std::list<CInterfaceGroup*>::const_iterator itw;
						for (itw = rList.begin(); itw!= rList.end(); itw++)
						{
							CInterfaceGroup *pIG = *itw;
							bool		updateCoordCalled= false;
							// updateCoords the window only if the master group is his parent and if need it
							// do it until updateCoords() no more invalidate coordinates!!
							while (pIG->getParent()==rMG.Group && (pIG->getInvalidCoords()>0))
							{
								bRecomputeCtrlUnderPtr = true;
								// Update as many pass wanted (3 time for complex resizing, 1 for scroll for example)
								uint	numPass= pIG->getInvalidCoords();
								// reset before updateCoords
								pIG->resetInvalidCoords();
								for(uint i=0;i<numPass;i++)
								{
									pIG->updateCoords ();
								}
								updateCoordCalled= true;
							}
							// If the group need to update pos each frame (eg: CGroupInScene),
							// and updateCoords not called
							if(pIG->getParent()==rMG.Group && !updateCoordCalled && pIG->isNeedFrameUpdatePos())
							{
								// This Group will compute the delta to apply.
								pIG->onFrameUpdateWindowPos(0,0);
							}
						}
					}
				}
			}

			if ( CWidgetManager::getInstance()->getPointer() != NULL)
				CWidgetManager::getInstance()->getPointer()->updateCoords();
		}



		if (bRecomputeCtrlUnderPtr)
		{
			H_AUTO ( RZ_Interface_RecomputeCtrlUnderPtr )
			if ( CWidgetManager::getInstance()->getPointer() != NULL )
			{
				sint32 mx = _Pointer->getX();
				sint32 my = _Pointer->getY();
				getViewsUnder (mx, my, _ViewsUnderPointer);
				getCtrlsUnder (mx, my, _CtrlsUnderPointer);
				getGroupsUnder (mx, my, _GroupsUnderPointer);
				CInterfaceGroup *ptr = getWindowUnder (mx, my);
				_WindowUnder = ptr;
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::movePointer (sint32 dx, sint32 dy)
	{
		if (!_Pointer)
			return;

		uint32 nScrW, nScrH;
		sint32 oldpx, oldpy, newpx, newpy, disppx, disppy, olddisppx, olddisppy;

		CViewRenderer::getInstance()->getScreenSize (nScrW, nScrH);
		_Pointer->getPointerPos (oldpx, oldpy);

		olddisppx = oldpx;
		olddisppy = oldpy;

		newpx = oldpx + dx;
		newpy = oldpy + dy;

		if (newpx < 0) newpx = 0;
		if (newpy < 0) newpy = 0;
		if (newpx > (sint32)nScrW) newpx = nScrW;
		if (newpy > (sint32)nScrH) newpy = nScrH;
		dx = newpx - oldpx;
		dy = newpy - oldpy;

		disppx = newpx;
		disppy = newpy;

		_Pointer->setPointerPos (newpx, newpy);
		_Pointer->setPointerDispPos (disppx, disppy);

		// must get back coordinates because of snapping
		sint32 mx = _Pointer->getX();
		sint32 my = _Pointer->getY();
		getViewsUnder (mx, my, _ViewsUnderPointer);
		getCtrlsUnder (mx, my, _CtrlsUnderPointer);
		getGroupsUnder (mx, my, _GroupsUnderPointer);
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::movePointerAbs(sint32 px, sint32 py)
	{
		if(!CWidgetManager::getInstance()->getPointer())
			return;

		uint32 nScrW, nScrH;
		CViewRenderer::getInstance()->getScreenSize (nScrW, nScrH);
		NLMISC::clamp(px, 0, (sint32) nScrW);
		NLMISC::clamp(py, 0, (sint32) nScrH);
		//
		_Pointer->setPointerPos (px, py);
		_Pointer->setPointerDispPos (px, py);
		//
		getViewsUnder (px, py, _ViewsUnderPointer);
		getCtrlsUnder (px, py, _CtrlsUnderPointer);
		getGroupsUnder (px, py, _GroupsUnderPointer);
	}

	// ***************************************************************************
	void CWidgetManager::setCapturePointerLeft(CCtrlBase *c)
	{
		// additionally, abort any dragging
		if( CCtrlDraggable::getDraggedSheet() != NULL )
			CCtrlDraggable::getDraggedSheet()->abortDragging();

		_CapturePointerLeft = c;
		notifyElementCaptured(c);
	}

	// ***************************************************************************
	void CWidgetManager::setCapturePointerRight(CCtrlBase *c)
	{
		_CapturePointerRight = c;
		notifyElementCaptured(c);
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::setCaptureKeyboard(CCtrlBase *c)
	{
		CGroupEditBoxBase *oldEb= dynamic_cast<CGroupEditBoxBase*>((CCtrlBase*)_CaptureKeyboard);
		CGroupEditBoxBase *newEb= dynamic_cast<CGroupEditBoxBase*>(c);

		if (_CaptureKeyboard && _CaptureKeyboard != c)
		{
			_CaptureKeyboard->onKeyboardCaptureLost();
		}
		// If the old capturedKeyboard is an editBox and allow recoverFocusOnEnter
		if ( oldEb && oldEb->getRecoverFocusOnEnter() )
		{
			_OldCaptureKeyboard = _CaptureKeyboard;
		}
		if ( newEb )
		{
			CGroupEditBoxBase::disableSelection();

			if (!newEb->getAHOnFocus().empty())
			{
				CAHManager::getInstance()->runActionHandler(newEb->getAHOnFocus(), newEb, newEb->getAHOnFocusParams());
			}

		}
		_CaptureKeyboard = c;
		notifyElementCaptured(c);
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::resetCaptureKeyboard()
	{
		CCtrlBase *captureKeyboard = _CaptureKeyboard;
		_OldCaptureKeyboard = NULL;
		_CaptureKeyboard = NULL;
		if (captureKeyboard)
		{
			captureKeyboard->onKeyboardCaptureLost();
		}
	}

	// ***************************************************************************
	void CWidgetManager::registerClockMsgTarget(CCtrlBase *vb)
	{
		if (!vb) return;
		if (isClockMsgTarget(vb))
		{
			nlwarning("<CInterfaceManager::registerClockMsgTarget> Element %s is already registered", vb->getId().c_str());
			return;
		}
		_ClockMsgTargets.push_back(vb);
	}

	// ***************************************************************************
	void CWidgetManager::unregisterClockMsgTarget(CCtrlBase *vb)
	{
		if (!vb) return;
		std::vector<CCtrlBase*>::iterator it = std::find(_ClockMsgTargets.begin(), _ClockMsgTargets.end(), vb);
		if (it != _ClockMsgTargets.end())
		{
			_ClockMsgTargets.erase(it);
		}
	}

	// ***************************************************************************
	bool CWidgetManager::isClockMsgTarget(CCtrlBase *vb) const
	{
		std::vector<CCtrlBase*>::const_iterator it = std::find(_ClockMsgTargets.begin(), _ClockMsgTargets.end(), vb);
		return it != _ClockMsgTargets.end();
	}

	void CWidgetManager::sendClockTickEvent()
	{
		NLGUI::CEventDescriptorSystem clockTick;
		clockTick.setEventTypeExtended(NLGUI::CEventDescriptorSystem::clocktick);

		if (_CapturePointerLeft)
		{
			_CapturePointerLeft->handleEvent(clockTick);
		}
		if (_CapturePointerRight)
		{
			_CapturePointerRight->handleEvent(clockTick);
		}

		// and send clock tick msg to ctrl that are registered
		std::vector<CCtrlBase*> clockMsgTarget = _ClockMsgTargets;
		for(std::vector<CCtrlBase*>::iterator it = clockMsgTarget.begin(); it != clockMsgTarget.end(); ++it)
		{
			(*it)->handleEvent(clockTick);
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::notifyElementCaptured(CCtrlBase *c)
	{
		std::set<CCtrlBase *> seen;
		CCtrlBase *curr = c;
		while (curr)
		{
			seen.insert(curr);
			curr->elementCaptured(c);
			curr = curr->getParent();
		}
		// also warn the ctrl under the pointer
		for (uint i = 0; i < (uint) _CtrlsUnderPointer.size(); ++i)
		{
			if (!seen.count(_CtrlsUnderPointer[i]))
			{
				_CtrlsUnderPointer[i]->elementCaptured(c);
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::makeWindow(CInterfaceGroup *group)
	{
		if(!group)
			return;

		uint32 i = 0;
		for (i = 0; i < _MasterGroups.size(); ++i)
		{
			if (_MasterGroups[i].Group == group->getParent())
					break;
		}

		if (i == _MasterGroups.size())
		{
			std::string stmp = std::string("not found master group for window: ")+group->getId();
			nlwarning (stmp.c_str());
			return;
		}
		else
		{
			// check if group hasn't been inserted twice.
			if (_MasterGroups[i].isWindowPresent(group))
			{
				nlwarning("Window inserted twice");
			}
			else
			{
				_MasterGroups[i].addWindow(group,group->getPriority());
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::unMakeWindow(CInterfaceGroup *group, bool noWarning)
	{
		if (!group)
			return;

		uint32 i = 0;
		for (i = 0; i < _MasterGroups.size(); ++i)
		{
			if (_MasterGroups[i].Group == group->getParent())
					break;
		}

		if (i == _MasterGroups.size())
		{
			if (!noWarning)
			{
				std::string stmp = std::string("not found master group for window: ")+group->getId();
				nlwarning (stmp.c_str());
			}
			return;
		}
		else
		{
			// check if group hasn't been inserted twice.
			if (!_MasterGroups[i].isWindowPresent(group))
			{
				if (!noWarning)
					nlwarning("Window not inserted in master group");
			}
			else
			{
				_MasterGroups[i].delWindow(group);
			}
		}
	}

	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::setGlobalColor (NLMISC::CRGBA col)
	{
		if (!_RProp)
		{
			_RProp = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:R");
			_GProp = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:G");
			_BProp = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:B");
			_AProp = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:COLOR:A");
		}
		_RProp ->setValue32 (col.R);
		_GProp ->setValue32 (col.G);
		_BProp ->setValue32 (col.B);
		_AProp ->setValue32 (col.A);

		_GlobalColor = col;

		// set the global color for content (the same with modulated alpha)
		_GlobalColorForContent = _GlobalColor;
		_GlobalColorForContent.A = (uint8) (( (uint16) _GlobalColorForContent.A * (uint16) _ContentAlpha) >> 8);
	}

	// ***************************************************************************
	void CWidgetManager::setContentAlpha(uint8 alpha)
	{
		_ContentAlpha = alpha;
		// update alpha of global color
		_GlobalColorForContent.A = alpha;/*(uint8) (( (uint16) _GlobalColor.A * (uint16) _ContentAlpha) >> 8);*/
	}

	void CWidgetManager::resetColorProps()
	{
		_RProp = NULL;
		_GProp = NULL;
		_BProp = NULL;
		_AProp = NULL;
	}

	// ------------------------------------------------------------------------------------------------
	CInterfaceOptions* CWidgetManager::getOptions( const std::string &name )
	{
		std::map< std::string, NLMISC::CSmartPtr< CInterfaceOptions > >::iterator it = _OptionsMap.find( name );
		if( it == _OptionsMap.end() )
			return NULL;
		else
			return it->second;
	}

	void CWidgetManager::addOptions( std::string name, CInterfaceOptions *options )
	{
		_OptionsMap.insert( std::map< std::string, CInterfaceOptions* >::value_type( name, options ) );
	}

	void CWidgetManager::removeOptions( std::string name )
	{
		_OptionsMap.erase( name );
	}

	void CWidgetManager::removeAllOptions()
	{
		_OptionsMap.clear();
	}
	
	
	// ***************************************************************************
	void CWidgetManager::enableMouseHandling( bool handle )
	{
		_MouseHandlingEnabled = handle;
		if(!handle)
		{
			if(!getPointer())
				return;
			
			// If Left captured, reset
			if( getCapturePointerLeft() )
				setCapturePointerLeft( NULL );

			// Same for Right
			if( getCapturePointerRight() )
				setCapturePointerRight( NULL );
			
			// Avoid any problem with modals
			disableModalWindow();
		}
	}
	
	// ***************************************************************************
	uint CWidgetManager::getUserDblClickDelay()
	{
		uint nVal = 50;
		NLMISC::CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:DOUBLE_CLICK_SPEED");
		if( pNL != NULL )
			nVal = pNL->getValue32();
		
		uint dbclickDelay = (uint)(DOUBLE_CLICK_MIN + (DOUBLE_CLICK_MAX-DOUBLE_CLICK_MIN) * (float)nVal / 100.0f);
		return dbclickDelay;
	}
	
	// ------------------------------------------------------------------------------------------------
	void CWidgetManager::setupOptions()
	{
		// After parsing options and templates node -> init system options.
		CInterfaceOptions *opt = getOptions( "system" );
		if( opt != NULL )
		{
			// List here all Special options
			_SystemOptions[OptionCtrlSheetGrayColor]= opt->getValue("ctrl_sheet_gray_color");
			_SystemOptions[OptionCtrlTextGrayColor]= opt->getValue("ctrl_text_gray_color");
			_SystemOptions[OptionCtrlSheetRedifyColor]= opt->getValue("ctrl_sheet_redify_color");
			_SystemOptions[OptionCtrlTextRedifyColor]= opt->getValue("ctrl_text_redify_color");
			_SystemOptions[OptionCtrlSheetGreenifyColor]= opt->getValue("ctrl_sheet_greenify_color");
			_SystemOptions[OptionCtrlTextGreenifyColor]= opt->getValue("ctrl_text_greenify_color");
			_SystemOptions[OptionViewTextOverBackColor]= opt->getValue("text_over_back_color");
			_SystemOptions[OptionFont]= opt->getValue("font");
			_SystemOptions[OptionAddCoefFont]= opt->getValue("add_coef_font");
			_SystemOptions[OptionMulCoefAnim]= opt->getValue("mul_coef_anim");
			_SystemOptions[OptionTimeoutBubbles]= opt->getValue("bubbles_timeout");
			_SystemOptions[OptionTimeoutMessages]= opt->getValue("messages_timeout");
			_SystemOptions[OptionTimeoutContext]= opt->getValue("context_timeout");
			_SystemOptions[OptionTimeoutContextHtml]= opt->getValue("context_html_timeout");
		}
		
	}
	
	// Get the alpha roll over speed
	float CWidgetManager::getAlphaRolloverSpeed()
	{
		if( _AlphaRolloverSpeedDB == NULL )
			_AlphaRolloverSpeedDB = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:ALPHA_ROLLOVER_SPEED");
		float fTmp = ROLLOVER_MIN_DELTA_PER_MS + (ROLLOVER_MAX_DELTA_PER_MS - ROLLOVER_MIN_DELTA_PER_MS) * 0.01f * (100 - _AlphaRolloverSpeedDB->getValue32());
		return fTmp*fTmp*fTmp;
	}

	void CWidgetManager::resetAlphaRolloverSpeed()
	{
		_AlphaRolloverSpeedDB = NULL;
	}
	
	void CWidgetManager::setContainerAlpha(uint8 alpha)
	{
		_ContainerAlpha = alpha;
		// update alpha of global color
		NLMISC::CRGBA c = getGlobalColor();
		c.A = alpha;/*(uint8) (( (uint16) _GlobalColor.A * (uint16) _ContainerAlpha) >> 8);	*/
		setGlobalColor( c );
	}

	void CWidgetManager::updateGlobalAlphas()
	{
		_GlobalContentAlpha = (uint8)NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CONTENT_ALPHA")->getValue32();
		_GlobalContainerAlpha = (uint8)NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CONTAINER_ALPHA")->getValue32();
		_GlobalRolloverFactorContent = (uint8)NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CONTENT_ROLLOVER_FACTOR")->getValue32();
		_GlobalRolloverFactorContainer = (uint8)NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CONTAINER_ROLLOVER_FACTOR")->getValue32();
	}

	CWidgetManager::CWidgetManager()
	{
		_Pointer = NULL;
		curContextHelp = NULL;

		resetColorProps();

		_GlobalColor = NLMISC::CRGBA(255,255,255,255);
		_GlobalColorForContent = _GlobalColor;
		_ContentAlpha = 255;
		_ContainerAlpha = 255;
		_GlobalContentAlpha = 255;
		_GlobalContainerAlpha = 255;
		_GlobalRolloverFactorContent = 255;
		_GlobalRolloverFactorContainer = 255;
		_AlphaRolloverSpeedDB = NULL;

		_MouseHandlingEnabled = true;
	}

	CWidgetManager::~CWidgetManager()
	{
		for (uint32 i = 0; i < _MasterGroups.size(); ++i)
		{
			delete _MasterGroups[i].Group;
		}

		_Pointer = NULL;
		curContextHelp = NULL;
	}

}