netsurf/riscos/menus.c

/*
 * This file is part of NetSurf, http://netsurf.sourceforge.net/
 * Licensed under the GNU General Public License,
 *		  http://www.opensource.org/licenses/gpl-license
 * Copyright 2003 Phil Mellor <monkeyson@users.sourceforge.net>
 * Copyright 2005 James Bursa <bursa@users.sourceforge.net>
 * Copyright 2003 John M Bell <jmb202@ecs.soton.ac.uk>
 * Copyright 2005 Richard Wilson <info@tinct.net>
 */

/** \file
 * Menu creation and handling (implementation).
 */

#include <stdlib.h>
#include <string.h>
#include "oslib/font.h"
#include "oslib/os.h"
#include "oslib/osgbpb.h"
#include "oslib/wimp.h"
#include "oslib/wimpspriteop.h"
#include "netsurf/content/url_store.h"
#include "netsurf/desktop/gui.h"
#include "netsurf/render/box.h"
#include "netsurf/render/form.h"
#include "netsurf/riscos/gui.h"
#include "netsurf/riscos/global_history.h"
#include "netsurf/riscos/help.h"
#include "netsurf/riscos/options.h"
#include "netsurf/riscos/tinct.h"
#include "netsurf/riscos/theme.h"
#include "netsurf/riscos/treeview.h"
#include "netsurf/riscos/wimp.h"
#include "netsurf/utils/log.h"
#include "netsurf/utils/messages.h"
#include "netsurf/utils/url.h"
#include "netsurf/utils/utils.h"


/*	Menu index definitions used by menu decoding code so that entries can
	be quickly commented out. Use -ve numbers below -1 to hide an entry.
*/
#define MENU_PAGE	0
#define MENU_OBJECT	1
#define MENU_SELECTION	-2
#define MENU_NAVIGATE	2
#define MENU_VIEW	3
#define MENU_UTILITIES	4
#define MENU_HELP	5

static void translate_menu(wimp_menu *menu);
static void build_languages_menu(void);
static void ro_gui_menu_toolbar_submenu_selection(int index);
static void ro_gui_menu_prepare_images(void);
static void ro_gui_menu_prepare_window(void);
static void ro_gui_menu_prepare_toolbars(struct toolbar *toolbar);
static void ro_gui_menu_prepare_render(void);
static void ro_gui_menu_prepare_help(int forced);
static void ro_gui_menu_prepare_view(void);
static void ro_gui_menu_objectinfo(wimp_message_menu_warning *warning);
static void ro_gui_menu_object_reload(void);
static void ro_gui_menu_browser_warning(wimp_message_menu_warning *warning);
static void ro_gui_menu_hotlist_warning(wimp_message_menu_warning *warning);
static void ro_gui_menu_global_history_warning(wimp_message_menu_warning *warning);

struct gui_window *current_gui;
wimp_menu *current_menu;
static int current_menu_x, current_menu_y;
static char select_null_text_string[] = "\0";

/** Box for object under menu, or 0 if no object. */
static struct box *gui_menu_object_box = 0;

/** Menu of options for form select controls. */
static wimp_menu *gui_form_select_menu = 0;
/** Form control which gui_form_select_menu is for. */
static struct form_control *gui_form_select_control;


/*	Default menu item flags
*/
#define DEFAULT_FLAGS (wimp_ICON_TEXT | wimp_ICON_FILLED | \
		(wimp_COLOUR_BLACK << wimp_ICON_FG_COLOUR_SHIFT) | \
		(wimp_COLOUR_WHITE << wimp_ICON_BG_COLOUR_SHIFT))


/*	Iconbar menu
*/
static wimp_MENU(4) ibar_menu = {
  { "NetSurf" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Info" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "AppHelp" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Choices" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Quit" } }
  }
};
int iconbar_menu_height = 4 * 44;
wimp_menu *iconbar_menu = (wimp_menu *)&ibar_menu;


/*	Export submenu
*/
static wimp_MENU(2) export_menu = {
  { "ExportAs" }, 7,2,7,0, 200, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING,		       (wimp_menu *)1, DEFAULT_FLAGS, { "Draw" } },
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING, (wimp_menu *)1, DEFAULT_FLAGS, { "Text" } }
  }
};

static wimp_MENU(3) link_menu = {
  { "SaveLink" }, 7,2,7,0, 200, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING, (wimp_menu*)1, DEFAULT_FLAGS, { "URI" } },
    { wimp_MENU_GIVE_WARNING, (wimp_menu*)1, DEFAULT_FLAGS, { "URL" } },
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING, (wimp_menu*)1, DEFAULT_FLAGS, { "LinkText" } }
  }
};


/*	Page submenu
*/
static wimp_MENU(8) page_menu = {
  { "Page" }, 7,2,7,0, 200, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING,			   (wimp_menu *)1,	      DEFAULT_FLAGS, { "PageInfo" } },
    { wimp_MENU_GIVE_WARNING,			   (wimp_menu *)1,	      DEFAULT_FLAGS, { "Save" } },
    { wimp_MENU_GIVE_WARNING,			   (wimp_menu *)1,	      DEFAULT_FLAGS, { "SaveComp" } },
    { 0,		     			   (wimp_menu *)&export_menu, DEFAULT_FLAGS, { "Export" } },
    { 0,		     			   (wimp_menu *)&link_menu,   DEFAULT_FLAGS, { "SaveURL" } },
    { wimp_MENU_GIVE_WARNING | wimp_MENU_SEPARATE, (wimp_menu *)1,	      DEFAULT_FLAGS, { "Print" } },
    { 0,		     			   wimp_NO_SUB_MENU,          DEFAULT_FLAGS, { "NewWindow" } },
    { wimp_MENU_LAST,	    			   wimp_NO_SUB_MENU,	      DEFAULT_FLAGS, { "ViewSrc" } }
  }
};


/*	Object export submenu
*/
static wimp_MENU(2) object_export_menu = {
  { "ExportAs" }, 7,2,7,0, 200, 44, 0,
  {
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING, (wimp_menu *)1, DEFAULT_FLAGS, { "Sprite" } }
  }
};


/*	Object submenu
*/
static wimp_MENU(5) object_menu = {
  { "Object" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING, (wimp_menu *)1,			DEFAULT_FLAGS, { "ObjInfo" } },
    { wimp_MENU_GIVE_WARNING, (wimp_menu *)1,			DEFAULT_FLAGS, { "ObjSave" } },
    { 0,		      (wimp_menu *)&object_export_menu, DEFAULT_FLAGS, { "Export" } },
    { wimp_MENU_SEPARATE, (wimp_menu *)&link_menu,		   DEFAULT_FLAGS, { "SaveURL" } },
    { wimp_MENU_LAST,		wimp_NO_SUB_MENU,		  DEFAULT_FLAGS, { "ObjReload" } }
  }
};


/*	Selection submenu
*/
static wimp_MENU(3) selection_menu = {
  { "Selection" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS | wimp_ICON_SHADED, { "Copy" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS | wimp_ICON_SHADED, { "SelectAll" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU, DEFAULT_FLAGS | wimp_ICON_SHADED, { "Clear" } }
  }
};


/*	Navigate submenu
*/
static wimp_MENU(5) navigate_menu = {
  { "Navigate" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Home" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Back" } },
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Forward" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Reload" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Stop" } }
  }
};


/*	Image submenu
*/
static wimp_MENU(3) image_menu = {
  { "Images" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS | wimp_ICON_SHADED, { "ForeImg" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS,		      	  { "BackImg" } },
  }
};


/*	Toolbar submenu
*/
static wimp_MENU(4) show_toolbar_menu = {
  { "Toolbars" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ToolButtons" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ToolAddress" } },
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ToolThrob" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ToolStatus" } }
  }
};


/*	Render submenu
*/
static wimp_MENU(3) render_menu = {
  { "Render" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "RenderText" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "RenderAnims" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "RenderAll" } }
  }
};


/*	Window submenu
*/
static wimp_MENU(4) window_menu = {
  { "Window" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "WindowSave" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "WindowStagr" } },
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "WindowSize" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "WindowReset" } }
  }
};


/*	View submenu
*/
static wimp_MENU(5) view_menu = {
  { "View" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING,			   (wimp_menu *)1,	            DEFAULT_FLAGS, { "ScaleView" } },
    { wimp_MENU_GIVE_WARNING,			   (wimp_menu *)&image_menu,        DEFAULT_FLAGS, { "Images" } },
    { wimp_MENU_GIVE_WARNING,			   (wimp_menu *)&show_toolbar_menu, DEFAULT_FLAGS, { "Toolbars" } },
    { wimp_MENU_GIVE_WARNING | wimp_MENU_SEPARATE, (wimp_menu *)&render_menu,       DEFAULT_FLAGS, { "Render" } },
    { wimp_MENU_LAST,				   wimp_NO_SUB_MENU,	            DEFAULT_FLAGS, { "OptDefault" } }
  }
};


/*	Hotlist submenu
*/
static wimp_MENU(2) hotlist_util_menu = {
  { "Hotlist" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HotlistAdd" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HotlistShow" } }
  }
};


/*	History submenu
*/
static wimp_MENU(2) history_util_menu = {
  { "History" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HistLocal" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HistGlobal" } }
  }
};


