static void PopupMainToolbMenu(Window *parent, uint16 parent_button, StringID base_string, byte item_count, byte disabled_mask = 0, int sel_index = 0, int checked_items = 0);

static void PopupMainPlayerToolbMenu(Window *parent, int main_button, int gray = 0);

/** The idea of this enum is to allow a separation between widget position

 * and _menu_clicked_procs's entry.  By shifting, the "action" id is extracted and

 * kept safe for usage when required.

 * @see ToolbarMenuWindow::OnMouseLoop */

enum ScenarioEditorMenuActions {

	SEMA_MAP_CLICK = 17 << 8,

/** Returns the position where the toolbar wants the menu to appear.

 * Make sure the dropdown is fully visible within the window.

 * x + w->left because x is supposed to be the offset of the toolbar-button

 * we clicked on and w->left the toolbar window itself. So meaning that

 * the default position is aligned with the left side of the clicked button */

static Point GetToolbarDropdownPos(uint16 parent_button, int width, int height)

{

	const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);

	Point pos;

	pos.x = w->widget[GB(parent_button, 0, 8)].left;

	pos.x = w->left + Clamp(pos.x, 0, w->width - width);

	pos.y = w->height;

	return pos;

}

/**

 * Retrieve the menu item number from a position

 * @param w Window holding the menu items

 * @param x X coordinate of the position

 * @param y Y coordinate of the position

 * @return Index number of the menu item, or \c -1 if no valid selection under position

 */

static int GetMenuItemIndex(const Window *w, int item_count, int disabled_items)

