// 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 "stdpch.h"
#include "interface_manager.h"
#include "nel/gui/interface_expr.h"
#include "group_menu.h"
#include "nel/misc/xml_auto_ptr.h"
#include "nel/gui/view_bitmap.h"
#include "nel/gui/action_handler.h" // Just for getAllParams
#include "nel/gui/lua_ihm.h"
#include "lua_ihm_ryzom.h"

#include "nel/misc/i18n.h"

using namespace NLMISC;
using namespace std;


static const std::string ID_MENU_CHECKBOX  = "menu_cb";
static const std::string ID_MENU_SEPARATOR = "menu_separator";
static const std::string ID_MENU_SUBMENU = "menu_sb";

static const uint MENU_WIDGET_X = 2;
static const uint LEFT_MENU_WIDGET_X = 4;

// ------------------------------------------------------------------------------------------------
// CGroupSubMenu
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
bool CViewTextMenu::getGrayed() const
{
	return _Grayed;
}

// ------------------------------------------------------------------------------------------------
void CViewTextMenu::setGrayed (bool g)
{
	_Grayed = g;
}

// ------------------------------------------------------------------------------------------------
void CViewTextMenu::setCheckable(bool c)
{
	if (!c)
	{
		_Checkable = false;
		_CheckBox = NULL;
	}
	else
	{
		_Checkable = true;
	}
}

// ------------------------------------------------------------------------------------------------
void CViewTextMenu::setChecked(bool c)
{
	if (_CheckBox)
	{
		CInterfaceOptions *pIO = CWidgetManager::getInstance()->getOptions("menu_checkbox");
		if (!pIO) return;
		_CheckBox->setTexture(pIO->getValStr(c ? "checked_bitmap" : "unchecked_bitmap"));
	}
	_Checked = c;
}

// ------------------------------------------------------------------------------------------------
sint32 CViewTextMenu::getAlpha() const
{
	if (_Grayed)
	{
		return OldColorGrayed.A;
	}
	else
	{
		if (Over)
			return OldColorOver.A;
		else
			return OldColor.A;
	}
}

// ------------------------------------------------------------------------------------------------
void CViewTextMenu::setAlpha (sint32 a)
{
	OldShadowColor.A = OldColor.A = (uint8)a;
	OldShadowColorOver.A = OldColorOver.A = (uint8)a;
	OldShadowColorGrayed.A = OldShadowColorGrayed.A = (uint8)a;
}

// ------------------------------------------------------------------------------------------------
// CGroupSubMenu
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
CGroupSubMenu::CGroupSubMenu(const TCtorParam &param)
: CGroupSubMenuBase(param)
{
	_SelectionView = NULL;
	_GroupList = NULL;
	_GroupMenu = NULL;
	_Selected = -1;
	_MaxVisibleLine = -1;
	_ScrollBar = NULL;
}

// ------------------------------------------------------------------------------------------------
CGroupSubMenu::~CGroupSubMenu()
{
	removeAllUserGroups();
}

// ------------------------------------------------------------------------------------------------
sint CGroupSubMenu::getLineFromId(const std::string &id)
{
	for (uint k = 0; k < _Lines.size(); ++k)
	{
		if (_Lines[k].Id == id)
		{
			return (sint) k;
		}
	}
	return -1;
}