/*	Utilities submenu
*/
static wimp_MENU(4) utilities_menu = {
  { "Utilities" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,				       (wimp_menu *)&hotlist_util_menu, DEFAULT_FLAGS, { "Hotlist" } },
    { 0,				       (wimp_menu *)&history_util_menu, DEFAULT_FLAGS, { "History" } },
    { wimp_MENU_GIVE_WARNING,		       (wimp_menu *)1,			DEFAULT_FLAGS, { "FindText" } },
    { wimp_MENU_GIVE_WARNING | wimp_MENU_LAST, (wimp_menu *)&window_menu,	DEFAULT_FLAGS, { "Window" } },
  }
};


/*	Help submenu
*/
static wimp_MENU(5) help_menu = {
  { "Help" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HelpContent" } },
    { 0,		  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HelpGuide" } },
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HelpInfo" } },
    { wimp_MENU_SEPARATE, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HelpAbout" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "HelpInter" } }
  }
};


/*	Main browser menu
*/
static wimp_MENU(6) menu = {
  { "NetSurf" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,				       (wimp_menu *)&page_menu,	     DEFAULT_FLAGS, { "Page" } },
    { 0,				       (wimp_menu *)&object_menu,    DEFAULT_FLAGS, { "Object" } },
//    { 0,					 (wimp_menu *)&selection_menu, DEFAULT_FLAGS, { "Selection" } },
    { wimp_MENU_GIVE_WARNING,		       (wimp_menu *)&navigate_menu,  DEFAULT_FLAGS, { "Navigate" } },
    { wimp_MENU_GIVE_WARNING,		       (wimp_menu *)&view_menu,	     DEFAULT_FLAGS, { "View" } },
    { 0,				       (wimp_menu *)&utilities_menu, DEFAULT_FLAGS, { "Utilities" } },
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING, (wimp_menu *)&help_menu,	     DEFAULT_FLAGS, { "Help" } }
  }
};
wimp_menu *browser_menu = (wimp_menu *) &menu;



/*	Hotlist new submenu
*/
static wimp_MENU(2) hotlist_new = {
  { "New" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING,		       (wimp_menu *)1, DEFAULT_FLAGS, { "Folder" } },
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING, (wimp_menu *)1, DEFAULT_FLAGS, { "Link" } },
  }
};


/*	Hotlist expand submenu
*/
static wimp_MENU(3) hotlist_expand = {
  { "Expand" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "All" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Folders" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Links" } }
  }
};

/*	Hotlist collapse submenu
*/
static wimp_MENU(3) hotlist_collapse = {
  { "Collapse" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "All" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Folders" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Links" } }
  }
};

/*	Hotlist file submenu
*/
static wimp_MENU(5) hotlist_file = {
  { "Hotlist" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,					   (wimp_menu *)&hotlist_new,	    DEFAULT_FLAGS, { "New" } },
    { wimp_MENU_GIVE_WARNING | wimp_MENU_SEPARATE, (wimp_menu *)1,		    DEFAULT_FLAGS, { "Export" } },
    { 0,					   (wimp_menu *)&hotlist_expand,    DEFAULT_FLAGS, { "Expand" } },
    { 0,					   (wimp_menu *)&hotlist_collapse,  DEFAULT_FLAGS, { "Collapse" } },
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING,	   (wimp_menu *)&show_toolbar_menu, DEFAULT_FLAGS, { "Toolbars" } }
  }
};

/*	History file submenu
*/
static wimp_MENU(4) history_file = {
  { "History" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING | wimp_MENU_SEPARATE, (wimp_menu *)1,		    DEFAULT_FLAGS, { "Export" } },
    { 0,					   (wimp_menu *)&hotlist_expand,    DEFAULT_FLAGS, { "Expand" } },
    { 0,					   (wimp_menu *)&hotlist_collapse,  DEFAULT_FLAGS, { "Collapse" } },
    { wimp_MENU_LAST | wimp_MENU_GIVE_WARNING,	   (wimp_menu *)&show_toolbar_menu, DEFAULT_FLAGS, { "Toolbars" } }
  }
};

/*	Hotlist file submenu
*/
static wimp_MENU(4) hotlist_select = {
  { "Selection" }, 7,2,7,0, 300, 44, 0,
  {
    { wimp_MENU_GIVE_WARNING, (wimp_menu *)1,	DEFAULT_FLAGS, { "Edit" } },
    { 0,		      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Launch" } },
    { 0,		      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Delete" } },
    { wimp_MENU_LAST,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ResetUsage" } }
  }
};

/*	History file submenu
*/
static wimp_MENU(4) history_select = {
  { "Selection" }, 7,2,7,0, 300, 44, 0,
  {
    { 0,		      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Launch" } },
    { wimp_MENU_LAST,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "Delete" } },
  }
};

/*	Hotlist menu
*/
static wimp_MENU(4) hotlist_root = {
  { "Hotlist" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,		      (wimp_menu *)&hotlist_file,   DEFAULT_FLAGS, { "Hotlist" } },
    { wimp_MENU_GIVE_WARNING, (wimp_menu *)&hotlist_select, DEFAULT_FLAGS, { "Selection" } },
    { 0,		      wimp_NO_SUB_MENU,		    DEFAULT_FLAGS, { "SelectAll" } },
    { wimp_MENU_LAST,	      wimp_NO_SUB_MENU,		    DEFAULT_FLAGS, { "Clear" } }
  }
};
wimp_menu *hotlist_menu = (wimp_menu *)&hotlist_root;

/*	History menu
*/
static wimp_MENU(4) history_root = {
  { "History" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,		      (wimp_menu *)&history_file,   DEFAULT_FLAGS, { "History" } },
    { wimp_MENU_GIVE_WARNING, (wimp_menu *)&history_select, DEFAULT_FLAGS, { "Selection" } },
    { 0,		      wimp_NO_SUB_MENU,		    DEFAULT_FLAGS, { "SelectAll" } },
    { wimp_MENU_LAST,	      wimp_NO_SUB_MENU,		    DEFAULT_FLAGS, { "Clear" } }
  }
};
wimp_menu *global_history_menu = (wimp_menu *)&history_root;


/*	Proxy auth popup menu (used in proxy Choices dialog)
*/
static wimp_MENU(3) proxy_menu = {
  { "ProxyAuth" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ProxyNone" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ProxyBasic" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ProxyNTLM" } }
  }
};
wimp_menu *proxyauth_menu = (wimp_menu *) &proxy_menu;


/*	Image display quality popup menu (used in image Choices dialog)
*/
static wimp_MENU(4) imageq_menu = {
  { "Display" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ImgStyle0" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ImgStyle1" } },
    { 0,	      wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ImgStyle2" } },
    { wimp_MENU_LAST, wimp_NO_SUB_MENU, DEFAULT_FLAGS, { "ImgStyle3" } }
  }
};
wimp_menu *image_quality_menu = (wimp_menu *) &imageq_menu;


/*	Toolbar icon menu
*/
static wimp_MENU(5) toolbar = {
  { "Toolbar" }, 7,2,7,0, 200, 44, 0,
  {
    { 0,		  (wimp_menu *)&show_toolbar_menu, DEFAULT_FLAGS, { "Toolbars" } },
    { wimp_MENU_LAST,	  wimp_NO_SUB_MENU,		   DEFAULT_FLAGS, { "EditToolbar" } }
  }
};
wimp_menu *toolbar_menu = (wimp_menu *)&toolbar;


/*	Current toolbar
*/
struct toolbar *current_toolbar;

/*	Languages popup menu (used in browser choices dialog)
*/
wimp_menu *languages_menu = NULL;

/*	Toolbar menu
*/
wimp_menu *toolbar_icon_menu = NULL;

/*	URL suggestion menu
*/
static wimp_MENU(GLOBAL_HISTORY_RECENT_URLS) url_suggest;
wimp_menu *url_suggest_menu = (wimp_menu *)&url_suggest;

static wimp_menu *browser_page_menu = (wimp_menu *)&page_menu;
static wimp_menu *browser_export_menu = (wimp_menu *)&export_menu;
static wimp_menu *browser_object_menu = (wimp_menu *)&object_menu;
static wimp_menu *browser_link_menu = (wimp_menu *)&link_menu;
static wimp_menu *browser_object_export_menu = (wimp_menu *)&object_export_menu;
static wimp_menu *browser_selection_menu = (wimp_menu *)&selection_menu;
static wimp_menu *browser_navigate_menu = (wimp_menu *)&navigate_menu;
static wimp_menu *browser_view_menu = (wimp_menu *)&view_menu;
static wimp_menu *browser_image_menu = (wimp_menu *)&image_menu;
static wimp_menu *browser_toolbar_menu = (wimp_menu *)&show_toolbar_menu;
static wimp_menu *browser_render_menu = (wimp_menu *)&render_menu;
static wimp_menu *browser_window_menu = (wimp_menu *)&window_menu;
static wimp_menu *browser_utilities_menu = (wimp_menu *)&utilities_menu;
static wimp_menu *browser_hotlist_menu = (wimp_menu *)&hotlist_util_menu;
static wimp_menu *browser_history_menu = (wimp_menu *)&history_util_menu;
static wimp_menu *browser_help_menu = (wimp_menu *)&help_menu;

static wimp_menu *hotlist_new_menu = (wimp_menu *)&hotlist_new;
static wimp_menu *hotlist_expand_menu = (wimp_menu *)&hotlist_expand;
static wimp_menu *hotlist_collapse_menu = (wimp_menu *)&hotlist_collapse;
static wimp_menu *hotlist_file_menu = (wimp_menu *)&hotlist_file;
static wimp_menu *hotlist_select_menu = (wimp_menu *)&hotlist_select;