{

	int x = _cursor.pos.x;

	int y = _cursor.pos.y;

	if ((x -= w->left) >= 0 && x < w->width && (y -= w->top + 1) >= 0) {

		y /= 10;

		if (y < item_count &&

				!HasBit(disabled_items, y)) {

			return y;

		}

	}

	return -1;

}

	OME_GAMEOPTIONS    = 0,

	OME_SHOW_TOWNNAMES = 6,

	OME_MENUCOUNT,

	uint16 x = 0;

	if (HasBit(_display_opt, DO_SHOW_TOWN_NAMES))    SetBit(x, OME_SHOW_TOWNNAMES);

	if (HasBit(_display_opt, DO_SHOW_STATION_NAMES)) SetBit(x, OME_SHOW_STATIONNAMES);

	if (HasBit(_display_opt, DO_SHOW_SIGNS))         SetBit(x, OME_SHOW_SIGNS);

	if (HasBit(_display_opt, DO_WAYPOINTS))          SetBit(x, OME_SHOW_WAYPOINTNAMES);

	if (HasBit(_display_opt, DO_FULL_ANIMATION))     SetBit(x, OME_FULL_ANIMATION);

	if (HasBit(_display_opt, DO_FULL_DETAIL))        SetBit(x, OME_FULL_DETAILS);

	if (IsTransparencySet(TO_HOUSES))                SetBit(x, OME_TRANSPARENTBUILDINGS);

	if (IsTransparencySet(TO_SIGNS))                 SetBit(x, OME_SHOW_STATIONSIGNS);

	PopupMainToolbMenu(w, TBN_SETTINGS, STR_02C4_GAME_OPTIONS, OME_MENUCOUNT, 0, 0, x);

	/* Scenario editor button, Use different button to activate.

	 * This scheme will allow to have an action (SEMA_MAP_CLICK, which is in fact

	 * an entry in _menu_clicked_procs) while at the same time having a start button

	 * who is not at the same index as its action

	 * @see ToolbarMenuWindow::OnMouseLoop */

	PopupMainToolbMenu(w, TBSE_SMALLMAP | SEMA_MAP_CLICK, STR_02DE_MAP_OF_WORLD, MME_MENUCOUNT_EDITOR);

	if (_networking && index == 0) {

		if (_networking) index--;

	PopupMainToolbMenu(w, TBN_INDUSTRIES, STR_INDUSTRY_DIR, 2, (_current_player == PLAYER_SPECTATOR) ? 2 : 0);

	PopupMainToolbMenu(w, TBN_RAILS, STR_1015_RAILROAD_CONSTRUCTION, RAILTYPE_END, ~p->avail_railtypes, _last_built_railtype);

	/* The standard road button is *always* available */

	PopupMainToolbMenu(w, TBN_ROADS, STR_180A_ROAD_CONSTRUCTION, 2, ~(p->avail_roadtypes | ROADTYPES_ROAD), _last_built_roadtype);

/* --- Rendering/handling the drop down menus --- */

typedef void MenuClickedProc(int index);

static MenuClickedProc * const _menu_clicked_procs[] = {

	NULL,                 /* 0 */

	NULL,                 /* 1 */

	MenuClickSettings,    /* 2 */

	MenuClickSaveLoad,    /* 3 */

	MenuClickMap,         /* 4 */

	MenuClickTown,        /* 5 */

	MenuClickSubsidies,   /* 6 */

	MenuClickStations,    /* 7 */

	MenuClickFinances,    /* 8 */

	MenuClickCompany,     /* 9 */

	MenuClickGraphs,      /* 10 */

	MenuClickLeague,      /* 11 */

	MenuClickIndustry,    /* 12 */

	MenuClickShowTrains,  /* 13 */

	MenuClickShowRoad,    /* 14 */

	MenuClickShowShips,   /* 15 */

	MenuClickShowAir,     /* 16 */

	MenuClickMap,         /* 17 */

	NULL,                 /* 18 */

	MenuClickBuildRail,   /* 19 */

	MenuClickBuildRoad,   /* 20 */

	MenuClickBuildWater,  /* 21 */

	MenuClickBuildAir,    /* 22 */

	MenuClickForest,      /* 23 */

	MenuClickMusicWindow, /* 24 */

	MenuClickNewspaper,   /* 25 */

	MenuClickHelp,        /* 26 */

};

struct ToolbarMenuWindow : Window {

	int item_count;

	int sel_index;

	int main_button;

	int action_id;

	int checked_items;

	int disabled_items;

	StringID base_string;

	ToolbarMenuWindow(int x, int y, int width, int height, const Widget *widgets, int item_count,

										int sel_index, int parent_button, StringID base_string, int checked_items,

										int disabled_items) :

			Window(x, y, width, height, WC_TOOLBAR_MENU, widgets),

			item_count(item_count), sel_index(sel_index), main_button(GB(parent_button, 0, 8)),

			action_id((GB(parent_button, 8, 8) != 0) ? GB(parent_button, 8, 8) : parent_button),

			checked_items(checked_items), disabled_items(disabled_items), base_string(base_string)

	{

		this->widget[0].bottom = item_count * 10 + 1;

		this->widget[0].right = this->width - 1;

		this->flags4 &= ~WF_WHITE_BORDER_MASK;

		this->FindWindowPlacementAndResize(width, height);

	}

	~ToolbarMenuWindow()

	{

		Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);

		w->RaiseWidget(this->main_button);

		w->SetDirty();

	}

	virtual void OnPaint()

	{

		this->DrawWidgets();

		for (int i = 0, x = 1, y = 1; i != this->item_count; i++, y += 10) {

			TextColour color = HasBit(this->disabled_items, i) ? TC_GREY : (this->sel_index == i) ? TC_WHITE : TC_BLACK;

			if (this->sel_index == i) GfxFillRect(x, y, x + this->width - 3, y + 9, 0);

			if (HasBit(this->checked_items, i)) DrawString(x + 2, y, STR_CHECKMARK, color);

			DrawString(x + 2, y, this->base_string + i, color);

		}

	}

	virtual void OnMouseLoop()

	{

		int index = GetMenuItemIndex(this, this->item_count, this->disabled_items);

		if (_left_button_down) {

			if (index == -1 || index == this->sel_index) return;

			this->sel_index = index;

			this->SetDirty();

		} else {

			if (index < 0) {

				Window *w = FindWindowById(WC_MAIN_TOOLBAR,0);

				if (GetWidgetFromPos(w, _cursor.pos.x - w->left, _cursor.pos.y - w->top) == this->main_button) {

					index = this->sel_index;

				}

			}

			int action_id = this->action_id;

			delete this;

			if (index >= 0) {

				assert((uint)index <= lengthof(_menu_clicked_procs));

				_menu_clicked_procs[action_id](index);

			}

		}

	}

};

/* Dynamic widget length determined by toolbar-string length.

 * See PopupMainToolbMenu en MenuWndProc */