// ------------------------------------------------------------------------------------------------
CGroupSubMenu *CGroupSubMenu::getSubMenu(uint index) const
{
	if (index >= _SubMenus.size())
	{
		nlassert("bad index");
		return NULL;
	}
	return _SubMenus[index];
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setSubMenu(uint index, CGroupSubMenu *sub)
{
	nlassert(sub != NULL);
	nlassert(index < _SubMenus.size());

	if (_SubMenus[index] != NULL)
	{
		// must delete from the group menu (if not found, just delete)
		if( !_GroupMenu || !_GroupMenu->delGroup(_SubMenus[index]) )
			delete _SubMenus[index];
		_SubMenus[index] = NULL;
		delView(_Lines[index].RightArrow);
	}

	if (_Lines[index].CheckBox)
		_Lines[index].RightArrow = createRightArrow(_Lines[index].CheckBox, true);
	else
		_Lines[index].RightArrow = createRightArrow(_GroupList, false);

	sub->_GroupMenu = _GroupMenu;
	sub->initOptions(this);
	_GroupMenu->addGroup (sub);
	sub->_DispType = _GroupMenu->_DispType;
	_SubMenus[index] = sub;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::initOptions(CInterfaceGroup *parent)
{
	// Initialization
	// me
	_Parent = _GroupMenu;
	if (parent == NULL)
	{
		setParentPos (_GroupMenu);
		setParentPosRef (Hotspot_TL);
		setPosRef (Hotspot_TL);
	}
	else
	{
		setParentPos (parent);
		setParentPosRef (Hotspot_BR);
		setPosRef (Hotspot_BL);
	}
	_DisplayFrame = true;
	_ResizeFromChildH = true;
	_ResizeFromChildW = true;
	_ResizeFromChildHMargin = 8;
	_ResizeFromChildWMargin = 8;
	_ModulateGlobalColor = _GroupMenu->_ModulateGlobalColor;
	// the selection
	if (_SelectionView == NULL)
	{
		_SelectionView = new CViewBitmap(CViewBase::TCtorParam());
//		CInterfaceManager *pIM = CInterfaceManager::getInstance();
//		CViewRenderer &rVR = *CViewRenderer::getInstance();
		_SelectionView->setParent (this);
		_SelectionView->setActive (false);
		_SelectionView->setTexture ("blank.tga");
		_SelectionView->setScale (true);
		_SelectionView->setX (4);
		_SelectionView->setSizeRef(1); // sizeref on W
		_SelectionView->setW (-8);
		addView (_SelectionView, 0);
	}
	// the group list
	if (_GroupList == NULL)
	{
		_GroupList = new CGroupList(CViewBase::TCtorParam());
		_GroupList->setParent (this);
		_GroupList->setParentPos (this);
		_GroupList->setX (4);
		_GroupList->setY (4);
		_GroupList->setSpace (_GroupMenu->_Space);
		addGroup (_GroupList);
	}
}

// ------------------------------------------------------------------------------------------------
bool CGroupSubMenu::parse (xmlNodePtr cur,  CInterfaceGroup *parent)
{
	initOptions(parent);
	CInterfaceManager *im = CInterfaceManager::getInstance();
	// the children
	while (cur)
	{
		CViewTextMenu *pV = NULL;

		CXMLAutoPtr id((const char*) xmlGetProp (cur,  (xmlChar*)"id"));

		if (stricmp((char*)cur->name, "separator") == 0)
		{
			if (id)
			{
				addSeparator((const char *) id);
			}
			else
			{
				addSeparator();
			}
		}
		else
		if (stricmp((char*)cur->name, "action") == 0)
		{
			string		strId,  strAh,  strParams,  strCond, strTexture="";
			ucstring	ucstrName;

			if (id)		strId = (const char*)id;
			CXMLAutoPtr name((const char*) xmlGetProp (cur,  (xmlChar*)"name"));

			if (name)
			{
				const char *ptrName = (const char*)name;
				ucstrName = ucstring(ptrName);
				if ((strlen(ptrName)>2) && (ptrName[0] == 'u') && (ptrName[1] == 'i'))
					ucstrName = CI18N::get (ptrName);
			}

			CXMLAutoPtr ah((const char*) xmlGetProp (cur,  (xmlChar*)"handler"));
			if (ah)		strAh = (const char*)ah;
			CXMLAutoPtr cond((const char*) xmlGetProp (cur,  (xmlChar*)"cond"));
			if (cond)	strCond = (const char*)cond;
			CXMLAutoPtr params((const char*) xmlGetProp (cur,  (xmlChar*)"params"));
			if (params)	strParams = (const char*)params;
			CXMLAutoPtr strCheckable((const char*) xmlGetProp (cur,  (xmlChar*)"checkable"));
			bool bCheckable = false;
			if (strCheckable)	bCheckable = convertBool (strCheckable);
			CXMLAutoPtr strChecked((const char*) xmlGetProp (cur,  (xmlChar*)"checked"));
			bool bChecked = false;
			if (strChecked)	bChecked = convertBool (strChecked);
			bool bFormatted = false;
			CXMLAutoPtr strFormatted((const char*) xmlGetProp (cur,  (xmlChar*)"formatted"));
			if (strFormatted)	bFormatted = convertBool (strFormatted);

			pV = addLine (ucstrName, strAh, strParams, strId, strCond, strTexture, bCheckable, bChecked, bFormatted);

			CXMLAutoPtr strSelectable((const char*) xmlGetProp (cur,  (xmlChar*)"selectable"));
			bool bSelectable = true;
			if (strSelectable)	bSelectable = convertBool (strSelectable);
			_Lines.back().Selectable = bSelectable;


			CXMLAutoPtr grayed((const char*) xmlGetProp (cur,  (xmlChar*)"grayed"));
			bool bGrayed = false;
			if (grayed)	bGrayed = convertBool (grayed);
			pV->setGrayed(bGrayed);

			// Is this line has a sub menu ?
			xmlNodePtr child = cur->children;
			if (child != NULL)
			{
				if (_Lines.back().CheckBox)
				{
					_Lines.back().RightArrow = createRightArrow(_Lines.back().CheckBox, true);
				}
				else
				{
					_Lines.back().RightArrow = createRightArrow(_GroupList, false);
				}
				// and create the sub menu
				CGroupSubMenu *childMenu = new CGroupSubMenu(CViewText::TCtorParam());
				childMenu->_GroupMenu = _GroupMenu;
				childMenu->parse (child,  this);

				CXMLAutoPtr MVL((const char*) xmlGetProp(cur,  (xmlChar*)"max_visible_line"));
				if (MVL)
				{
					sint32 maxVisibleLine;
					fromString((const char*)MVL, maxVisibleLine);
					childMenu->setMaxVisibleLine(maxVisibleLine);
				}

				_SubMenus.back() = childMenu;
			}

			// Add user groups
			// Left
			CXMLAutoPtr usergroup((const char*) xmlGetProp (cur,  (xmlChar*)"usergroup_l"));
			if (usergroup)
			{
				vector< pair<string,string> > vparams;
				CXMLAutoPtr ugparams((const char*) xmlGetProp (cur,  (xmlChar*)"usergroup_params_l"));
				if (ugparams)
				{
					IActionHandler::getAllParams((const char*)ugparams, vparams);
				}

				string completeId = _Parent->getId() + ":" + _Lines[_Lines.size()-1].Id;
				CInterfaceGroup *pUGLeft = im->createGroupInstance((const char*)usergroup, completeId, vparams);
				if (pUGLeft)
					setUserGroupLeft((uint)_Lines.size()-1, pUGLeft, true);
			}
			usergroup = (char*) xmlGetProp (cur,  (xmlChar*)"usergroup_r");
			if (usergroup)
			{
				vector< pair<string,string> > vparams;
				CXMLAutoPtr ugparams((const char*) xmlGetProp (cur,  (xmlChar*)"usergroup_params_r"));
				if (ugparams)
				{
					IActionHandler::getAllParams((const char*)ugparams, vparams);
				}

				string completeId = _Parent->getId() + ":" + _Lines[_Lines.size()-1].Id;
				CInterfaceGroup *pUG = im->createGroupInstance((const char*)usergroup, completeId, vparams);
				if (pUG)
					setUserGroupRight((uint)_Lines.size()-1, pUG, true);
			}
		}
		cur = cur->next;
	}

	_GroupMenu->addGroup (this);
	this->_DispType = _GroupMenu->_DispType;

	return true;
}


// ------------------------------------------------------------------------------------------------
CViewBitmap *CGroupSubMenu::createCheckBox(bool checked)
{
	// Put the left arrow to the line
	CViewBitmap *pVB = new CViewBitmap(CViewBase::TCtorParam());
	pVB->setParent (this);
	pVB->setParentPos (_GroupList);
	pVB->setParentPosRef (Hotspot_BR);
	pVB->setPosRef (Hotspot_BL);
	CInterfaceOptions *pIO = CWidgetManager::getInstance()->getOptions("menu_checkbox");
	if (pIO)
	{
		pVB->setTexture(pIO->getValStr(checked ? "checked_bitmap" : "unchecked_bitmap"));
	}
	pVB->setX (MENU_WIDGET_X);
	pVB->setId (ID_MENU_CHECKBOX); // always rescale to parent in update coords
	addView (pVB);
	return pVB;
}


// ------------------------------------------------------------------------------------------------
CViewBitmap	   *CGroupSubMenu::createRightArrow(CInterfaceElement *parentPos, bool center)
{
	// Put the left arrow to the line
	CViewBitmap *pVB = new CViewBitmap(CViewBase::TCtorParam());
	pVB->setParent (this);
	pVB->setParentPos (parentPos);
	if (!center)
	{
		pVB->setParentPosRef (Hotspot_BR);
		pVB->setPosRef (Hotspot_BL);
	}
	else
	{
		pVB->setParentPosRef (Hotspot_MR);
		pVB->setPosRef (Hotspot_ML);
	}
	pVB->setTexture("w_arrow_right_3.tga");
	pVB->setX (MENU_WIDGET_X);
	pVB->setId (ID_MENU_SUBMENU); // rescale to parent in update coords if asked (not needed if there's already on the left a checkbox)
	addView (pVB);
	return pVB;
}

// ------------------------------------------------------------------------------------------------
#define GET_REF_ELM(__index__)	\
	CInterfaceElement	*refElm;						\
	sint32				refElmYReal= 0;					\
	sint32				refElmHReal= 0;					\
	refElm = _Lines[__index__].ViewText;				\
	if(refElm)											\
	{													\
		refElmYReal= refElm->getYReal() - _Lines[__index__].TextDY;	\
		refElmHReal= _Lines[__index__].HReal;			\
	}

void CGroupSubMenu::updateCoords ()
{
	if (_ParentPos == _GroupMenu)
	{
		// Root Menu
		setX(_GroupMenu->SpawnMouseX);
		setY(_GroupMenu->SpawnMouseY);
		CGroupFrame::updateCoords();

		CViewRenderer &rVR = *CViewRenderer::getInstance();
		uint32 screenW, screenH;
		rVR.getScreenSize(screenW, screenH);
		if ((_XReal+_WReal) > (sint32)screenW)
			setX(screenW-_WReal);
		if (_YReal < 0)
			setY(_HReal);
	}
	else
	// The sub menu may go outside the screen in Y. => clamp it as possible
	{
		/* X/Y coords have normally been updated before by "parent" sub menus
			Why? because setSubMenu() is typically called in "parent first" order (or it is exactly what is done in ::parse())
			=> Parent CGroupSubMenu::updateCoords() are called before their sons in CGroupMenu::updateCoords() !!!
			=> No Need to call _SubMenus[RALineNb]->updateCoords() below !  (else would call too much time because of recursion!!)
		*/

		// must udpate correct Real coords
		CGroupFrame::updateCoords();

		// get screen size
		CViewRenderer &rVR = *CViewRenderer::getInstance();
		uint32 screenW, screenH;
		rVR.getScreenSize(screenW, screenH);

		sint32	hReal= getHReal();
		// If the H is too big, abort.. can't do anything
		if(hReal<=(sint32)screenH)
		{
			sint32	yReal= getYReal();

			// compute the shift to apply to the Y of the sub menu, to respect (as possible) the screen
			sint32	dyClamp= 0;
			if(yReal<0)
				dyClamp= - yReal;
			if(yReal+hReal>(sint32)screenH)
				dyClamp= screenH - (yReal+hReal);
			// change then the Y
			if(dyClamp!=0)
			{
				setY(getY()+dyClamp);
				CGroupFrame::updateCoords();
			}
		}
	}

	// not yet setuped?
	if (!_GroupList) return;

	// get text dy position
	sint32	textDYPos= 0;
	textDYPos= -(1+_GroupList->getSpace())/2;

	// Set the arrows at the right positions (in _Views we have selection and the right arrows)
	sint32 CBLineNb = 0; // check box
	sint32 RALineNb = 0; // right arrow
	uint32 i;

	sint32 maxUserGroupWidth = 0;
	// compute max width of user groups, & adapt max height for each line
	uint k;

	// update all left user groups to get their width
	sint32 maxLeftUGWidth = 0;
	for(k = 0; k < _Lines.size(); ++k)
	{
		if (_Lines[k].UserGroupLeft)
		{
			_Lines[k].UserGroupLeft->updateCoords();
			maxLeftUGWidth = std::max(_Lines[k].UserGroupLeft->getWReal(), maxLeftUGWidth);
		}
	}

	_GroupList->setX(LEFT_MENU_WIDGET_X + maxLeftUGWidth);

	// active separators when needed
	bool activeLineSeen = false;
	for (i = 0; i < _Lines.size(); ++i)
	{
		if (_Lines[i].Separator != NULL)
		{
			if (i == _Lines.size() - 1)
			{
				_Lines[i].Separator->setActive(false);
				break;
			}
			_Lines[i].Separator->setActive(activeLineSeen);
			activeLineSeen = false;
		}
		else
		{
			if (_Lines[i].ViewText && _Lines[i].ViewText->getActive()) activeLineSeen = true;
		}
	}

	CGroupFrame::updateCoords();

	bool mustUpdate = false;

	if (_MaxVisibleLine > 0 && sint32(_Lines.size())>_MaxVisibleLine)
	{
		for(k = 0; k < _Lines.size(); ++k)
		if (_Lines[k].ViewText)
		{
			// compute max height of widgets on the left of text
			sint32 widgetMaxH = 0;
			if (_Lines[k].UserGroupRight)	widgetMaxH = _Lines[k].UserGroupRight->getHReal();
			if (_Lines[k].UserGroupLeft)	widgetMaxH = std::max(widgetMaxH, _Lines[k].UserGroupLeft->getHReal());
			if (_Lines[k].CheckBox)		widgetMaxH = std::max(widgetMaxH, _Lines[k].CheckBox->getHReal());
			if (_Lines[k].RightArrow)	widgetMaxH = std::max(widgetMaxH, _Lines[k].RightArrow->getHReal());
			widgetMaxH = std::max(widgetMaxH, _Lines[k].ViewText->getHReal());
			_GroupList->setMaxH(widgetMaxH*_MaxVisibleLine+_GroupList->getSpace()*(_MaxVisibleLine-1));
			if (_ScrollBar == NULL)
			{
				_ScrollBar = new CCtrlScroll(CViewBase::TCtorParam());
				_ScrollBar->setParent (this);
				_ScrollBar->setParentPos (_GroupList);
				_ScrollBar->setPosRef (Hotspot_BL);
				_ScrollBar->setParentPosRef (Hotspot_BR);
				_ScrollBar->setX (4);
				_ScrollBar->setY (0);
				_ScrollBar->setW (8);
				_ScrollBar->setTextureBottomOrLeft	("w_scroll_l123_b.tga");
				_ScrollBar->setTextureMiddle		("w_scroll_l123_m.tga");
				_ScrollBar->setTextureTopOrRight	("w_scroll_l123_t.tga");
				_ScrollBar->setTarget(_GroupList);
				_SelectionView->setW (-8-8-2);
				addCtrl(_ScrollBar);
				mustUpdate = true;
			}
			break;
		}
	}
	else
	{
		_SelectionView->setW(-8);
	}


	// *** Setup Text
	for(k = 0; k < _Lines.size(); ++k)
	{
		CInterfaceGroup *ig = _Lines[k].UserGroupRight;
		if (ig)
		{
			ig->updateCoords();
			maxUserGroupWidth = std::max(maxUserGroupWidth, ig->getWReal());
		}
		if (_Lines[k].ViewText)
		{
			// compute max height of widgets on the left of text
			sint32 widgetMaxH = 0;
			if (_Lines[k].UserGroupRight) widgetMaxH = _Lines[k].UserGroupRight->getHReal();
			if (_Lines[k].UserGroupLeft) widgetMaxH = std::max(widgetMaxH, _Lines[k].UserGroupLeft->getHReal());
			if (_Lines[k].CheckBox)  widgetMaxH = std::max(widgetMaxH, _Lines[k].CheckBox->getHReal());
			if (_Lines[k].RightArrow)  widgetMaxH = std::max(widgetMaxH, _Lines[k].RightArrow->getHReal());

			sint32	textHReal= _Lines[k].ViewText->getHReal();
			_Lines[k].HReal= max(widgetMaxH, textHReal);
			_Lines[k].TextDY= textDYPos;
			if(widgetMaxH>textHReal)
				_Lines[k].TextDY+= (widgetMaxH-textHReal) / 2;
		}
	}


	// *** Update Text Positions
//	sint32 currX = 0;
	for(k = 0; k < _Lines.size(); ++k)
	{
		if (_Lines[k].ViewText)
		{
			// Setup Y
			_Lines[k].ViewText->setY(_Lines[k].TextDY);
		}
	}



	if (mustUpdate)
	{
		CGroupFrame::updateCoords();
	}


	// *** Setup SubMenus and CheckBoxes Positions
	sint32 maxViewW = 0;
	for (i = 1; i < _Views.size(); ++i)
	{
		CViewBitmap *pVB = dynamic_cast<CViewBitmap *>(_Views[i]);
		if (pVB == NULL) continue;
		if (pVB->getId() == ID_MENU_SUBMENU)
		{
			// Look for the next line of the menu that contains a sub menu
			for(;;)
			{
				nlassert (RALineNb < (sint32)_SubMenus.size());
				if (_SubMenus[RALineNb] != NULL) // has a check box or an arrow to indicate submenu ?
				{
					break;
				}
				++RALineNb;
			}

			// get refElm and refElmYReal
			GET_REF_ELM(RALineNb)

			// if there is a check box, y is 0
			if (_Lines[RALineNb].CheckBox || _Lines[RALineNb].UserGroupRight)
			{
				pVB->setY(0);
				pVB->setX(MENU_WIDGET_X);
			}
			else
			{
				sint32 limY = refElmYReal + refElmHReal/2 - _GroupList->getYReal();
				// Setup the arrow at the right pos
				if(_GroupList->getMaxH()>=limY && limY>=0)
				{
					pVB->setY(refElmYReal + (refElmHReal - pVB->getHReal()) / 2 - _GroupList->getYReal());
					pVB->setColor(_Lines[RALineNb].ViewText->getColor());
					pVB->setActive(_Lines[RALineNb].ViewText->getActive());
					pVB->setX(maxUserGroupWidth + MENU_WIDGET_X);
				}
				else
				{
					pVB->setY(0);
					pVB->setActive(false);
				}
			}

			if (_GroupMenu->SpawnOnMousePos)
			{
				_SubMenus[RALineNb]->setParentPos (this);

				// According to mouse position, set the sub menu on the left or right, begin at top or bottom
				CViewRenderer &rVR = *CViewRenderer::getInstance();
				uint32 screenW, screenH;
				rVR.getScreenSize(screenW, screenH);
				if ((_GroupMenu->SpawnMouseX <= ((sint32)screenW/2)) && (_GroupMenu->SpawnMouseY <= ((sint32)screenH/2)))
				{
					_SubMenus[RALineNb]->setParentPosRef(Hotspot_BR);
					_SubMenus[RALineNb]->setPosRef(Hotspot_BL);
					_SubMenus[RALineNb]->setY (refElmYReal - _GroupList->getYReal());
				}
				if ((_GroupMenu->SpawnMouseX <= ((sint32)screenW/2)) && (_GroupMenu->SpawnMouseY > ((sint32)screenH/2)))
				{
					_SubMenus[RALineNb]->setParentPosRef(Hotspot_TR);
					_SubMenus[RALineNb]->setPosRef(Hotspot_TL);
					_SubMenus[RALineNb]->setY (refElmHReal+(refElmYReal - _GroupList->getYReal()) - _GroupList->getHReal());
				}
				if ((_GroupMenu->SpawnMouseX > ((sint32)screenW/2)) && (_GroupMenu->SpawnMouseY <= ((sint32)screenH/2)))
				{
					_SubMenus[RALineNb]->setParentPosRef(Hotspot_BL);
					_SubMenus[RALineNb]->setPosRef(Hotspot_BR);
					_SubMenus[RALineNb]->setY (refElmYReal - _GroupList->getYReal());
				}
				if ((_GroupMenu->SpawnMouseX > ((sint32)screenW/2)) && (_GroupMenu->SpawnMouseY > ((sint32)screenH/2)))
				{
					_SubMenus[RALineNb]->setParentPosRef(Hotspot_TL);
					_SubMenus[RALineNb]->setPosRef(Hotspot_TR);
					_SubMenus[RALineNb]->setY (refElmHReal+(refElmYReal - _GroupList->getYReal()) - _GroupList->getHReal());
				}
				_SubMenus[RALineNb]->setX(0);
			}
			else
			{
				// Setup sub menu
				_SubMenus[RALineNb]->setParentPos (this);
				_SubMenus[RALineNb]->setParentPosRef (Hotspot_BR);
				_SubMenus[RALineNb]->setPosRef (Hotspot_BL);
				_SubMenus[RALineNb]->setY (16+refElmYReal - _GroupList->getYReal() - _SubMenus[RALineNb]->getHReal());
			}

			++RALineNb;
		}
		else if (pVB->getId() == ID_MENU_CHECKBOX)
		{
			for(;;)
			{
				nlassert (CBLineNb < (sint32)_SubMenus.size());
				if (_Lines[CBLineNb].CheckBox != NULL) // has a check box or an arrow to indicate submenu ?
				{
					break;
				}
				++CBLineNb;
			}
			// Setup the arrow at the right pos
			if (!_Lines[CBLineNb].UserGroupRight)
			{
				// get refElm and refElmYReal
				GET_REF_ELM(CBLineNb)

				pVB->setX(maxUserGroupWidth + 2 * MENU_WIDGET_X);

				sint32 limY = refElmYReal + refElmHReal/2 - _GroupList->getYReal();
				// Setup the arrow at the right pos
				if(_GroupList->getMaxH()>=limY && limY>=0)
				{
					pVB->setY(refElmYReal + (refElmHReal - pVB->getHReal()) / 2 - _GroupList->getYReal());
					pVB->setActive(_Lines[CBLineNb].ViewText->getActive());
				}
				else
				{
					pVB->setY(0);
					pVB->setActive(false);
				}
			}
			else
			{
				pVB->setY(0);
				pVB->setX(MENU_WIDGET_X);
			}
			pVB->setColor (_Lines[CBLineNb].ViewText->getColor());
			//
			++CBLineNb;
		}

		if (maxViewW<(pVB->getWReal()+pVB->getX())) maxViewW = pVB->getWReal()+pVB->getX();
	}

	// setup scrollbar position in function of views width
	if(maxViewW>0 && _ScrollBar)
		_ScrollBar->setX(4 + maxViewW);

	// *** Setup user groups positions
	for(k = 0; k < _Lines.size(); ++k)
	{
		CInterfaceGroup *igr = _Lines[k].UserGroupRight;
		CInterfaceGroup *igl = _Lines[k].UserGroupLeft;
		if (igr || igl)
		{
			// get refElm and refElmYReal
			GET_REF_ELM(k)

			if (refElm)
			{
				if (igr)
				{
					igr->setX(MENU_WIDGET_X + maxUserGroupWidth - igr->getWReal());

					sint32 limY = refElmYReal + refElmHReal/2 - _GroupList->getYReal();
					if(_GroupList->getMaxH()>=limY && limY>=0)
					{
						igr->setY(refElmYReal + (refElmHReal - igr->getHReal()) / 2 - _GroupList->getYReal());
						igr->setActive (refElm->getActive());
					}
					else
					{
						igr->setY(0);
						igr->setActive(false);
					}
				}

				if (igl)
				{
					sint32 limY = refElmYReal + refElmHReal/2 - _GroupList->getYReal();
					if(_GroupList->getMaxH()>=limY && limY>=0)
					{
						igl->setY(refElmYReal + (refElmHReal - igl->getHReal()) / 2 - this->getYReal());
						igl->setActive(refElm->getActive());
					}
					else
					{
						igl->setY(0);
						igl->setActive(false);
					}
				}
			}
		}
	}


	sint32 SepLineNb = 0;
	// set separator at the right position
	for (i = 0; i < _ChildrenGroups.size(); ++i)
	{
		CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup *>(_ChildrenGroups[i]);
		if (pIG == NULL) continue;
		if (pIG->getId() != ID_MENU_SEPARATOR) continue; // is it a separator ?

		// set good width
		/*sint32 sw = getW() - _LeftBorder - _RightBorder;
		sw = std::max(sw, (sint32) 0);
		pIG->setW(sw);*/

		// Look for the next line of the menu that contains a separator
		CInterfaceGroup *sep = NULL;
		do
		{
			nlassert (SepLineNb < (sint32)_Lines.size());
			sep = _Lines[SepLineNb].Separator;
			++SepLineNb;
		}
		while (sep == NULL);

		// Setup the arrow at the right pos
		pIG->setY (sep->getYReal() - getYReal());
		pIG->setActive(sep->getActive());
	}
	CGroupFrame::updateCoords();

	//_SelectionView->setW (this->getW());
	_SelectionView->setH (8);
	_SelectionView->setY (4);


	if (_Selected != -1 && _Lines[_Selected].ViewText != NULL)
	{
		CRGBA col= _GroupMenu->_HighLightOver;

		_SelectionView->setColor (col);
		_SelectionView->setModulateGlobalColor(getModulateGlobalColor());

		// get refElm and refElmYReal
		GET_REF_ELM(_Selected)

		_SelectionView->setH (refElmHReal);
		_SelectionView->setY (refElmYReal - this->getYReal());
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::checkCoords()
{
	if (!_Active) return;
	if (_GroupMenu == NULL) return;

	// if the mouse goes out the window,  unselect all (because handleEvent may not be called)
	CInterfaceManager *pIM = CInterfaceManager::getInstance();
	sint	xMouse= CWidgetManager::getInstance()->getPointer()->getX();
	sint	yMouse= CWidgetManager::getInstance()->getPointer()->getY();
	if (!((xMouse >= _XReal) &&
		(xMouse < (_XReal + _WReal))&&
		(yMouse > _YReal) &&
		(yMouse <= (_YReal+ _HReal))))
		_Selected= -1;

//	CViewRenderer &rVR = *CViewRenderer::getInstance();

	// Highlight (background under the selection)
	if (_Selected != -1)
	{
		// display hightlight
		if(_GroupMenu->_HighLightOver.A > 0)
		{
			_SelectionView->setActive (true);
			_SelectionView->invalidateCoords();
		}
		else
		{
			_SelectionView->setActive (false);
		}
	}
	else // no selection
	{
		_SelectionView->setActive (false);
	}

	// Text color if grayed or not
	for (sint32 i = 0; i < (sint32)_Lines.size(); ++i)
	{
		if (_Lines[i].ViewText)
		{
			if (_Lines[i].ViewText->getGrayed()) // Colors when the text is grayed
			{
				_Lines[i].ViewText->setColor (_Lines[i].ViewText->OldColorGrayed);
				_Lines[i].ViewText->setShadowColor (_Lines[i].ViewText->OldShadowColorGrayed);
			}
			else
			{
				if (i == _Selected) // Colors when the text is selected
				{
					_Lines[i].ViewText->Over = true;
					_Lines[i].ViewText->setColor (_Lines[i].ViewText->OldColorOver);
					_Lines[i].ViewText->setShadowColor (_Lines[i].ViewText->OldShadowColorOver);
				}
				else // Or finally normal colors
				{
					_Lines[i].ViewText->Over = false;
					_Lines[i].ViewText->setColor (_Lines[i].ViewText->OldColor);
					_Lines[i].ViewText->setShadowColor (_Lines[i].ViewText->OldShadowColor);
				}
			}
		}
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::draw()
{
	if (!_Active) return;
	if (_GroupMenu == NULL) return;
	CGroupFrame::draw();
}

// ------------------------------------------------------------------------------------------------
bool CGroupSubMenu::handleEvent (const NLGUI::CEventDescriptor &event)
{
	if (!_Active)
		return false;

	sint32	textDYPos= 0;
	if(_GroupList)
		textDYPos= -(1+_GroupList->getSpace())/2;

	if (event.getType() == NLGUI::CEventDescriptor::mouse)
	{
		const NLGUI::CEventDescriptorMouse &eventDesc = (const NLGUI::CEventDescriptorMouse &)event;
		_Selected = -1;

		// TODO First check sub menus that can be not in the area of this menu

		if (!((eventDesc.getX() >= _XReal) &&
			(eventDesc.getX() < (_XReal + _WReal))&&
			(eventDesc.getY() > _YReal) &&
			(eventDesc.getY() <= (_YReal+ _HReal))))
			return false;

		uint32 i = 0;
		for (i = 0; i < _Lines.size(); ++i)
		{
			if (_Lines[i].Selectable)
			{
				// get refElm and refElmYReal
				GET_REF_ELM(i)

				if (refElm)
				{
					if (refElm->getActive() == true)
					if ((eventDesc.getY() > refElmYReal) &&
						(eventDesc.getY() <= (refElmYReal + refElmHReal + _GroupList->getSpace())))
					{
						_Selected = i;
						break;
					}
				}
			}
		}

		if (eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mouseleftup)
		{
			// If a line is selected and the line is not grayed
			if ((_Selected != -1) && (!_Lines[i].ViewText->getGrayed()))
			{
				CInterfaceManager *pIM = CInterfaceManager::getInstance();
				CAHManager::getInstance()->runActionHandler (	_Lines[_Selected].AHName,
										CWidgetManager::getInstance()->getCtrlLaunchingModal(),
										_Lines[_Selected].AHParams );

				if (_SubMenus[_Selected] != NULL)
				{
					openSubMenu (_Selected);
				}
				else
				{
					// if the menu hasn't triggered a new modal window,  disable it
					if (CWidgetManager::getInstance()->getModalWindow() == _GroupMenu)
					{
						if(_GroupMenu && _GroupMenu->getCloseSubMenuUsingPopModal())
							CWidgetManager::getInstance()->popModalWindow();
						else
							CWidgetManager::getInstance()->disableModalWindow ();
					}
				}
			}
		}

		if (event.getType() == NLGUI::CEventDescriptor::mouse)
		{
			const NLGUI::CEventDescriptorMouse &eventDesc = (const NLGUI::CEventDescriptorMouse &)event;
			//
			if (_GroupList && _ScrollBar)
			{
				if (eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mousewheel)
				{
					if (isIn(eventDesc.getX(), eventDesc.getY()))
					{
						sint32 h = 0;
						for (uint32 k = 0; k < _Lines.size(); ++k)
						if (_Lines[k].ViewText)
						{
							// compute max height of widgets on the left of text
							sint32 widgetMaxH = 0;
							if (_Lines[k].UserGroupRight)	widgetMaxH = _Lines[k].UserGroupRight->getHReal();
							if (_Lines[k].UserGroupLeft)	widgetMaxH = std::max(widgetMaxH, _Lines[k].UserGroupLeft->getHReal());
							if (_Lines[k].CheckBox)		widgetMaxH = std::max(widgetMaxH, _Lines[k].CheckBox->getHReal());
							if (_Lines[k].RightArrow)	widgetMaxH = std::max(widgetMaxH, _Lines[k].RightArrow->getHReal());
							widgetMaxH = std::max(widgetMaxH, _Lines[k].ViewText->getHReal());
							h = widgetMaxH+_GroupList->getSpace();
						}
						if (h == 0) h = 1;
						_ScrollBar->moveTargetY(- eventDesc.getWheel() * h);

						hideSubMenus();

						return true;
					}
				}
			}
		}

		return true;
	}
	return false;
}

// ------------------------------------------------------------------------------------------------
CInterfaceElement* CGroupSubMenu::getElement (const std::string &id)
{
	string sTmp = id.substr(0,  _GroupMenu->getId().size());
	if (sTmp != _GroupMenu->getId()) return NULL;

	string sRest = id.substr(_GroupMenu->getId().size()+1,  id.size());

	// Iterate through the tree to see if sRest is present
	CGroupSubMenu *pCurGSM = this;
	while (!sRest.empty())
	{
		// Get the first element of the sRest
		string::size_type posid = sRest.find (":");

		if (posid == string::npos)	// Is there just one token to test ?
		{
			for (uint32 i = 0; i < pCurGSM->_Lines.size(); ++i)
				if (sRest == pCurGSM->_Lines[i].Id)
					return pCurGSM->_Lines[i].ViewText;
			sRest = "";
		}
		else // no a lot of token left
		{
			string sTok = sRest.substr (0,  posid);
			uint32 i = 0;
			for (i = 0; i < pCurGSM->_Lines.size(); ++i)
				if (sTok == pCurGSM->_Lines[i].Id)
					break;
			if (i == pCurGSM->_Lines.size())
				return NULL;

			// No sub-menus
			if (pCurGSM->_SubMenus[i] == NULL)
			{
				// Get next token
				sRest = sRest.substr (posid+1);
				posid = sRest.find (":");
				if (posid == string::npos)
					sTok = sRest;
				else
					sTok = sRest.substr (0,  posid);
				// Do we want left or right user group ?
				if (pCurGSM->_Lines[i].UserGroupRight)
				{
					string sUGid = pCurGSM->_Lines[i].UserGroupRight->getId();
					sUGid = sUGid.substr(sUGid.rfind(':')+1,sUGid.size());
					if (sUGid == sTok)
					{
						CInterfaceElement *pIE = pCurGSM->_Lines[i].UserGroupRight->getElement(id);
						return pIE;
					}
				}
				if (pCurGSM->_Lines[i].UserGroupLeft)
				{
					string sUGid = pCurGSM->_Lines[i].UserGroupLeft->getId();
					sUGid = sUGid.substr(sUGid.rfind(':')+1,sUGid.size());
					if (sUGid == sTok)
					{
						CInterfaceElement *pIE = pCurGSM->_Lines[i].UserGroupLeft->getElement(id);
						return pIE;
					}
				}

				return NULL;
			}
			else
			{
				pCurGSM = pCurGSM->_SubMenus[i];
			}
		}
		sRest = sRest.substr (posid+1);
	}

	return NULL;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::addSeparator(const std::string &id)
{
	addSeparatorAtIndex((uint)_Lines.size(), id);
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::addSeparatorAtIndex(uint index, const std::string &id)
{
	if (index > _Lines.size())
	{
		nlwarning("Bad index");
		return;
	}
	CInterfaceManager *im = CInterfaceManager::getInstance();
		// create the real separator. It may be larger than the group list, this is why we create a separate group
	CInterfaceGroup *separator = im->createGroupInstance("menu_separator", "", NULL, 0);
	if (!separator) return;
	separator->setId(ID_MENU_SEPARATOR);
	addGroup(separator);
	separator->setParent(this);
	// create place holder group
	CInterfaceGroup *ph = im->createGroupInstance("menu_separator_empty", "", NULL, 0);
	if (!ph)
	{
		delGroup(separator);
		return;
	}
	_GroupList->addChildAtIndex(ph, index);
	SSubMenuEntry tmp;
	tmp.Id = id;
	tmp.Separator = ph;
	tmp.ViewText = NULL;
	tmp.CheckBox = NULL;
	tmp.RightArrow = NULL;
	_Lines.insert(_Lines.begin() + index, tmp);
	_SubMenus.insert(_SubMenus.begin() + index, (CGroupSubMenu*)NULL);
	_GroupMenu->invalidateCoords();
}


// ------------------------------------------------------------------------------------------------
CViewTextMenu* CGroupSubMenu::addLine (const ucstring &name,  const std::string &ah,
									   const std::string &params,  const std::string &id,
									   const std::string &cond, const std::string &texture,
									   bool checkable /*= false*/,  bool checked /*= false*/, bool formatted /*= false */
									  )
{
	SSubMenuEntry tmp;

	CViewTextMenu *pV = new CViewTextMenu(CViewBase::TCtorParam());


	pV->setCaseMode(_GroupMenu->getCaseMode());
	if (formatted)
	{
		pV->setMultiLine (true);
		pV->setMultiLineMaxWOnly (true);
		pV->setTextFormatTaged (name);
	}
	else
	{
		pV->setText (name);
	}
	pV->setColor (_GroupMenu->_Color);
	pV->setFontSize (_GroupMenu->_FontSize);
	pV->setShadow (_GroupMenu->_Shadow);
	pV->setCheckable(checkable);
	pV->setChecked(checked);
	pV->setModulateGlobalColor(_GroupMenu->_ModulateGlobalColor);

	pV->OldColor =				_GroupMenu->_Color;
	pV->OldShadowColor =		_GroupMenu->_ShadowColor;
	pV->OldColorOver =			_GroupMenu->_ColorOver;
	pV->OldShadowColorOver =	_GroupMenu->_ShadowColorOver;
	pV->OldColorGrayed =		_GroupMenu->_ColorGrayed;
	pV->OldShadowColorGrayed =	_GroupMenu->_ShadowColorGrayed;

	_GroupList->addChild (pV);

	CViewBitmap *checkBox = NULL;

	if (checkable)
	{
		checkBox = createCheckBox(checked);
		checkBox->setTexture(texture);
		pV->setCheckBox(checkBox);
	}

	tmp.ViewText = pV;
	tmp.Separator = NULL;
	tmp.AHName = ah;
	tmp.AHParams = params;
	tmp.Cond = cond;
	tmp.CheckBox = checkBox;
	tmp.RightArrow = NULL;
	if (id.empty())
		tmp.Id = NLMISC::toString (_Lines.size());
	else
		tmp.Id = id;

	pV->setId(_GroupMenu->getId()+":"+tmp.Id);

	_Lines.push_back (tmp);

	// Add an empty sub menu by default
	_SubMenus.push_back (NULL);

	_GroupMenu->invalidateCoords();

	return pV;
}

CViewTextMenu* CGroupSubMenu::addLineAtIndex(uint index,  const ucstring &name,  const std::string &ah,
											 const std::string &params,  const std::string &id /*=""*/,
											 const std::string &cond /*=std::string()*/, const std::string &texture,
											 bool checkable /*= false*/,  bool checked /*= false*/, bool formatted /*= false */
											)
{
	if (index > _Lines.size())
	{
		nlwarning("Bad index");
		return NULL;
	}
	SSubMenuEntry tmp;
	CViewTextMenu *pV = new CViewTextMenu(CViewBase::TCtorParam());


	pV->setCaseMode(_GroupMenu->getCaseMode());


	if (formatted)
	{
		pV->setMultiLine (true);
		pV->setMultiLineMaxWOnly (true);
		pV->setTextFormatTaged (name);
	}
	else
	{
		pV->setText (name);
	}

	pV->setColor (_GroupMenu->_Color);
	pV->setFontSize (_GroupMenu->_FontSize);
	pV->setShadow (_GroupMenu->_Shadow);
	pV->setCheckable(checkable);
	pV->setChecked(checked);
	pV->setModulateGlobalColor(_GroupMenu->_ModulateGlobalColor);

	pV->OldColor =				_GroupMenu->_Color;
	pV->OldShadowColor =		_GroupMenu->_ShadowColor;
	pV->OldColorOver =			_GroupMenu->_ColorOver;
	pV->OldShadowColorOver =	_GroupMenu->_ShadowColorOver;
	pV->OldColorGrayed =		_GroupMenu->_ColorGrayed;
	pV->OldShadowColorGrayed =	_GroupMenu->_ShadowColorGrayed;

	_GroupList->addChildAtIndex(pV,  index);

	CViewBitmap *checkBox = NULL;
	if (checkable)
	{
		checkBox = createCheckBox(checked);
		checkBox->setTexture(texture);
		pV->setCheckBox(checkBox);
	}

	tmp.ViewText = pV;
	tmp.Separator = NULL;
	tmp.AHName = ah;
	tmp.AHParams = params;
	tmp.Cond = cond;
	tmp.CheckBox = checkBox;
	tmp.RightArrow = NULL;

	if (id.empty())
		tmp.Id = NLMISC::toString (_Lines.size());
	else
		tmp.Id = id;

	pV->setId(getId()+":"+tmp.Id);

	_Lines.insert(_Lines.begin() + index,  tmp);

	// Add an empty sub menu by default
	_SubMenus.insert(_SubMenus.begin() + index,  (CGroupSubMenu*)NULL);

	_GroupMenu->invalidateCoords();

	return pV;
}


// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::removeLine(uint index)
{
	if (index >= _Lines.size())
	{
		nlwarning("Bad index");
		return;
	}
	setUserGroupRight(index, NULL, false); // remove user group
	setUserGroupLeft(index, NULL, false); // remove user group
	// remove view (right arrow & checkbox)
	if (_Lines[index].RightArrow) delView(_Lines[index].RightArrow);
	if (_Lines[index].CheckBox) delView(_Lines[index].CheckBox);
	if (_Lines[index].Separator)
	{
		// remove one separator group
		for(uint k = 0; k < _ChildrenGroups.size(); ++k)
		{
			if (_ChildrenGroups[k]->getId() == ID_MENU_SEPARATOR)
			{
				delGroup(_ChildrenGroups[k]);
				break;
			}
		}
	}
	//
	_GroupList->setDelOnRemove(index, true);
	_GroupList->delChild(index);
	_Lines.erase(_Lines.begin() + index);

	//invalidate selection
	_Selected = -1;

	if(_SubMenus[index])
	{
		// reset it and his sons (recurs)
		_SubMenus[index]->reset();
		// then delete it
		_GroupMenu->delGroup(_SubMenus[index]);
	}
	_SubMenus.erase(_SubMenus.begin() + index);
	_GroupMenu->invalidateCoords();
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::openSubMenu (sint32 nb)
{
	hideSubMenus ();
	_SubMenus[nb]->setActive (true);
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::hideSubMenus ()
{
	for (uint32 i = 0; i < _SubMenus.size(); ++i)
		if (_SubMenus[i] != NULL)
		{
			_SubMenus[i]->setActive (false);
			_SubMenus[i]->hideSubMenus ();
		}
}

// ------------------------------------------------------------------------------------------------
void	CGroupSubMenu::reset()
{
	uint lineCount = (uint)_Lines.size();
	for(sint k = lineCount - 1; k >= 0; --k)
	{
		removeLine(k);
	}
}


// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::removeAllUserGroups()
{
	for(uint k = 0; k < _Lines.size(); ++k)
	{
		setUserGroupRight(k, NULL, false);
		setUserGroupLeft(k, NULL, false);
	}
}

// ------------------------------------------------------------------------------------------------
CInterfaceGroup *CGroupSubMenu::getUserGroupRight(uint line) const
{
	if (line >= _Lines.size())
	{
		nlwarning("bad index");
		return NULL;
	}
	return _Lines[line].UserGroupRight;
}

// ------------------------------------------------------------------------------------------------
CInterfaceGroup *CGroupSubMenu::getUserGroupLeft(uint line) const
{
	if (line >= _Lines.size())
	{
		nlwarning("bad index");
		return NULL;
	}
	return _Lines[line].UserGroupLeft;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setUserGroupRight(uint line, CInterfaceGroup *group, bool ownership)
{
	if (line >= _Lines.size())
	{
		nlwarning("bad index");
		return;
	}
	if (group && isChildGroup(group))
	{
		nlwarning("Group inserted twice");
		return;
	}
	if (_Lines[line].UserGroupRight)
	{
		delGroup(_Lines[line].UserGroupRight, !_Lines[line].UserGroupRightOwnership);
	}
	_Lines[line].UserGroupRight = group;
	_Lines[line].UserGroupRightOwnership = ownership;
	if (group)
	{
		CViewBase *prevElem = _Lines[line].CheckBox ? _Lines[line].CheckBox : _Lines[line].RightArrow;
		if (prevElem)
		{
			prevElem->setParentPosRef (Hotspot_MR);
			prevElem->setPosRef (Hotspot_ML);
			prevElem->setParentPos(group);
			prevElem->setX(MENU_WIDGET_X);
			prevElem->setY(0);
		}
		sint insertionOrder;
		if (prevElem)
		{
			insertionOrder = getInsertionOrder(prevElem);
		}
		else
		{
			insertionOrder = -1;
		}
		addGroup(group, insertionOrder);
		group->setParent(this);
		group->setParentPos(_GroupList);
		group->setParentPosRef (Hotspot_BR);
		group->setPosRef (Hotspot_BL);
	}
	else
	{
		// restore all posref..
		CViewBase *prevElem = _Lines[line].CheckBox ? _Lines[line].CheckBox : _Lines[line].RightArrow;
		if (prevElem)
		{
			prevElem->setParent (this);
			prevElem->setParentPos (_GroupList);
			prevElem->setParentPosRef (Hotspot_BR);
			prevElem->setPosRef (Hotspot_BL);
			prevElem->setX (MENU_WIDGET_X);
		}
	}
	_GroupMenu->invalidateCoords();
}


// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setUserGroupLeft(uint line, CInterfaceGroup *group, bool ownership)
{
	if (line >= _Lines.size())
	{
		nlwarning("bad index");
		return;
	}
	if (group && isChildGroup(group))
	{
		nlwarning("Group inserted twice");
		return;
	}
	if (_Lines[line].UserGroupLeft)
	{
		delGroup(_Lines[line].UserGroupLeft, !_Lines[line].UserGroupLeftOwnership);
	}
	_Lines[line].UserGroupLeft = group;
	_Lines[line].UserGroupLeftOwnership = ownership;
	if (group)
	{
		addGroup(group);
		group->setParent(this);
		group->setParentPos(this);
		group->setParentPosRef (Hotspot_BL);
		group->setPosRef (Hotspot_BL);
		group->setX(LEFT_MENU_WIDGET_X);
	}

	_GroupMenu->invalidateCoords();
}


// ------------------------------------------------------------------------------------------------
CGroupSubMenu *CGroupSubMenu::cloneMenu(CGroupSubMenu *appendToMenu,  CGroupMenu	*newFather,  CInterfaceGroup *initGroup /* = NULL */) const
{
	CGroupSubMenu *copyMenu = appendToMenu ? appendToMenu : new CGroupSubMenu(CViewText::TCtorParam());
	uint startSize = (uint)copyMenu->_Lines.size();
	copyMenu->_GroupMenu = newFather;
	copyMenu->initOptions(initGroup);
	copyMenu->_Lines.reserve(_Lines.size() + startSize);
	copyMenu->_SubMenus.reserve(_SubMenus.size() + startSize);
	// copy childrens
	for(uint k = 0; k < _Lines.size(); ++k)
	{
		if (_Lines[k].Separator)
		{
			copyMenu->addSeparator(_Lines[k].Id);
		}
		else
		{
			std::string texture = std::string();
			if(_Lines[k].ViewText->getCheckBox())
			{
				texture = _Lines[k].ViewText->getCheckBox()->getTexture();
			}
			CViewTextMenu *pV = NULL;
			pV = copyMenu->addLine (_Lines[k].ViewText->getText(),  _Lines[k].AHName,  _Lines[k].AHParams,  _Lines[k].Id,  _Lines[k].Cond,
				     texture, _Lines[k].ViewText->getCheckable(),  _Lines[k].ViewText->getChecked(), _Lines[k].ViewText->getFormatted ());
			copyMenu->_Lines[k].Selectable = _Lines[k].Selectable;
			pV->setGrayed(_Lines[k].ViewText->getGrayed());
		}

		// sub menu copy if there's one
		if (_SubMenus[k] != NULL)
		{

			if (copyMenu->_Lines.back().CheckBox)
			{
				copyMenu->_Lines.back().RightArrow = copyMenu->createRightArrow(copyMenu->_Lines.back().CheckBox, true);
			}
			else
			{
				copyMenu->_Lines.back().RightArrow = copyMenu->createRightArrow(copyMenu->_GroupList, false);
			}


			// and create the sub menu
			copyMenu->_SubMenus[k + startSize] = _SubMenus[k]->cloneMenu(NULL,  newFather,  copyMenu);
		}
	}
	if (!appendToMenu)
	{
		newFather->addGroup(copyMenu);
	}
	return copyMenu;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setActive(bool state)
{
	// check conditions
	for(uint k = 0; k < _Lines.size(); ++k)
	{
		if (!_Lines[k].Cond.empty())
		{
			CInterfaceExprValue result;
			if (CInterfaceExpr::eval(_Lines[k].Cond,  result))
			{
				if (result.toBool())
				{
					_Lines[k].ViewText->setGrayed(!result.getBool());
				}
			}
		}
	}

	if(_ScrollBar && _GroupList)
		_ScrollBar->setTrackPos(_GroupList->getHReal());

	CGroupFrame::setActive(state);
}

// ------------------------------------------------------------------------------------------------
const std::string CGroupSubMenu::getActionHandler(uint lineIndex) const
{
	if (lineIndex > _Lines.size())
	{
		nlwarning("Bad index");
		return 0;
	}
	return _Lines[lineIndex].AHName;
}

// ------------------------------------------------------------------------------------------------
const std::string CGroupSubMenu::getActionHandlerParam(uint lineIndex) const
{
	if (lineIndex > _Lines.size())
	{
		nlwarning("Bad index");
		return 0;
	}
	return _Lines[lineIndex].AHParams;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setSelectable(uint lineIndex, bool selectable)
{
	if (lineIndex > _Lines.size())
	{
		nlwarning("Bad index");
		return;
	}
	_Lines[lineIndex].Selectable = selectable;
}

// ------------------------------------------------------------------------------------------------
bool CGroupSubMenu::getSelectable(uint lineIndex) const
{
	if (lineIndex > _Lines.size())
	{
		nlwarning("Bad index");
		return 0;
	}
	return _Lines[lineIndex].Selectable;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setMaxVisibleLine(sint32 mvl)
{
	_MaxVisibleLine = mvl;
}

// ------------------------------------------------------------------------------------------------
const std::string &CGroupSubMenu::getLineId(uint index)
{
	if(index>=_Lines.size())
	{
		static string nullString;
		return nullString;
	}
	else
		return _Lines[index].Id;
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setGrayedLine(uint line,  bool g)
{
	if(line<_Lines.size())
	{
		if (_Lines[line].ViewText)
		{
			_Lines[line].ViewText->setGrayed(g);
		}
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupSubMenu::setHiddenLine(uint line,  bool h)
{
	if(line<_Lines.size())
	{
		if (_Lines[line].ViewText)
		{
			_Lines[line].ViewText->setActive(!h);
		}
	}
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaGetNumLine(CLuaState &ls)
{
	CLuaIHM::checkArgCount(ls, "getNumLine", 0);
	ls.push((double) getNumLine());
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaGetSubMenu(CLuaState &ls)
{
	const char *funcName = "getSubMenu";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	CLuaIHM::pushUIOnStack(ls, getSubMenu((uint) ls.toNumber(1)));
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaAddSubMenu(CLuaState &ls)
{
	const char *funcName = "addSubMenu";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	setSubMenu((uint) ls.toNumber(1), new CGroupSubMenu(CViewText::TCtorParam()));
	CLuaIHM::pushUIOnStack(ls, getSubMenu((uint) ls.toNumber(1)));
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaGetLineId(CLuaState &ls)
{
	const char *funcName = "getLineId";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	std::string id = getLineId((uint) ls.toNumber(1));
	CLuaIHM::push(ls, id);
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaGetLineFromId(CLuaState &ls)
{
	const char *funcName = "getLineFromId";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
	ls.push((double) getLineFromId(ls.toString(1)));
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaIsSeparator(CLuaState &ls)
{
	const char *funcName = "isSeparator";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	ls.push(isSeparator((uint) ls.toNumber(1)));
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaAddLine(CLuaState &ls)
{
	const char *funcName = "addLine";
	CLuaIHM::checkArgCount(ls, funcName, 4);
	CLuaIHM::checkArgTypeUCString(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
	CLuaIHM::checkArgType(ls, funcName, 3, LUA_TSTRING);
	CLuaIHM::checkArgType(ls, funcName, 4, LUA_TSTRING);
	ucstring arg1;
	nlverify(CLuaIHM::getUCStringOnStack(ls, 1, arg1));
	addLine(arg1, ls.toString(2), ls.toString(3), ls.toString(4));
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaAddLineAtIndex(CLuaState &ls)
{
	const char *funcName = "addLineAtIndex";
	CLuaIHM::checkArgCount(ls, funcName, 5);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	CLuaIHM::checkArgTypeUCString(ls, funcName, 2);
	CLuaIHM::checkArgType(ls, funcName, 3, LUA_TSTRING);
	CLuaIHM::checkArgType(ls, funcName, 4, LUA_TSTRING);
	CLuaIHM::checkArgType(ls, funcName, 5, LUA_TSTRING);
	ucstring arg2;
	nlverify(CLuaIHM::getUCStringOnStack(ls, 2, arg2));
	addLineAtIndex((uint) ls.toNumber(1), arg2, ls.toString(3), ls.toString(4), ls.toString(5));
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaAddSeparator(CLuaState &ls)
{
	CLuaIHM::checkArgCount(ls, "addSeparator", 0);
	addSeparator();
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaAddSeparatorAtIndex(CLuaState &ls)
{
	const char *funcName = "addSeparatorAtIndex";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	addSeparatorAtIndex((uint) ls.toNumber(1));
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaRemoveLine(CLuaState &ls)
{
	const char *funcName = "removeLine";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	removeLine((uint) ls.toNumber(1));
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaSetUserGroupRight(CLuaState &ls)
{
	const char *funcName = "setUserGroupRight";
	CLuaIHM::checkArgCount(ls, funcName, 2);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	if (!(CLuaIHM::isUIOnStack(ls, 2) || ls.isNil(2)))
	{
		CLuaIHM::fails(ls, "%s :  Group required as argument 2", funcName);
	}
	CInterfaceElement *el = CLuaIHM::getUIOnStack(ls, 2);
	CInterfaceGroup *group = dynamic_cast<CInterfaceGroup *>(el);
	if (el && !group)
	{
		CLuaIHM::fails(ls, "%s :  Group required as argument 2", funcName);
	}
	setUserGroupRight((uint) ls.toNumber(1), group, true);
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaSetUserGroupLeft(CLuaState &ls)
{
	const char *funcName = "setUserGroupLeft";
	CLuaIHM::checkArgCount(ls, funcName, 2);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	if (!(CLuaIHM::isUIOnStack(ls, 2) || ls.isNil(2)))
	{
		CLuaIHM::fails(ls, "%s :  Group required as argument 2", funcName);
	}
	CInterfaceElement *el = CLuaIHM::getUIOnStack(ls, 2);
	CInterfaceGroup *group = dynamic_cast<CInterfaceGroup *>(el);
	if (el && !group)
	{
		CLuaIHM::fails(ls, "%s :  Group required as argument 2", funcName);
	}
	setUserGroupLeft((uint) ls.toNumber(1), group, true);
	return 0;
}


// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaGetUserGroupRight(CLuaState &ls)
{
	const char *funcName = "getUserGroupRight";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	CLuaIHM::pushUIOnStack(ls, getUserGroupRight((uint) ls.toNumber(1)));
	return 1;
}


// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaGetUserGroupLeft(CLuaState &ls)
{
	const char *funcName = "getUserGroupLeft";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	CInterfaceElement *pIE = getUserGroupLeft((uint) ls.toNumber(1));
	if (pIE)
	{
		CLuaIHM::pushUIOnStack(ls, pIE);
		return 1;
	}
	else return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaSetMaxVisibleLine(CLuaState &ls)
{
	const char *funcName = "setMaxVisibleLine";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	setMaxVisibleLine((uint) ls.toNumber(1));
	return 0;
}

// ------------------------------------------------------------------------------------------------
int CGroupSubMenu::luaReset(CLuaState &ls)
{
	const char *funcName = "reset";
	CLuaIHM::checkArgCount(ls, funcName, 0);
	reset();
	return 0;
}


// ------------------------------------------------------------------------------------------------
// CGroupMenu
// ------------------------------------------------------------------------------------------------

NLMISC_REGISTER_OBJECT(CViewBase, CGroupMenu, std::string, "menu");

// ------------------------------------------------------------------------------------------------
CGroupMenu::CGroupMenu(const TCtorParam &param)
:CGroupModal(param)
{
	_Active = false;
	_Color = CRGBA::White;
	_ColorOver = CRGBA::White;
	_ColorGrayed = CRGBA(128, 128, 128, 255);
	_ShadowColor = CRGBA::Black;
	_ShadowColorOver = CRGBA::Black;
	_ShadowColorGrayed = CRGBA::Black;
	_HighLightOver.set(128, 0, 0, 255);
	_FontSize = 12;
	_Shadow = false;
	_ResizeFromChildH = _ResizeFromChildW = true;
	_DisplayFrame = false;
	_RootMenu = NULL;
	_Space = 3;
	_CaseMode = CaseUpper;
	_Formatted = false;
}

// ------------------------------------------------------------------------------------------------
CGroupMenu::~CGroupMenu()
{
}

// ------------------------------------------------------------------------------------------------
bool CGroupMenu::parse (xmlNodePtr in,  CInterfaceGroup *parentGroup)
{
	CXMLAutoPtr prop;

	_FontSize = 12;

	// override source menu options (if there's one)
	if (!CGroupModal::parse(in, parentGroup))
		return false;


	// see if this menu extends another menu
	prop= (char*) xmlGetProp( in,  (xmlChar*)"extends" );
	CGroupSubMenu *gmExtended = NULL;
	if (prop)
	{
		CInterfaceManager *im = CInterfaceManager::getInstance();
		CGroupMenu *gm = dynamic_cast<CGroupMenu *>(CWidgetManager::getInstance()->getElementFromId(prop));
		if (!gm)
		{
			gm = dynamic_cast<CGroupMenu *>(CWidgetManager::getInstance()->getElementFromId("ui:interface:" + std::string((const char*)prop)));
		}
		if (gm)
		{
			gmExtended = gm->_RootMenu;
			// copy group frame parameters
			CGroupFrame::copyOptionFrom(*gm);
			// copy basic datas
			_Color = gm->_Color;
			_ShadowColor = gm->_ShadowColor;
			_Shadow = gm->_Shadow;
			_FontSize = gm->_FontSize;
			_ColorOver = gm->_ColorOver;
			_ShadowColorOver = gm->_ShadowColorOver;
			_HighLightOver = gm->_HighLightOver;
			_ColorGrayed = gm->_ColorGrayed;
			_ShadowColorGrayed = gm->_ShadowColorGrayed;
			_Priority = gm->_Priority;
			_ModulateGlobalColor = gm->_ModulateGlobalColor;
			_Space = gm->_Space;
			_CaseMode = gm->_CaseMode;
		}
		else
		{
			nlwarning("Can't get menu %s or bad type",  (const char *) prop);
		}
	}


	// Override the modal behaviour because of sub menus
	ExitClickOut = true;
	ExitClickL = false;
	ExitClickR = false;
	ExitKeyPushed = true;
	_ResizeFromChildH = _ResizeFromChildW = true;
	_DisplayFrame = false;
	_Active = false;
	_Formatted = false;

	// text colors
	prop= (char*) xmlGetProp( in,  (xmlChar*)"color" );
	if (prop)	_Color = convertColor(prop);

	prop = (char*) xmlGetProp( in, (xmlChar*)"case_mode" );
	if (prop)
	{
		sint32 caseMode;
		fromString((const char*)prop, caseMode);
		_CaseMode = (TCaseMode)caseMode;
	}

	prop= (char*) xmlGetProp( in,  (xmlChar*)"shadow_color" );
	if (prop)	_ShadowColor = convertColor(prop);

	prop= (char*) xmlGetProp( in,  (xmlChar*)"color_over" );
	if (prop)	_ColorOver = convertColor(prop);

	prop= (char*) xmlGetProp( in,  (xmlChar*)"shadow_color_over" );
	if (prop)	_ShadowColorOver = convertColor(prop);

	prop= (char*) xmlGetProp( in,  (xmlChar*)"highlight_over" );
	if (prop)	_HighLightOver = convertColor(prop);

	prop= (char*) xmlGetProp( in,  (xmlChar*)"color_grayed" );
	if (prop)	_ColorGrayed = convertColor(prop);

	prop= (char*) xmlGetProp( in,  (xmlChar*)"shadow_color_grayed" );
	if (prop)	_ShadowColorGrayed = convertColor(prop);

	prop = (char*) xmlGetProp (in,  (xmlChar*)"space");
	if (prop) fromString((const char*)prop, _Space);

	// Text props
	prop = (char*) xmlGetProp( in,  (xmlChar*)"fontsize" );
	if (prop) fromString((const char*)prop, _FontSize);

	prop = (char*) xmlGetProp( in,  (xmlChar*)"shadow" );
	if (prop)
		_Shadow = convertBool(prop);

	prop = (char*) xmlGetProp( in,  (xmlChar*)"formatted" );
	if (prop)
		_Formatted = convertBool(prop);


	// Read sons
	xmlNodePtr cur;
	cur = in->children;
	if (_RootMenu != NULL) delete _RootMenu;
	_RootMenu = new CGroupSubMenu(CViewText::TCtorParam());
	_RootMenu->_GroupMenu = this;
	_RootMenu->parse (cur);

	prop = (char*) xmlGetProp( in,  (xmlChar*)"max_visible_line" );
	if (prop)
	{
		sint32 maxVisibleLine;
		fromString((const char*)prop, maxVisibleLine);
		_RootMenu->setMaxVisibleLine(maxVisibleLine);
	}

	if (gmExtended)
	{
		gmExtended->cloneMenu(_RootMenu,  this);
	}
	return true;
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::recurseDraw(CGroupSubMenu *pSubMenu)
{
	pSubMenu->draw();

//	const vector<CInterfaceGroup*> &rGroups = pSubMenu->getGroups();

	for (uint32 i = 0; i < pSubMenu->getNumLines(); i++)
	{
		CGroupSubMenu *pGSM = pSubMenu->getSubMenu(i);
		if (pGSM != NULL)
		{
			recurseDraw(pGSM);
			CViewRenderer::getInstance()->flush();
		}
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::draw ()
{
	if (!_Active) return;

	// TEMP TEMP
	//CViewRenderer &rVR = *CViewRenderer::getInstance();
	//rVR.drawRotFlipBitmap _RenderLayer,  (_XReal,  _YReal,  _WReal,  _HReal,  0,  false,  rVR.getBlankTextureId(),  CRGBA(255, 0, 0, 255) );

	_RootMenu->_Active = true;

	if (SpawnOnMousePos)
		recurseDraw(_RootMenu);
	else
		CGroupModal::draw();
}

// ------------------------------------------------------------------------------------------------
bool CGroupMenu::handleEvent (const NLGUI::CEventDescriptor &event)
{
	if (!_Active)
		return false;
	return CGroupModal::handleEvent (event);
}

// ------------------------------------------------------------------------------------------------
CInterfaceElement* CGroupMenu::getElement (const std::string &id)
{
	if (id == getId()) return this;
	CInterfaceElement *pIE = _RootMenu->getElement(id);
	if (pIE != NULL)
		return pIE;
	return CGroupModal::getElement(id);
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::setActive (bool state)
{
	if (SpawnOnMousePos)
	{
		CViewRenderer &rVR = *CViewRenderer::getInstance();
		uint32 w,h;
		rVR.getScreenSize(w,h);
		setW(w);
		setH(h);
		setX(0);
		setY(0);
		_ResizeFromChildH = _ResizeFromChildW = false;
		_RootMenu->_PosRef = Hotspot_TL;
		_RootMenu->_ParentPosRef = Hotspot_BL;
	}

	CGroupFrame::setActive (state);

	// must recompute now the pos of the menu
	uint32 i;
	for (i = 0; i < _ChildrenGroups.size(); ++i)
	{
		_ChildrenGroups[i]->setActive (true);
	}

	CGroupModal::updateCoords();

	// hide sub menus
	_RootMenu->hideSubMenus();
}

// ------------------------------------------------------------------------------------------------
bool CGroupSubMenu::isSeparator(uint i) const
{
	if (i >= _SubMenus.size())
	{
		nlassert("bad index");
		return false;
	}
	return _Lines[i].Separator != NULL;
}
// ------------------------------------------------------------------------------------------------
bool CGroupMenu::isWindowUnder (sint32 x,  sint32 y)
{
	for (uint32 i = 0; i < _ChildrenGroups.size(); ++i)
		if (_ChildrenGroups[i]->getActive ())
			if (_ChildrenGroups[i]->isWindowUnder(x, y))
				return true;

	return false;
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::addLine (const string &name,  const string &ah,  const string &params,
						  const std::string &id/*=std::string()*/,
						  const std::string &cond /*= std::string()*/, const std::string &texture,
						  bool checkable /*= false*/,  bool checked /*= false*/
						 )
{
	if (_RootMenu == NULL)
	{
		_RootMenu = new CGroupSubMenu(CViewText::TCtorParam());
		_RootMenu->_GroupMenu = this;
		addGroup (_RootMenu);
	}

	_RootMenu->addLine (name,  ah,  params,  id,  cond,  texture,  checkable,  checked, _Formatted);
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::addLine(const ucstring &name,  const std::string &ah,  const std::string &params,
						 const std::string &id /* = std::string()*/,
						 const std::string &cond /*= std::string()*/, const std::string &texture,
						 bool checkable /*= false*/,  bool checked /*= false*/
						)
{
	if (_RootMenu == NULL)
	{
		_RootMenu = new CGroupSubMenu(CViewText::TCtorParam());
		_RootMenu->_GroupMenu = this;
		addGroup (_RootMenu);
	}
	_RootMenu->addLine (name,  ah,  params,  id,  cond,  texture,  checkable,  checked, _Formatted);
}
// ------------------------------------------------------------------------------------------------
void CGroupMenu::addLineAtIndex(uint index, const ucstring &name, const std::string &ah,
								const std::string &params, const std::string &id /*=std::string()*/,
								const std::string &cond /*=std::string()*/, const std::string &texture,
								bool checkable /*=false*/, bool checked /*=false*/)
{
	if (_RootMenu == NULL)
	{
		_RootMenu = new CGroupSubMenu(CViewText::TCtorParam());
		_RootMenu->_GroupMenu = this;
		addGroup (_RootMenu);
	}
	_RootMenu->addLineAtIndex(index, name,  ah,  params,  id,  cond,  texture,  checkable,  checked, _Formatted);
}


// ------------------------------------------------------------------------------------------------
void CGroupMenu::reset ()
{
	if ( _RootMenu )
	{
		_RootMenu->reset();
		invalidateCoords();
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::setMinW(sint32 minW)
{
	if ( _RootMenu )
	{
		_RootMenu->_GroupList->setMinW(minW-_RootMenu->getResizeFromChildWMargin());
		_RootMenu->_GroupList->setW(minW-_RootMenu->getResizeFromChildWMargin());
		_RootMenu->setW(minW-_RootMenu->getResizeFromChildWMargin());
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::setGrayedLine(uint line,  bool g)
{
	if ( _RootMenu )
	{
		_RootMenu->setGrayedLine(line, g);
	}
}

// ------------------------------------------------------------------------------------------------
uint CGroupMenu::getNumLine() const
{
	return _RootMenu ? _RootMenu->getNumLine() : 0;
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::deleteLine(uint index)
{
	if (index > getNumLine())
	{
		nlwarning("bad index");
		return;
	}
	_RootMenu->removeLine(index);
}

// ------------------------------------------------------------------------------------------------
const std::string CGroupMenu::getActionHandler(uint lineIndex) const
{
	return _RootMenu ? _RootMenu->getActionHandler(lineIndex) : "";
}

// ------------------------------------------------------------------------------------------------
const std::string CGroupMenu::getActionHandlerParam(uint lineIndex) const
{
	return _RootMenu ? _RootMenu->getActionHandlerParam(lineIndex) : "";
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::setUserGroupRight(uint line, CInterfaceGroup *gr, bool ownerShip /*=true*/)
{
	if (_RootMenu)
	{
		_RootMenu->setUserGroupRight(line, gr, ownerShip);
	}
}

// ------------------------------------------------------------------------------------------------
void CGroupMenu::setUserGroupLeft(uint line, CInterfaceGroup *gr, bool ownerShip /*=true*/)
{
	if (_RootMenu)
	{
		_RootMenu->setUserGroupLeft(line, gr, ownerShip);
	}
}

// ------------------------------------------------------------------------------------------------
int CGroupMenu::luaGetRootMenu(CLuaState &ls)
{
	CLuaIHM::checkArgCount(ls, "getRootMenu", 0);
	CLuaIHM::pushUIOnStack(ls, getRootMenu());
	return 1;
}

// ------------------------------------------------------------------------------------------------
int CGroupMenu::luaSetMinW(CLuaState &ls)
{
	const char *funcName = "setMinW";
	CLuaIHM::checkArgCount(ls, funcName, 1);
	CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
	setMinW((sint32) ls.toNumber(1));
	return 0;
}