static wimp_menu *history_file_menu = (wimp_menu *)&history_file;
static wimp_menu *history_select_menu = (wimp_menu *)&history_select;


/**
 * Create menu structures.
 */

void ro_gui_menus_init(void)
{
	translate_menu(iconbar_menu);

	translate_menu(browser_menu);
	translate_menu(browser_page_menu);
	translate_menu(browser_export_menu);
	translate_menu(browser_object_menu);
	translate_menu(browser_link_menu);
	translate_menu(browser_object_export_menu);
	translate_menu(browser_selection_menu);
	translate_menu(browser_navigate_menu);
	translate_menu(browser_view_menu);
	translate_menu(browser_image_menu);
	translate_menu(browser_toolbar_menu);
	translate_menu(browser_render_menu);
	translate_menu(browser_window_menu);
	translate_menu(browser_utilities_menu);
	translate_menu(browser_hotlist_menu);
	translate_menu(browser_history_menu);
	translate_menu(browser_help_menu);

	translate_menu(hotlist_menu);
	translate_menu(hotlist_new_menu);
	translate_menu(hotlist_expand_menu);
	translate_menu(hotlist_collapse_menu);
	translate_menu(hotlist_file_menu);
	translate_menu(hotlist_select_menu);

	translate_menu(global_history_menu);
	translate_menu(history_file_menu);
	translate_menu(history_select_menu);


	translate_menu(toolbar_menu);

	translate_menu(proxyauth_menu);

	translate_menu(image_quality_menu);

	build_languages_menu();

	url_suggest_menu->title_data.indirected_text.text = strdup(messages_get("URLSuggest"));

	iconbar_menu->entries[0].sub_menu = (wimp_menu *) dialog_info;
	browser_page_menu->entries[0].sub_menu = (wimp_menu*) dialog_pageinfo;
	browser_object_menu->entries[0].sub_menu = (wimp_menu*) dialog_objinfo;
//	browser_page_menu->entries[1].sub_menu = (wimp_menu *) dialog_saveas;
//	browser_page_menu->entries[2].sub_menu = (wimp_menu *) dialog_saveas;
//	browser_export_menu->entries[0].sub_menu = (wimp_menu *) dialog_saveas;
//	browser_export_menu->entries[1].sub_menu = (wimp_menu *) dialog_saveas;
//	browser_view_menu->entries[0].sub_menu = (wimp_menu *) dialog_zoom;
}


/**
 * Replace text in a menu with message values.
 */

void translate_menu(wimp_menu *menu)
{
	unsigned int i = 0;
	const char *indirected_text;

	/*	We can't just blindly set something as indirected as if we use
		the fallback messages text (ie the pointer we gave), we overwrite
		this data when setting the pointer to the indirected text we
		already had.
	*/
	indirected_text = messages_get(menu->title_data.text);
	if (indirected_text != menu->title_data.text) {
		menu->title_data.indirected_text.text = strdup(indirected_text);
		menu->entries[0].menu_flags |= wimp_MENU_TITLE_INDIRECTED;

	}

	/* items */
	do {
		indirected_text = messages_get(menu->entries[i].data.text);
		if (indirected_text != menu->entries[i].data.text) {
			menu->entries[i].icon_flags |= wimp_ICON_INDIRECTED;
			menu->entries[i].data.indirected_text.text = strdup(indirected_text);
			menu->entries[i].data.indirected_text.validation = select_null_text_string;
			menu->entries[i].data.indirected_text.size = strlen(indirected_text) + 1;
		}
		i++;
	} while ((menu->entries[i - 1].menu_flags & wimp_MENU_LAST) == 0);
}

/**
 * Builds the languages menu based on available translations
 */
void build_languages_menu(void)
{
	int context = 0, read_count, entries = 0;
	os_error *e;
	osgbpb_INFO(100) info;
	char lang[8] = {0};
	char *lang_name;
	void *temp;

	languages_menu = calloc(1, wimp_SIZEOF_MENU(1));
	if (!languages_menu) {
		LOG(("No memory for languages menu"));
		die("Insufficient memory for languages menu");
	}
	languages_menu->title_data.indirected_text.text = strdup(messages_get("Languages"));
	languages_menu->title_fg = wimp_COLOUR_BLACK;
	languages_menu->title_bg = wimp_COLOUR_LIGHT_GREY;
	languages_menu->work_fg = wimp_COLOUR_BLACK;
	languages_menu->work_bg = wimp_COLOUR_WHITE;
	languages_menu->width = 300;
	languages_menu->height = 44;
	languages_menu->gap = 0;

	while (context != -1) {
		e = xosgbpb_dir_entries_info("<NetSurf$Dir>.Resources", (osgbpb_info_list*)&info, 1,
				context, sizeof(info), 0, &read_count, &context);
		if (e)
			die(e->errmess);

		if (read_count == 0)
			continue;

		if (info.obj_type != fileswitch_IS_DIR)
			continue;

		snprintf(lang, sizeof lang, "lang_%2s", info.name);
		if ((lang_name = strdup(messages_get(lang))) == NULL ||
		    strlen(info.name) != 2)
			continue;

		temp = realloc(languages_menu, wimp_SIZEOF_MENU(entries+1));
		if (!temp)
			die("Insufficient memory for languages menu");

		languages_menu = temp;
		languages_menu->entries[entries].menu_flags = 0;
		languages_menu->entries[entries].sub_menu = wimp_NO_SUB_MENU;
		languages_menu->entries[entries].icon_flags = DEFAULT_FLAGS | wimp_ICON_INDIRECTED;
		languages_menu->entries[entries].data.indirected_text.text = lang_name;
		languages_menu->entries[entries].data.indirected_text.validation = (char *)-1;
		languages_menu->entries[entries].data.indirected_text.size = strlen(lang_name) + 1;

		entries++;
	}

	languages_menu->entries[0].menu_flags |= wimp_MENU_TITLE_INDIRECTED;
	languages_menu->entries[entries-1].menu_flags |= wimp_MENU_LAST;
}


/**
 * Builds the URL suggestion menu
 */
bool ro_gui_menu_prepare_url_suggest(void) {
  	char **suggest_text;
	int suggestions;
	int i;

  	suggest_text = global_history_get_recent(&suggestions);
  	if (suggestions < 1)
  		return false;

	url_suggest_menu->title_fg = wimp_COLOUR_BLACK;
	url_suggest_menu->title_bg = wimp_COLOUR_LIGHT_GREY;
	url_suggest_menu->work_fg = wimp_COLOUR_BLACK;
	url_suggest_menu->work_bg = wimp_COLOUR_WHITE;
	url_suggest_menu->width = 300;
	url_suggest_menu->height = 44;
	url_suggest_menu->gap = 0;

	for (i = 0; i < suggestions; i++) {
		url_suggest_menu->entries[i].menu_flags = 0;
		url_suggest_menu->entries[i].sub_menu = wimp_NO_SUB_MENU;
		url_suggest_menu->entries[i].icon_flags = DEFAULT_FLAGS | wimp_ICON_INDIRECTED;
		url_suggest_menu->entries[i].data.indirected_text.text = suggest_text[i];
		url_suggest_menu->entries[i].data.indirected_text.validation = (char *)-1;
		url_suggest_menu->entries[i].data.indirected_text.size = strlen(suggest_text[i]) + 1;
	}

	url_suggest_menu->entries[0].menu_flags |= wimp_MENU_TITLE_INDIRECTED;
	url_suggest_menu->entries[suggestions - 1].menu_flags |= wimp_MENU_LAST;
	return true;
}


/**
 * Display a menu.
 */