static const Widget _menu_widgets[] = {

{    WWT_PANEL, RESIZE_NONE,  COLOUR_GREY, 0,  0, 0, 0, 0x0, STR_NULL},

{ WIDGETS_END},

};

/**

 * Get the maximum length of a given string in a string-list. This is an

 * implicit string-list where the ID's are consecutive

 * @param base_string StringID of the first string in the list

 * @param count amount of StringID's in the list

 * @return the length of the longest string

 */

static int GetStringListMaxWidth(StringID base_string, byte count)

{

	char buffer[512];

	int width, max_width = 0;

	for (byte i = 0; i != count; i++) {

		GetString(buffer, base_string + i, lastof(buffer));

		width = GetStringBoundingBox(buffer).width;

		if (width > max_width) max_width = width;

	}

	return max_width;

}

/**

 * Show a general dropdown menu. The positioning of the dropdown menu

 * defaults to the left side of the parent_button, eg the button that caused

 * this window to appear. The only exceptions are when the right side of this

 * dropdown would fall outside the main toolbar window, in that case it is

 * aligned with the toolbar's right side.

 * Since the disable-mask is only 8 bits right now, these dropdowns are

 * restricted to 8 items max if any bits of disabled_mask are active.

 * @param parent Pointer to a window this dropdown menu belongs to. Has no effect

 * whatsoever, only graphically for positioning.

 * @param parent_button The widget identifier of the button that was clicked for

 * this dropdown. The created dropdown then knows what button to raise (button) on

 * action and whose function to execute (action).

 * It is possible to appoint another button for an action event by setting the

 * upper 8 bits of this parameter. If non is set, action is presumed to be the same

 * as button. So<br>

 * button bits 0 -  7 - widget clicked to get dropdown

 * action bits 8 - 15 - function of widget to execute on select (defaults to bits 0 - 7)

 * @param base_string The first StringID shown in the dropdown list. All others are

 * consecutive indeces from the language file. XXX - fix? Use ingame-string tables?

 * @param item_count Number of strings in the list, see previous parameter

 * @param disabled_mask Bitmask of disabled strings in the list

 * @param sel_index The selected toolbar item

 * @param check_items The items to have a checked mark in front of them.

 * @return Return a pointer to the newly created dropdown window

 */

static void PopupMainToolbMenu(Window *parent, uint16 parent_button, StringID base_string, byte item_count, byte disabled_mask, int sel_index, int checked_items)

{

	assert(disabled_mask == 0 || item_count <= 8);

	parent->LowerWidget(parent_button);

	parent->InvalidateWidget(parent_button);

	DeleteWindowById(WC_TOOLBAR_MENU, 0);

	/* Extend the dropdown toolbar to the longest string in the list */

	int width = max(GetStringListMaxWidth(base_string, item_count) + 6, 140);

	int height = item_count * 10 + 2;

	Point pos = GetToolbarDropdownPos(parent_button, width, height);

	new ToolbarMenuWindow(pos.x, pos.y, width, height, _menu_widgets, item_count, sel_index, parent_button, base_string, checked_items, disabled_mask);

	SndPlayFx(SND_15_BEEP);

}

/* --- Rendering/drawing the player menu --- */

static int GetPlayerIndexFromMenu(int index)

{

	if (index >= 0) {

		const Player *p;

		FOR_ALL_PLAYERS(p) {

			if (--index < 0) return p->index;

		}

	}

	return -1;

}

struct ToolbarPlayerMenuWindow : Window {

	int item_count;

	int sel_index;

	int main_button;

	int action_id;

	int gray_items;

	ToolbarPlayerMenuWindow(int x, int y, int width, int height, const Widget *widgets, int main_button, int gray) :

			Window(x, y, width, height, WC_TOOLBAR_MENU, widgets),

			item_count(0), main_button(main_button), action_id(main_button), gray_items(gray)

	{

		this->flags4 &= ~WF_WHITE_BORDER_MASK;

		this->sel_index = (_local_player != PLAYER_SPECTATOR) ? _local_player : GetPlayerIndexFromMenu(0);

		if (_networking && main_button == TBN_PLAYERS) {

			if (_local_player != PLAYER_SPECTATOR) {

				this->sel_index++;

			} else {

				/* Select client list by default for spectators */

				this->sel_index = 0;

			}

		}

		this->FindWindowPlacementAndResize(width, height);

	}