void ro_gui_create_menu(wimp_menu *menu, int x, int y, struct gui_window *g)
{
	int doc_x, doc_y;
	wimp_window_state state;
	os_error *error;

	current_gui = g;

	if (menu == browser_menu) {
		assert(g);

		state.w = g->window;
		error = xwimp_get_window_state(&state);
		if (error) {
			LOG(("xwimp_get_window_state: 0x%x: %s",
					error->errnum, error->errmess));
			warn_user("WimpError", error->errmess);
			return;
		}

		doc_x = window_x_units(x, &state) / 2 / g->option.scale;
		doc_y = -window_y_units(y, &state) / 2 / g->option.scale;

		gui_menu_object_box = 0;
		if (g->bw->current_content &&
				g->bw->current_content->type == CONTENT_HTML) {
			gui_menu_object_box = box_object_at_point(
					g->bw->current_content, doc_x, doc_y);
		}

		if (!hotlist_tree)
			browser_utilities_menu->entries[0].icon_flags |=
					wimp_ICON_SHADED;
		if (gui_menu_object_box)
			menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		else
			menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		if ((current_gui->bw) && (current_gui->bw->current_content)) {
			menu->entries[0].icon_flags &= ~wimp_ICON_SHADED;
		} else {
			menu->entries[0].icon_flags |= wimp_ICON_SHADED;
		}
		current_toolbar = g->toolbar;

	} else if (menu == toolbar_menu) {
		ro_gui_menu_prepare_toolbars(current_toolbar);
		toolbar_menu->entries[1].menu_flags &= ~wimp_MENU_TICKED;
		if (current_toolbar->editor)
			toolbar_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
	} else if (menu == hotlist_menu) {
		ro_gui_menu_prepare_hotlist();
		current_toolbar = hotlist_tree->toolbar;
	} else if (menu == global_history_menu) {
		ro_gui_menu_prepare_global_history();
		current_toolbar = global_history_tree->toolbar;
	} else if (menu == url_suggest_menu) {
		if (!ro_gui_menu_prepare_url_suggest())
			return;
	}

	error = xwimp_create_menu(menu, x - 64, y);
	if (error) {
		LOG(("xwimp_create_menu: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
	} else {
		current_menu = menu;
		current_menu_x = x;
		current_menu_y = y;
	}
}


/**
 * Display a pop-up menu next to the specified icon.
 *
 * \param  menu  menu to open
 * \param  w     window handle
 * \param  i     icon handle
 */

void ro_gui_popup_menu(wimp_menu *menu, wimp_w w, wimp_i i)
{
	wimp_window_state state;
	wimp_icon_state icon_state;
	os_error *error;

	state.w = w;
	icon_state.w = w;
	icon_state.i = i;
	error = xwimp_get_window_state(&state);
	if (error) {
		LOG(("xwimp_get_window_state: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
		return;
	}

	error = xwimp_get_icon_state(&icon_state);
	if (error) {
		LOG(("xwimp_get_icon_state: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
		return;
	}

	ro_gui_create_menu(menu,
			state.visible.x0 + icon_state.icon.extent.x1 + 64,
			state.visible.y1 + icon_state.icon.extent.y1 -
			state.yscroll, current_gui);
}


/**
 * Handle menu selection.
 */

void ro_gui_menu_selection(wimp_selection *selection)
{
	struct node *node;
	char url[80];
	wimp_pointer pointer;
	wimp_window_state state;
	os_error *error;

	wimp_get_pointer_info(&pointer);

	if (current_menu == gui_form_select_menu && 0 <= selection->items[0]) {
		browser_window_form_select(current_gui->bw,
				gui_form_select_control,
				selection->items[0]);

	} else if (current_menu == iconbar_menu) {
		switch (selection->items[0]) {
			case 0: /* Info */
				ro_gui_create_menu((wimp_menu *) dialog_info,
						pointer.pos.x, pointer.pos.y, 0);
				break;
			case 1: /* Help */
				ro_gui_open_help_page("docs");
				break;
			case 2: /* Choices */
				ro_gui_dialog_open_config();
				break;
			case 3: /* Quit */
				netsurf_quit = true;
				break;
		}

	} else if (current_menu == url_suggest_menu) {
	  	if (!current_gui)
	  		LOG(("No current GUI"));
	  	else if (selection->items[0] >= 0) {
	  		browser_window_go(current_gui->bw,
	  			url_suggest_menu->entries[selection->items[0]].data.indirected_text.text, 0);
	  		global_history_add_recent(url_suggest_menu->entries[selection->items[0]].data.indirected_text.text);
	  	}
	} else if (current_menu == toolbar_menu) {
		switch (selection->items[0]) {
			case 0:	/* Toolbars-> */
				ro_gui_menu_toolbar_submenu_selection(selection->items[1]);
				break;
			case 1:	/* Edit toolbar */
				ro_gui_theme_toggle_edit(current_toolbar);
				ro_gui_menu_prepare_toolbars(current_toolbar);
				break;
		}
	} else if (current_menu == hotlist_menu) {
		switch (selection->items[0]) {
			case 0:	/* Hotlist-> */
				switch (selection->items[1]) {
					case 0: /* New */
						break;
					case 1: /* Export */
						break;
					case 2: /* Expand */
						tree_handle_expansion(hotlist_tree, hotlist_tree->root, true,
								(selection->items[2] != 2), (selection->items[2] != 1));
						break;
					case 3: /* Collapse */
						tree_handle_expansion(hotlist_tree, hotlist_tree->root, false,
								(selection->items[2] != 2), (selection->items[2] != 1));
						break;
					case 4:	/* Toolbars-> */
						ro_gui_menu_toolbar_submenu_selection(selection->items[2]);
						break;
				}
				break;
			case 1: /* Selection-> */
				switch (selection->items[1]) {
					case 0: /* Edit-> */
						break;
					case 1: /* Launch */
						ro_gui_tree_launch_selected(hotlist_tree);
						break;
					case 2: /* Delete */
						tree_delete_selected_nodes(hotlist_tree, hotlist_tree->root);
						break;
					case 3: /* Reset usage */
						tree_reset_URL_nodes(hotlist_tree, hotlist_tree->root, true);
						break;
				}
				break;
			case 2: /* Select all */
				ro_gui_tree_keypress(1, hotlist_tree);
				ro_gui_menu_prepare_hotlist();
				break;
			case 3: /* Clear */
				ro_gui_tree_keypress(26, hotlist_tree);
				ro_gui_menu_prepare_hotlist();
				break;
		}
	} else if (current_menu == global_history_menu) {
		switch (selection->items[0]) {
			case 0:	/* Hotlist-> */
				switch (selection->items[1]) {
					case 0: /* Export */
						break;
					case 1: /* Expand */
						tree_handle_expansion(global_history_tree, global_history_tree->root, true,
								(selection->items[2] != 2), (selection->items[2] != 1));
						break;
					case 2: /* Collapse */
						tree_handle_expansion(global_history_tree, global_history_tree->root, false,
								(selection->items[2] != 2), (selection->items[2] != 1));
						break;
					case 3:	/* Toolbars-> */
						ro_gui_menu_toolbar_submenu_selection(selection->items[2]);
						break;
				}
				break;
			case 1: /* Selection-> */
				switch (selection->items[1]) {
					case 0: /* Launch */
						ro_gui_tree_launch_selected(global_history_tree);
						break;
					case 1: /* Delete */
						tree_delete_selected_nodes(global_history_tree, global_history_tree->root);
						break;
				}
				break;
			case 2: /* Select all */
				ro_gui_tree_keypress(1, global_history_tree);
				ro_gui_menu_prepare_global_history();
				break;
			case 3: /* Clear */
				ro_gui_tree_keypress(26, global_history_tree);
				ro_gui_menu_prepare_global_history();
				break;
		}
	} else if (current_menu == browser_menu) {
		struct content *c = current_gui->bw->current_content;
		switch (selection->items[0]) {
			case MENU_PAGE:
				switch (selection->items[1]) {
					case 0: /* Info */
						break;
					case 1: /* Save */
						break;
					case 2: /* Full save */
						break;
					case 3: /* Export */
						break;
					case 4: /* Save location */
						switch (selection->items[2]) {
							case 0: /* URI */
								break;
							case 1: /* URL */
								break;
							case 2: /* Text */
								break;
						}
						break;
					case 5: /* Print */
						break;
					case 6: /* New window */
						browser_window_create(current_gui->bw->current_content->url,
								current_gui->bw, 0);
						break;
					case 7: /* Page source */
						ro_gui_view_source(c);
						break;
				}
				break;
			case MENU_OBJECT:
				if (!gui_menu_object_box)
					break;
				switch (selection->items[1]) {
					case 0: /* Info */
						break;
					case 1: /* Save */
						break;
					case 2: /* Export */
						break;
					case 3: /* Save Link */
						switch (selection->items[2]) {
							case 0: /* URI */
								break;
							case 1: /* URL */
								break;
							case 2: /* Text */
								break;
						}
						break;
					case 4: /* Reload */
						ro_gui_menu_object_reload();
						break;
				}
				break;
			case MENU_SELECTION:
				switch (selection->items[1]) {
					case 0: /* Copy to clipboard */
						ro_gui_copy_selection(current_gui);
						break;
					case 1: /* Select all */
						break;
					case 2: /* Clear */
						break;
				}
				break;
			case MENU_NAVIGATE:
				switch (selection->items[1]) {
					case 0: /* Home */
						if (option_homepage_url && option_homepage_url[0]) {
							browser_window_go(current_gui->bw, option_homepage_url, 0);
						} else {
							snprintf(url, sizeof url,
									"file:/<NetSurf$Dir>/Docs/intro_%s",
									option_language);
							browser_window_go(current_gui->bw, url, 0);
						}
						break;
					case 1: /* Back */
						history_back(current_gui->bw,
								current_gui->bw->history);
						ro_gui_prepare_navigate(current_gui);
						break;
					case 2: /* Forward */
						history_forward(current_gui->bw,
								current_gui->bw->history);
						ro_gui_prepare_navigate(current_gui);
						break;
					case 3: /* Reload */
						browser_window_reload(current_gui->bw, false);
						break;
					case 4: /* Stop */
						browser_window_stop(current_gui->bw);
						break;
				}
				break;
			case MENU_VIEW:
				switch (selection->items[1]) {
					case 0: /* Scale view */
						ro_gui_menu_prepare_scale();
						ro_gui_dialog_open_persistant(current_gui->window, dialog_zoom, false);
						break;
					case 1: /* Images -> */
						switch (selection->items[2]) {
							case 0:
								break;
							case 1:
								current_gui->option.background_images =
										!current_gui->option.background_images;
								break;
						}
						ro_gui_menu_prepare_images();
						gui_window_redraw_window(current_gui);
						break;
					case 2:	/* Toolbars-> */
						ro_gui_menu_toolbar_submenu_selection(selection->items[2]);
						break;
					case 3: /* Render -> */
						switch (selection->items[2]) {
							case 0:
								current_gui->option.background_blending =
										!current_gui->option.background_blending;
								gui_window_redraw_window(current_gui);
								break;
							case 1:
								current_gui->option.buffer_animations =
										!current_gui->option.buffer_animations;
								break;
							case 2:
								current_gui->option.buffer_everything =
										!current_gui->option.buffer_everything;
								break;
						}
						ro_gui_menu_prepare_render();
						break;
					case 4: /* Make default */
						ro_gui_window_default_options(current_gui->bw);
						ro_gui_save_options();
						break;
				}
				break;
			case MENU_UTILITIES:
				switch (selection->items[1]) {
					case 0: /* Hotlist -> */
						switch (selection->items[2]) {
							case 0:	/* Add to hotlist */
								node = tree_create_URL_node(hotlist_tree->root,
										messages_get(current_gui->title),
										current_gui->bw->current_content->url,
										ro_content_filetype(current_gui->bw->current_content),
										time(NULL), -1, 0);
								tree_redraw_area(hotlist_tree, node->box.x - NODE_INSTEP, 0,
										NODE_INSTEP, 16384);
								tree_handle_node_changed(hotlist_tree, node, false, true);
								ro_gui_tree_scroll_visible(hotlist_tree, &node->data);
								break;
							case -1:
							case 1: /* Show hotlist */
								ro_gui_hotlist_show();
								break;
						}
						break;
					case 1: /* History -> */
						switch (selection->items[2]) {
						  	case -1:
							case 0:	/* Local history */
								ro_gui_history_open(current_gui->bw,
										current_gui->bw->history, false);
								break;
							case 1: /* Global history */
								ro_gui_global_history_show();
								break;
						}
						break;
					case 2: /* Find Text -> */
#ifdef WITH_SEARCH
						ro_gui_search_open(current_gui, 0, 0, false, true);
#endif
						break;
					case 3: /* Window -> */
						switch (selection->items[2]) {
							case 0:
								ro_gui_screen_size(&option_window_screen_width,
										&option_window_screen_height);
								state.w = current_gui->window;
								error = xwimp_get_window_state(&state);
								if (error) {
									LOG(("xwimp_get_window_state: 0x%x: %s",
										error->errnum, error->errmess));
									warn_user("WimpError", error->errmess);
								}
								option_window_x = state.visible.x0;
								option_window_y = state.visible.y0;
								option_window_width = state.visible.x1 - state.visible.x0;
								option_window_height = state.visible.y1 - state.visible.y0;
								break;
							case 1:
								option_window_stagger = !option_window_stagger;
								break;
							case 2:
								option_window_size_clone = !option_window_size_clone;
								break;
							case 3:
								option_window_screen_width = 0;
								option_window_screen_height = 0;
								break;
						}
						if (selection->items[2] >= 0)
							ro_gui_save_options();
						ro_gui_menu_prepare_window();
						break;
				}
				break;
			case MENU_HELP:
				switch (selection->items[1]) {
					case -1: /* No sub-item */
					case 0: /* Contents */
						ro_gui_open_help_page("docs");
						break;
					case 1: /* User guide -> */
						ro_gui_open_help_page("guide");
						break;
					case 2: /* User information */
						ro_gui_open_help_page("info");
						break;
					case 3: /* About NetSurf */
						browser_window_create("file:/"
						"<NetSurf$Dir>/Docs/about", 0, 0);
						break;
					case 4: /* Interactive help */
						xos_cli("Filer_Run Resources:$.Apps.!Help");
						ro_gui_menu_prepare_help(true);
						break;
				}
				break;
		}
	} else if (current_menu == proxyauth_menu) {
		ro_gui_dialog_proxyauth_menu_selection(selection->items[0]);
	} else if (current_menu == image_quality_menu) {
		ro_gui_dialog_image_menu_selection(selection->items[0]);
	} else if (current_menu == languages_menu) {
		ro_gui_dialog_languages_menu_selection(languages_menu->
				entries[selection->items[0]].
				data.indirected_text.text);
	} else if (current_menu == font_menu) {
		ro_gui_dialog_font_menu_selection(selection->items[0]);
	}

	if (pointer.buttons == wimp_CLICK_ADJUST) {
		if (current_menu == gui_form_select_menu)
			gui_create_form_select_menu(current_gui->bw,
					gui_form_select_control);
		else
			ro_gui_create_menu(current_menu,
					current_menu_x, current_menu_y,
					current_gui);
	} else {
		if (current_menu == hotlist_menu)
			ro_gui_hotlist_menu_closed();
		else if (current_menu == global_history_menu)
			ro_gui_global_history_menu_closed();
	  	current_menu = NULL;
	  	current_gui = NULL;
	}
}


/**
 * Handle a selection for a toolbar submenu
 */
void ro_gui_menu_toolbar_submenu_selection(int index) {
	int height;

  	if ((index < 0) || (!current_toolbar))
  		return;
	switch (index) {
		case 0:
			current_toolbar->display_buttons = !current_toolbar->display_buttons;
			break;
		case 1:
			current_toolbar->display_url = !current_toolbar->display_url;
			break;
		case 2:
			current_toolbar->display_throbber = !current_toolbar->display_throbber;
			break;
		case 3:
			current_toolbar->display_status = !current_toolbar->display_status;
			break;
	}
	ro_gui_menu_prepare_toolbars(current_toolbar);
	current_toolbar->reformat_buttons = true;
	height = current_toolbar->height;
	ro_gui_theme_process_toolbar(current_toolbar, -1);
	if ((index == 1) && (current_toolbar->display_url))
		ro_gui_set_caret_first(current_toolbar->toolbar_handle);
	if (current_toolbar->type == THEME_BROWSER_TOOLBAR) {
		if ((height != current_toolbar->height) && (current_gui))
			ro_gui_window_update_dimensions(current_gui,
				height - current_toolbar->height);
	} else if (current_toolbar->type == THEME_HOTLIST_TOOLBAR) {
		tree_resized(hotlist_tree);
		xwimp_force_redraw((wimp_w)hotlist_tree->handle, 0,-16384, 16384, 16384);
	} else if (current_toolbar->type == THEME_HISTORY_TOOLBAR) {
		tree_resized(global_history_tree);
		xwimp_force_redraw((wimp_w)global_history_tree->handle, 0,-16384, 16384, 16384);
	}
}
  


/**
 * Handle Message_MenuWarning.
 */

void ro_gui_menu_warning(wimp_message_menu_warning *warning)
{
	if (current_menu == browser_menu)
		ro_gui_menu_browser_warning(warning);
	else if (current_menu == hotlist_menu)
		ro_gui_menu_hotlist_warning(warning);
	else if (current_menu == global_history_menu)
		ro_gui_menu_global_history_warning(warning);
}


/**
 * Handle Message_MenuWarning for the browser menu.
 */

void ro_gui_menu_browser_warning(wimp_message_menu_warning *warning)
{
	struct content *c;
	struct box *box;
	os_error *error = 0;

	c = current_gui->bw->current_content;

	switch (warning->selection.items[0]) {
	case MENU_PAGE: /* Page -> */
		switch (warning->selection.items[1]) {
		case 0: /* Page info */
			ro_gui_menu_prepare_pageinfo();
			error = xwimp_create_sub_menu(
					(wimp_menu *) dialog_pageinfo,
					warning->pos.x, warning->pos.y);
			break;

		case 1: /* Save */
			ro_gui_save_open(GUI_SAVE_SOURCE, c, true,
					warning->pos.x, warning->pos.y, 0, false);
			break;

		case 2: /* Save complete */
			ro_gui_save_open(GUI_SAVE_COMPLETE, c, true,
					warning->pos.x, warning->pos.y, 0, false);
			break;

		case 3: /* Export as -> */
			switch (warning->selection.items[2]) {
			case 0: /* Draw */
				ro_gui_save_open(GUI_SAVE_DRAW, c, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;

			case 1: /* Text */
				ro_gui_save_open(GUI_SAVE_TEXT, c, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;
			}
			break;

		case 4: /* Save Link */
			switch (warning->selection.items[2]) {
			case 0: /* URI */
				ro_gui_save_open(GUI_SAVE_LINK_URI, c, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;

			case 1: /* URL */
				ro_gui_save_open(GUI_SAVE_LINK_URL, c, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;

			case 2: /* Text */
				ro_gui_save_open(GUI_SAVE_LINK_TEXT, c, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;
			}
			break;

		case 5: /* Print -> */
#ifdef WITH_PRINT
			ro_gui_print_open(current_gui, warning->pos.x,
					warning->pos.y, true, false);
#endif
			break;
		}
		break;

	case MENU_OBJECT: /* Object -> */
		/** \todo  this is really dumb, the object should be the one
		 * that the user clicked menu over, not the one that happens to
		 * be under the menu now */
		box = gui_menu_object_box;
		if (!box)
			break;

		switch (warning->selection.items[1]) {
		case 0: /* Object info */
			ro_gui_menu_objectinfo(warning);
			return;

		case 1: /* Save */
			ro_gui_save_open(GUI_SAVE_OBJECT_ORIG, box->object,
					true,
					warning->pos.x, warning->pos.y, 0, false);
			break;

		case 2: /* Export */
			switch (warning->selection.items[2]) {
			case 0: /* Sprite */
				ro_gui_save_open(GUI_SAVE_OBJECT_NATIVE,
						box->object, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;
			}
			break;

		case 3: /* Save Link */
			switch (warning->selection.items[2]) {
			case 0: /* URI */
				ro_gui_save_open(GUI_SAVE_LINK_URI,
						box->object, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;

			case 1: /* URL */
				ro_gui_save_open(GUI_SAVE_LINK_URL,
						box->object, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;

			case 2: /* Text */
				ro_gui_save_open(GUI_SAVE_LINK_TEXT,
						box->object, true,
						warning->pos.x, warning->pos.y,
						0, false);
				break;
			}
			break;
		}
		break;

	case MENU_NAVIGATE: /* Navigate -> */
		ro_gui_prepare_navigate(current_gui);
		error = xwimp_create_sub_menu(browser_navigate_menu,
				warning->pos.x, warning->pos.y);
		break;

	case MENU_VIEW: /* View -> */
		switch (warning->selection.items[1]) {
			case -1: /* View-> */
				ro_gui_menu_prepare_view();
				if (current_gui->toolbar)
					view_menu.entries[2].icon_flags &= ~wimp_ICON_SHADED;
				else
					view_menu.entries[2].icon_flags |= wimp_ICON_SHADED;
				error = xwimp_create_sub_menu((wimp_menu *) browser_view_menu,
						warning->pos.x, warning->pos.y);
				break;
			case 0: /* Scale view -> */
				ro_gui_menu_prepare_scale();
				error = xwimp_create_sub_menu((wimp_menu *) dialog_zoom,
						warning->pos.x, warning->pos.y);
				break;

			case 1: /* Images -> */
				ro_gui_menu_prepare_images();
				error = xwimp_create_sub_menu(browser_image_menu,
						warning->pos.x, warning->pos.y);
				break;
			case 2: /* Toolbars -> */
				ro_gui_menu_prepare_toolbars(current_gui->toolbar);
				error = xwimp_create_sub_menu(browser_toolbar_menu,
						warning->pos.x, warning->pos.y);
				break;
			case 3: /* Render -> */
				ro_gui_menu_prepare_render();
				error = xwimp_create_sub_menu(browser_render_menu,
						warning->pos.x, warning->pos.y);
				break;
		}
		break;

	case MENU_UTILITIES:
		switch (warning->selection.items[1]) {
			case 0: /* Hotlist -> */
			case 1: /* History -> */
				break;
			case 2: /* Find text -> */
#ifdef WITH_SEARCH
				ro_gui_search_open(current_gui,
						   warning->pos.x,
						   warning->pos.y,
						   true,
						   false);
				break;
#endif
			case 3: /* Window -> */
				ro_gui_menu_prepare_window();
				error = xwimp_create_sub_menu(browser_window_menu,
						warning->pos.x, warning->pos.y);
				break;
		}
		break;
	case MENU_HELP: /* Help -> */
		ro_gui_menu_prepare_help(false);
		error = xwimp_create_sub_menu(browser_help_menu,
				warning->pos.x, warning->pos.y);
	}

	if (error) {
		LOG(("xwimp_create_sub_menu: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
	}
}


/**
 * Handle Message_MenuWarning for the hotlist menu.
 */

void ro_gui_menu_hotlist_warning(wimp_message_menu_warning *warning)
{
	os_error *error = NULL;
	struct node *node;

	switch (warning->selection.items[0]) {
		case 0:	/* Hotlist-> */
			switch (warning->selection.items[1]) {
				case 0: /* New-> */
					switch (warning->selection.items[2]) {
						case 0: /* Folder */
							ro_gui_hotlist_prepare_folder_dialog(NULL);
							error = xwimp_create_sub_menu(
									(wimp_menu *) dialog_folder,
									warning->pos.x, warning->pos.y);
							break;
						case 1: /* Entry */
							ro_gui_hotlist_prepare_entry_dialog(NULL);
							error = xwimp_create_sub_menu(
									(wimp_menu *) dialog_entry,
									warning->pos.x, warning->pos.y);
							break;
					}
					break;
				case 1: /* Export-> */
					ro_gui_save_open(GUI_SAVE_HOTLIST_EXPORT_HTML, 0, true,
							warning->pos.x, warning->pos.y, 0, false);
					break;
				case 4: /* Toolbars -> */
					ro_gui_menu_prepare_toolbars(hotlist_tree->toolbar);
					error = xwimp_create_sub_menu(browser_toolbar_menu,
							warning->pos.x, warning->pos.y);
					break;
			}
			break;
		case 1: /* Selection-> */
			switch (warning->selection.items[1]) {
				case -1: /* Root */
					ro_gui_menu_prepare_hotlist();
					error = xwimp_create_sub_menu(hotlist_select_menu,
							warning->pos.x, warning->pos.y);
					break;
				case 0: /* Edit-> */
					node = tree_get_selected_node(hotlist_tree->root);
					if (!node)
						break;
					if (node->folder) {
						ro_gui_hotlist_prepare_folder_dialog(node);
						error = xwimp_create_sub_menu(
								(wimp_menu *) dialog_folder,
								warning->pos.x, warning->pos.y);
					} else {
						ro_gui_hotlist_prepare_entry_dialog(node);
						error = xwimp_create_sub_menu(
								(wimp_menu *) dialog_entry,
								warning->pos.x, warning->pos.y);
					}
					break;
			}
			break;
	}

	if (error) {
		LOG(("xwimp_create_sub_menu: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
	}
}


/**
 * Handle Message_MenuWarning for the global history menu.
 */

void ro_gui_menu_global_history_warning(wimp_message_menu_warning *warning)
{
	os_error *error = NULL;

	switch (warning->selection.items[0]) {
		case 0:	/* History-> */
			switch (warning->selection.items[1]) {
				case 0: /* Export-> */
					ro_gui_save_open(GUI_SAVE_HISTORY_EXPORT_HTML, 0, true,
							warning->pos.x, warning->pos.y, 0, false);
					break;
				case 3: /* Toolbars -> */
					ro_gui_menu_prepare_toolbars(hotlist_tree->toolbar);
					error = xwimp_create_sub_menu(browser_toolbar_menu,
							warning->pos.x, warning->pos.y);
					break;
			}
			break;
		case 1: /* Selection-> */
			switch (warning->selection.items[1]) {
				case -1: /* Root */
					ro_gui_menu_prepare_global_history();
					error = xwimp_create_sub_menu(history_select_menu,
							warning->pos.x, warning->pos.y);
					break;
			}
			break;
	}

	if (error) {
		LOG(("xwimp_create_sub_menu: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
	}
}

/**
 * Update navigate menu status and toolbar icons.
 *
 * /param gui_window	the gui_window to update
 */
void ro_gui_prepare_navigate(struct gui_window *gui) {
	struct browser_window *bw;
	struct history *h;
	struct content *c;
	struct toolbar *t;
	bool update_menu = ((current_menu == browser_menu) && (current_gui == gui));
	int menu_changed = 0;
	unsigned int i;
	int suggestions;
	wimp_selection selection;

	if (!gui) {
		LOG(("Attempt to update a NULL gui_window icon status"));
		return;
	}

	/*	Get the data we need to work with
	*/
	bw = gui->bw;
	h = bw->history;
	c = bw->current_content;
	t = gui->toolbar;

	/*	Get the initial menu state to check for changes
	*/
	if (update_menu) {
		for (i = 0; i < 4; i++) {
			if (browser_navigate_menu->entries[i].icon_flags & wimp_ICON_SHADED) {
				menu_changed += (1 << i);
			}
		}
		if (menu.entries[0].icon_flags & wimp_ICON_SHADED) menu_changed += (1 << 4);
	}

	/*	Update the back/forwards icons/buttons
	*/
	if (update_menu) {
		if (history_back_available(h)) {
			browser_navigate_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		} else {
			browser_navigate_menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		}
		if (history_forward_available(h)) {
			browser_navigate_menu->entries[2].icon_flags &= ~wimp_ICON_SHADED;
		} else {
			browser_navigate_menu->entries[2].icon_flags |= wimp_ICON_SHADED;
		}
	}
	if (t) {
		if ((h) && (!t->editor)) {
			ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_BACK,
					!history_back_available(h));
			ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_FORWARD,
					!history_forward_available(h));
			ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_HISTORY,
				!(c || history_back_available(h) || history_forward_available(h)));
		} else {
			ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_BACK, !t->editor);
			ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_FORWARD, !t->editor);
			ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_HISTORY, !t->editor);
		}
		ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_BOOKMARK, (!hotlist_tree && !t->editor));
		global_history_get_recent(&suggestions);
		ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_SUGGEST, (suggestions <= 0));
	}

	/*	Update the stop/refresh icons/buttons
	*/
	if (bw->current_content && !bw->loading_content) {
		if (update_menu) browser_navigate_menu->entries[3].icon_flags &= ~wimp_ICON_SHADED;
		if (t) ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_RELOAD, false);
	} else {
		if (update_menu) browser_navigate_menu->entries[3].icon_flags |= wimp_ICON_SHADED;
		if (t) ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_RELOAD, !t->editor);
	}
	if (bw->loading_content || (bw->current_content &&
			bw->current_content->status != CONTENT_STATUS_DONE)) {
		if (update_menu) browser_navigate_menu->entries[4].icon_flags &= ~wimp_ICON_SHADED;
		if (t) ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_STOP, false);
	} else {
		if (update_menu) browser_navigate_menu->entries[4].icon_flags |= wimp_ICON_SHADED;
		if (t) ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_STOP, !t->editor);
	}

	/*	Set the scale view icon
	*/
	if (update_menu) {
		if (c) 
			menu.entries[0].icon_flags &= ~wimp_ICON_SHADED;
		else
			menu.entries[0].icon_flags |= wimp_ICON_SHADED;
	}
	if (t) {
		ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_SEARCH, (!c && !t->editor));
		ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_SCALE, (!c && !t->editor));
		ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_SAVE, (!c && !t->editor));
		ro_gui_set_icon_shaded_state(t->toolbar_handle, ICON_TOOLBAR_PRINT, (!c && !t->editor));
	}

	/*	Check if we've changed our menu state
	*/
	if (update_menu) {
		for (i = 0; i < 4; i++) {
			if (browser_navigate_menu->entries[i].icon_flags & wimp_ICON_SHADED) {
				menu_changed -= (1 << i);
			}
		}
		if (menu.entries[0].icon_flags & wimp_ICON_SHADED) menu_changed -= (1 << 4);

		/*	Re-open the submenu
		*/
		if (menu_changed != 0) {
			if (!xwimp_get_menu_state((wimp_menu_state_flags)0, &selection,
					(wimp_w)0, (wimp_i)0)) {
				if (selection.items[0] == MENU_NAVIGATE) {
					ro_gui_create_menu(current_menu, 0, 0, current_gui);
				}

			}
		}
	}
}


/**
 * Update image menu status
 */
static void ro_gui_menu_prepare_images(void) {
	if (current_menu != browser_menu) return;

	/*	Set the options according to the local values
	*/
	browser_image_menu->entries[1].menu_flags &= ~wimp_MENU_TICKED;
	if (current_gui->option.background_images) browser_image_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
	browser_image_menu->entries[2].menu_flags &= ~wimp_MENU_TICKED;
}


/**
 * Update render menu status
 */
static void ro_gui_menu_prepare_render(void) {
	if (current_menu != browser_menu) return;

	/*	Set the options according to the local values
	*/
	browser_render_menu->entries[1].menu_flags &= ~wimp_MENU_TICKED;
	browser_render_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
	browser_render_menu->entries[2].menu_flags &= ~wimp_MENU_TICKED;
	if (current_gui->option.background_blending) {
		browser_render_menu->entries[0].menu_flags |= wimp_MENU_TICKED;
	} else {
		browser_render_menu->entries[0].menu_flags &= ~wimp_MENU_TICKED;
	}
	if (current_gui->option.buffer_everything) {
		browser_render_menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		browser_render_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
		browser_render_menu->entries[2].menu_flags |= wimp_MENU_TICKED;
	} else {
		browser_render_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		browser_render_menu->entries[2].menu_flags &= ~wimp_MENU_TICKED;
		if (current_gui->option.buffer_animations) {
			browser_render_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
		} else {
			browser_render_menu->entries[1].menu_flags &= ~wimp_MENU_TICKED;
		}
	}
}


/**
 * Update window menu status
 */
static void ro_gui_menu_prepare_window(void) {
	if (current_menu != browser_menu) return;

	/*	Check if we can reset
	*/
	if ((option_window_screen_width != 0) && (option_window_screen_height != 0)) {
		browser_window_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		browser_window_menu->entries[3].icon_flags &= ~wimp_ICON_SHADED;

		/*	Check if we are staggered
		*/
		if (option_window_stagger) {
			browser_window_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
		} else {
			browser_window_menu->entries[1].menu_flags &= ~wimp_MENU_TICKED;
		}
	} else {
		browser_window_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
		browser_window_menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		browser_window_menu->entries[3].icon_flags |= wimp_ICON_SHADED;
	}

	/*	Set if we are cloing the window size
	*/
	if (option_window_size_clone) {
		browser_window_menu->entries[2].menu_flags |= wimp_MENU_TICKED;
	} else {
		browser_window_menu->entries[2].menu_flags &= ~wimp_MENU_TICKED;
	}
}


/**
 * Update toolbar menu status
 */
static void ro_gui_menu_prepare_toolbars(struct toolbar *toolbar) {
	int index;

	/*	Set our ticks, or shade everything if there's no toolbar
	*/
	if (toolbar) {
		for (index = 0; index < 4; index++) {
			browser_toolbar_menu->entries[index].icon_flags &= ~wimp_ICON_SHADED;
			browser_toolbar_menu->entries[index].menu_flags &= ~wimp_MENU_TICKED;
		}
		if (toolbar->editor) {
			browser_toolbar_menu->entries[0].icon_flags |= wimp_ICON_SHADED;
			browser_toolbar_menu->entries[0].menu_flags |= wimp_MENU_TICKED;
		}
		if ((toolbar->descriptor) && (toolbar->descriptor->theme)) {
			if (toolbar->display_buttons) browser_toolbar_menu->entries[0].menu_flags |= wimp_MENU_TICKED;
			if (toolbar->display_throbber) browser_toolbar_menu->entries[2].menu_flags |= wimp_MENU_TICKED;
		} else {
			for (index = 0; index < 3; index += 2) {
				browser_toolbar_menu->entries[index].icon_flags |= wimp_ICON_SHADED;
				browser_toolbar_menu->entries[index].menu_flags &= ~wimp_MENU_TICKED;
			}
		}
		if (toolbar->display_url)
			browser_toolbar_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
		if (toolbar->display_status)
			browser_toolbar_menu->entries[3].menu_flags |= wimp_MENU_TICKED;
		if (toolbar->type == THEME_BROWSER_TOOLBAR)
			browser_toolbar_menu->entries[0].menu_flags &= ~wimp_MENU_LAST;
		else
			browser_toolbar_menu->entries[0].menu_flags |= wimp_MENU_LAST;
	} else {
		for (index = 0; index < 4; index++) {
			browser_toolbar_menu->entries[index].icon_flags |= wimp_ICON_SHADED;
			browser_toolbar_menu->entries[index].menu_flags &= ~wimp_MENU_TICKED;
		}
		browser_toolbar_menu->entries[0].menu_flags &= ~wimp_MENU_LAST;
	}
}


/**
 * Update scale to current document value
 */
void ro_gui_menu_prepare_scale(void) {
	char scale_buffer[8];
	sprintf(scale_buffer, "%.0f", current_gui->option.scale * 100);
	ro_gui_set_icon_string(dialog_zoom, ICON_ZOOM_VALUE, scale_buffer);
	ro_gui_current_zoom_gui = current_gui;
}


/**
 * Update hotlist menu (all of)
 */
void ro_gui_menu_prepare_hotlist(void) {
  	os_error *error;
  	bool reopen = false;
	bool selection = false;
	struct node *single = NULL;
	struct toolbar *hotlist_toolbar;

	if (!hotlist_tree)
		return;
	hotlist_toolbar = hotlist_tree->toolbar;

	if (hotlist_tree->root->child) {
		single = tree_get_selected_node(hotlist_tree->root->child);
		selection = tree_has_selection(hotlist_tree->root->child);
		hotlist_menu->entries[2].icon_flags &= ~wimp_ICON_SHADED;
		hotlist_file_menu->entries[2].icon_flags &= ~wimp_ICON_SHADED;
		hotlist_file_menu->entries[3].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		hotlist_menu->entries[2].icon_flags |= wimp_ICON_SHADED;
		hotlist_file_menu->entries[2].icon_flags |= wimp_ICON_SHADED;
		hotlist_file_menu->entries[3].icon_flags &= wimp_ICON_SHADED;
	}

	if (hotlist_toolbar) {
	  	if (hotlist_toolbar->editor) {
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_OPEN, false);
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_EXPAND, false);
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_DELETE, false);
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_LAUNCH, false);
	  	} else {
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_OPEN, !hotlist_tree->root->child);
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_EXPAND, !hotlist_tree->root->child);
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_DELETE, !selection);
			ro_gui_set_icon_shaded_state(hotlist_toolbar->toolbar_handle,
					ICON_TOOLBAR_LAUNCH, !selection);
		}
	}

	if (selection) {
		reopen |= (hotlist_menu->entries[1].icon_flags & wimp_ICON_SHADED);
		hotlist_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		hotlist_menu->entries[3].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		reopen |= !(hotlist_menu->entries[1].icon_flags & wimp_ICON_SHADED);
		hotlist_menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		hotlist_menu->entries[3].icon_flags |= wimp_ICON_SHADED;
	}

	if (single) {
		reopen |= (hotlist_select_menu->entries[0].icon_flags & wimp_ICON_SHADED);
		hotlist_select_menu->entries[0].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		reopen |= !(hotlist_select_menu->entries[0].icon_flags & wimp_ICON_SHADED);
		hotlist_select_menu->entries[0].icon_flags |= wimp_ICON_SHADED;
	}

	if ((reopen) && (current_menu == hotlist_menu)) {
		error = xwimp_create_menu(hotlist_menu, 0, 0);
		if (error) {
			LOG(("xwimp_create_menu: 0x%x: %s",
					error->errnum, error->errmess));
			warn_user("MenuError", error->errmess);
		}
	}
}


/**
 * Update global history menu (all of)
 */
void ro_gui_menu_prepare_global_history(void) {
  	os_error *error;
  	bool reopen = false;
	bool selection = false;
	struct toolbar *global_history_toolbar;

	if (!global_history_tree)
		return;
	global_history_toolbar = global_history_tree->toolbar;

	if (global_history_tree->root->child) {
		selection = tree_has_selection(global_history_tree->root->child);
		global_history_menu->entries[2].icon_flags &= ~wimp_ICON_SHADED;
		history_file_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		history_file_menu->entries[2].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		global_history_menu->entries[2].icon_flags |= wimp_ICON_SHADED;
		history_file_menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		history_file_menu->entries[2].icon_flags |= wimp_ICON_SHADED;
	}

	if (global_history_toolbar) {
	  	if (global_history_toolbar->editor) {
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_OPEN, false);
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_EXPAND, false);
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_DELETE, false);
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_LAUNCH, false);
	  	} else {
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_OPEN, !global_history_tree->root->child);
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_EXPAND, !global_history_tree->root->child);
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_DELETE, !selection);
			ro_gui_set_icon_shaded_state(global_history_toolbar->toolbar_handle,
					ICON_TOOLBAR_LAUNCH, !selection);
		}
	}

	if (selection) {
		reopen |= (global_history_menu->entries[1].icon_flags & wimp_ICON_SHADED);
		global_history_menu->entries[1].icon_flags &= ~wimp_ICON_SHADED;
		global_history_menu->entries[3].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		reopen |= !(global_history_menu->entries[1].icon_flags & wimp_ICON_SHADED);
		global_history_menu->entries[1].icon_flags |= wimp_ICON_SHADED;
		global_history_menu->entries[3].icon_flags |= wimp_ICON_SHADED;
	}

	if ((reopen) && (current_menu == global_history_menu)) {
		error = xwimp_create_menu(global_history_menu, 0, 0);
		if (error) {
			LOG(("xwimp_create_menu: 0x%x: %s",
					error->errnum, error->errmess));
			warn_user("MenuError", error->errmess);
		}
	}
}