	~ToolbarPlayerMenuWindow()

	{

		Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);

		w->RaiseWidget(this->main_button);

		w->SetDirty();

	}

	void UpdatePlayerMenuHeight()

	{

		byte num = ActivePlayerCount();

		/* Increase one to fit in PlayerList in the menu when in network */

		if (_networking && this->main_button == TBN_PLAYERS) num++;

		if (this->item_count != num) {

			this->item_count = num;

			this->SetDirty();

			num = num * 10 + 2;

			this->height = num;

			this->widget[0].bottom = this->widget[0].top + num - 1;

			this->top = GetToolbarDropdownPos(0, this->width, this->height).y;

			this->SetDirty();

		}

	}

	virtual void OnPaint()

	{

		this->UpdatePlayerMenuHeight();

		this->DrawWidgets();

		int x = 1;

		int y = 1;

		int sel = this->sel_index;

		int gray = this->gray_items;

		/* 9 = playerlist */

		if (_networking && this->main_button == TBN_PLAYERS) {

			if (sel == 0) {

				GfxFillRect(x, y, x + 238, y + 9, 0);

			}

			DrawString(x + 19, y, STR_NETWORK_CLIENT_LIST, TC_FROMSTRING);

			y += 10;

			sel--;

		}

		for (PlayerID p = PLAYER_FIRST; p < MAX_PLAYERS; p++) {

			if (IsValidPlayerID(p)) {

				if (p == sel) {

					GfxFillRect(x, y, x + 238, y + 9, 0);

				}

				DrawPlayerIcon(p, x + 2, y + 1);

				SetDParam(0, p);

				SetDParam(1, p);

				TextColour color = (p == sel) ? TC_WHITE : TC_BLACK;

				if (gray & 1) color = TC_GREY;

				DrawString(x + 19, y, STR_7021, color);

				y += 10;

			}

			gray >>= 1;

		}

	}

	virtual void OnMouseLoop()

	{

		int index = GetMenuItemIndex(this, this->item_count, 0);

		if (_left_button_down) {

			this->UpdatePlayerMenuHeight();

			/* We have a new entry at the top of the list of menu 9 when networking

				* so keep that in count */

			if (_networking && this->main_button == TBN_PLAYERS) {

				if (index > 0) index = GetPlayerIndexFromMenu(index - 1) + 1;

			} else {

				index = GetPlayerIndexFromMenu(index);

			}

			if (index == -1 || index == this->sel_index) return;

			this->sel_index = index;

			this->SetDirty();

		} else {

			int action_id = this->action_id;

			/* We have a new entry at the top of the list of menu 9 when networking

				* so keep that in count */

			if (_networking && this->main_button == TBN_PLAYERS) {

				if (index > 0) index = GetPlayerIndexFromMenu(index - 1) + 1;

			} else {

				index = GetPlayerIndexFromMenu(index);

			}

			if (index < 0) {

				Window *w = FindWindowById(WC_MAIN_TOOLBAR,0);

				if (GetWidgetFromPos(w, _cursor.pos.x - w->left, _cursor.pos.y - w->top) == this->main_button) {

					index = this->sel_index;

				}

			}

			delete this;

			if (index >= 0) {

				assert(index >= 0 && index < 30);

				_menu_clicked_procs[action_id](index);

			}

		}

	}

};

static const Widget _player_menu_widgets[] = {

{    WWT_PANEL, RESIZE_NONE,  COLOUR_GREY, 0, 240, 0, 81, 0x0, STR_NULL},

{ WIDGETS_END},

};

/** Shows the list of players appearing under the buttons that are linked to options for

 * multiple players.

 * @param parent Window who triggered that action.  It's the toolbar, in fact

 * @param main_button widget which has been used

 * @param gray bit-mapping of the items that will need to be grayed out once displayed */

static void PopupMainPlayerToolbMenu(Window *parent, int main_button, int gray)

{

	parent->LowerWidget(main_button);

	parent->InvalidateWidget(main_button);

	DeleteWindowById(WC_TOOLBAR_MENU, 0);

	Point pos = GetToolbarDropdownPos(main_button, 241, 82);

	new ToolbarPlayerMenuWindow(pos.x, pos.y, 241, 82, _player_menu_widgets, main_button, gray);

	SndPlayFx(SND_15_BEEP);

}