/**
 * Update the Interactive Help status
 *
 * \parmam force  force the status to be disabled
 */
void ro_gui_menu_prepare_help(int forced) {
	if (ro_gui_interactive_help_available() || (forced)) {
		browser_help_menu->entries[4].icon_flags |= wimp_ICON_SHADED;
	} else {
		browser_help_menu->entries[4].icon_flags &= ~wimp_ICON_SHADED;
	}
}

void ro_gui_menu_prepare_view(void) {
	if (current_gui->toolbar) {
		view_menu.entries[2].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		view_menu.entries[2].icon_flags |= wimp_ICON_SHADED;
	}
	if ((current_gui->bw) && (current_gui->bw->current_content)) {
		view_menu.entries[0].icon_flags &= ~wimp_ICON_SHADED;
	} else {
		view_menu.entries[0].icon_flags |= wimp_ICON_SHADED;
	}
}

void ro_gui_menu_prepare_image_quality(unsigned int tinct_options) {
  	for (int i = 0; i < 4; i++)
  		image_quality_menu->entries[i].menu_flags &= ~wimp_MENU_TICKED;
  	if (tinct_options & tinct_USE_OS_SPRITE_OP) {
  		image_quality_menu->entries[0].menu_flags |= wimp_MENU_TICKED;
  	} else if (tinct_options & tinct_ERROR_DIFFUSE) {
  		image_quality_menu->entries[3].menu_flags |= wimp_MENU_TICKED;
  	} else if (tinct_options & tinct_DITHER) {
  		image_quality_menu->entries[2].menu_flags |= wimp_MENU_TICKED;
  	} else {
  		image_quality_menu->entries[1].menu_flags |= wimp_MENU_TICKED;
  	}
}


void ro_gui_menu_prepare_pageinfo(void)
{
	struct content *c = current_gui->bw->current_content;
	char icon_buf[20] = "file_xxx";
	char enc_buf[40];
	char enc_token[10] = "Encoding0";
	const char *icon = icon_buf;
	const char *title = "-";
	const char *url = "-";
	const char *enc = "-";
	const char *mime = "-";

	if (c->title != 0)     title = c->title;
	if (c->url != 0)       url = c->url;
	if (c->mime_type != 0) mime = c->mime_type;

	sprintf(icon_buf, "file_%x", ro_content_filetype(c));

	/*	Ensure the correct icon exists
	*/
	if (xwimpspriteop_read_sprite_info(icon_buf, 0, 0, 0, 0)) {
		sprintf(icon_buf, "file_xxx");
	}

	if (c->type == CONTENT_HTML) {
		if (c->data.html.encoding) {
			enc_token[8] = '0' + c->data.html.encoding_source;
			snprintf(enc_buf, sizeof enc_buf, "%s (%s)",
					c->data.html.encoding,
					messages_get(enc_token));
			enc = enc_buf;
		} else {
			enc = messages_get("EncodingUnk");
		}
	}

	ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_ICON, icon);
	ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_TITLE, title);
	ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_URL, url);
	ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_ENC, enc);
	ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_TYPE, mime);
}


void ro_gui_menu_objectinfo(wimp_message_menu_warning *warning)
{
	char icon_buf[20] = "file_xxx";
	const char *url = "-";
	const char *target = "-";
	const char *mime = "-";
	os_error *error;

	sprintf(icon_buf, "file_%.3x",
			ro_content_filetype(gui_menu_object_box->object));
	if (!ro_gui_wimp_sprite_exists(icon_buf))
		sprintf(icon_buf, "file_xxx");

	if (gui_menu_object_box->object->url)
		url = gui_menu_object_box->object->url;
	if (gui_menu_object_box->href)
		target = gui_menu_object_box->href;
	if (gui_menu_object_box->object->mime_type)
		mime = gui_menu_object_box->object->mime_type;

	ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_ICON, icon_buf);
	ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_URL, url);
	ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_TARGET, target);
	ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_TYPE, mime);

	error = xwimp_create_sub_menu((wimp_menu *) dialog_objinfo,
			warning->pos.x, warning->pos.y);
	if (error) {
		LOG(("xwimp_create_sub_menu: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("MenuError", error->errmess);
	}
}


void ro_gui_menu_object_reload(void)
{
	gui_menu_object_box->object->fresh = false;
	browser_window_reload(current_gui->bw, false);
}


/**
 * Display a menu of options for a form select control.
 *
 * \param  bw	    browser window containing form control
 * \param  control  form control of type GADGET_SELECT
 */

void gui_create_form_select_menu(struct browser_window *bw,
		struct form_control *control)
{
	unsigned int i = 0, j;
	char *text_convert;
	struct form_option *option;
	wimp_pointer pointer;
	os_error *error;

	for (option = control->data.select.items; option; option = option->next)
		i++;

	if (i == 0)
		return;

	if (gui_form_select_menu) {
	  	free(gui_form_select_menu->title_data.indirected_text.text);
		for (j = 0; ; j++) {
			free(gui_form_select_menu->entries[j].data.
					indirected_text.text);
			if (gui_form_select_menu->entries[j].menu_flags &
					wimp_MENU_LAST)
				break;
		}
		free(gui_form_select_menu);
		gui_form_select_menu = 0;
	}

	gui_form_select_menu = malloc(wimp_SIZEOF_MENU(i));
	if (!gui_form_select_menu) {
		warn_user("NoMemory", 0);
		return;
	}

	gui_form_select_menu->title_data.indirected_text.text =
			strdup(messages_get("SelectMenu"));
	gui_form_select_menu->title_fg = wimp_COLOUR_BLACK;
	gui_form_select_menu->title_bg = wimp_COLOUR_LIGHT_GREY;
	gui_form_select_menu->work_fg = wimp_COLOUR_BLACK;
	gui_form_select_menu->work_bg = wimp_COLOUR_WHITE;
	gui_form_select_menu->width = 200;
	gui_form_select_menu->height = wimp_MENU_ITEM_HEIGHT;
	gui_form_select_menu->gap = wimp_MENU_ITEM_GAP;

	for (i = 0, option = control->data.select.items; option;
			i++, option = option->next) {
		gui_form_select_menu->entries[i].menu_flags = 0;
		if (option->selected)
			gui_form_select_menu->entries[i].menu_flags =
					wimp_MENU_TICKED;
		gui_form_select_menu->entries[i].sub_menu = wimp_NO_SUB_MENU;
		gui_form_select_menu->entries[i].icon_flags = wimp_ICON_TEXT |
				wimp_ICON_INDIRECTED | wimp_ICON_FILLED |
				(wimp_COLOUR_BLACK <<
						wimp_ICON_FG_COLOUR_SHIFT) |
				(wimp_COLOUR_WHITE <<
						wimp_ICON_BG_COLOUR_SHIFT);
		/* \todo  can cnv_str_local_enc() fail? */
		gui_form_select_menu->entries[i].data.indirected_text.text =
				cnv_str_local_enc(option->text);
		/* convert spaces to hard spaces to stop things like 'Go Home' being treated
		   as if 'Home' is a keyboard shortcut and right aligned in the menu. */
		text_convert = gui_form_select_menu->entries[i].data.indirected_text.text - 1;
		while (*++text_convert != '\0')
			if (*text_convert == 0x20)
				*text_convert = 0xa0;
		gui_form_select_menu->entries[i].data.indirected_text.
				validation = select_null_text_string;
		gui_form_select_menu->entries[i].data.indirected_text.size =
				strlen(gui_form_select_menu->entries[i].
				data.indirected_text.text) + 1;
	}

	gui_form_select_menu->entries[0].menu_flags |=
			wimp_MENU_TITLE_INDIRECTED;
	gui_form_select_menu->entries[i - 1].menu_flags |= wimp_MENU_LAST;

	error = xwimp_get_pointer_info(&pointer);
	if (error) {
		LOG(("xwimp_get_pointer_info: 0x%x: %s",
				error->errnum, error->errmess));
		warn_user("WimpError", error->errmess);
	}

	current_gui = bw->window;
	gui_form_select_control = control;
	ro_gui_create_menu(gui_form_select_menu,
			pointer.pos.x, pointer.pos.y, bw->window);
}