mirrors/netsurf
1
0
Fork 0
mirror of https://github.com/netsurf-browser/netsurf synced 2024-12-25 05:27:00 +03:00
Code Issues Packages Projects Releases Wiki Activity
f42ed976e5
netsurf/riscos/menus.c
Steve Fryatt 3529ead319 Restore toolbar menus in RO treeview windows. 
svn path=/trunk/netsurf/; revision=10908
2010-10-24 23:17:21 +00:00

2367 lines
66 KiB
C
Raw Blame History

/*
* 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>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* Menu creation and handling (implementation).
*/
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "oslib/os.h"
#include "oslib/osbyte.h"
#include "oslib/osgbpb.h"
#include "oslib/territory.h"
#include "oslib/wimp.h"
#include "content/content.h"
#include "content/hlcache.h"
#include "content/urldb.h"
#include "desktop/cookies.h"
#include "desktop/browser.h"
#include "desktop/gui.h"
#include "desktop/history_global_core.h"
#include "desktop/history_core.h"
#include "desktop/hotlist.h"
#include "desktop/netsurf.h"
#include "desktop/selection.h"
#include "desktop/textinput.h"
#include "render/box.h"
#include "render/form.h"
#include "riscos/dialog.h"
#include "render/form.h"
#include "riscos/configure.h"
#include "riscos/cookies.h"
#include "riscos/gui.h"
#include "riscos/global_history.h"
#include "riscos/help.h"
#include "riscos/hotlist.h"
#include "riscos/menus.h"
#include "riscos/options.h"
#include "riscos/save.h"
#include "riscos/tinct.h"
#include "riscos/theme.h"
#include "riscos/treeview.h"
#include "riscos/url_suggest.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"
#include "utils/log.h"
#include "utils/messages.h"
#include "utils/url.h"
#include "utils/utils.h"
#include "utils/utf8.h"
struct menu_definition_entry {
menu_action action; /**< menu action */
wimp_menu_entry *menu_entry; /**< corresponding menu entry */
const char *entry_key; /**< Messages key for entry text */
struct menu_definition_entry *next; /**< next menu entry */
};
struct menu_definition {
wimp_menu *menu; /**< corresponding menu */
const char *title_key; /**< Messages key for title text */
int current_encoding; /**< Identifier for current text encoding of menu text (as per OS_Byte,71,127) */
struct menu_definition_entry *entries; /**< menu entries */
struct menu_definition *next; /**< next menu */
};
static void ro_gui_menu_define_menu_add(struct menu_definition *definition,
const struct ns_menu *menu, int depth,
wimp_menu_entry *parent_entry,
int first, int last, const char *prefix, int prefix_length);
static struct menu_definition *ro_gui_menu_find_menu(wimp_menu *menu);
static struct menu_definition_entry *ro_gui_menu_find_entry(wimp_menu *menu,
menu_action action);
static menu_action ro_gui_menu_find_action(wimp_menu *menu,
wimp_menu_entry *menu_entry);
static void ro_gui_menu_get_window_details(wimp_w w, struct gui_window **g,
struct browser_window **bw, hlcache_handle **h,
struct toolbar **toolbar,
bool *is_cookies, bool *is_hotlist, bool *is_global_history);
static int ro_gui_menu_get_checksum(void);
static void ro_gui_menu_prepare_pageinfo(struct gui_window *g);
static void ro_gui_menu_prepare_objectinfo(hlcache_handle *object,
const char *href);
static bool ro_gui_menu_translate(struct menu_definition *menu);
/* 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))
/** The currently defined menus to perform actions for */
static struct menu_definition *ro_gui_menu_definitions;
/** The current menu being worked with (may not be open) */
wimp_menu *current_menu;
/** Whether a menu is currently open */
bool current_menu_open = false;
/** Object under menu, or 0 if no object. */
static hlcache_handle *current_menu_object = 0;
/** URL of link under menu, or 0 if no link. */
static const char *current_menu_url = 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;
/** Window that owns the current menu */
wimp_w current_menu_window;
/** Icon that owns the current menu (only valid for popup menus) */
static wimp_i current_menu_icon;
/** The height of the iconbar menu */
int iconbar_menu_height = 5 * 44;
/** The available menus */
wimp_menu *iconbar_menu, *browser_menu, *image_quality_menu,
*browser_toolbar_menu, *tree_toolbar_menu,
*proxy_type_menu, *languages_menu;
static wimp_MENU(URL_SUGGEST_MAX_URLS) url_suggest_menu_block;
wimp_menu *url_suggest_menu = (wimp_menu *) &url_suggest_menu_block;
/* the values given in PRM 3-157 for how to check menus/windows are
* incorrect so we use a hack of checking if the sub-menu has bit 0
* set which is undocumented but true of window handles on
* all target OS versions */
#define IS_MENU(menu) !((int)(menu) & 1)
/**
* Create menu structures.
*/
void ro_gui_menu_init(void)
{
/* iconbar menu */
static const struct ns_menu iconbar_definition = {
"NetSurf", {
{ "Info", NO_ACTION, &dialog_info },
{ "AppHelp", HELP_OPEN_CONTENTS, 0 },
{ "Open", BROWSER_NAVIGATE_URL, 0 },
{ "Open.OpenURL", BROWSER_NAVIGATE_URL, &dialog_openurl },
{ "Open.HotlistShow", HOTLIST_SHOW, 0 },
{ "Open.HistGlobal", HISTORY_SHOW_GLOBAL, 0 },
{ "Open.ShowCookies", COOKIES_SHOW, 0 },
{ "Choices", CHOICES_SHOW, 0 },
{ "Quit", APPLICATION_QUIT, 0 },
{NULL, 0, 0}
}
};
iconbar_menu = ro_gui_menu_define_menu(&iconbar_definition);
/* browser menu */
static const struct ns_menu browser_definition = {
"NetSurf", {
{ "Page", BROWSER_PAGE, 0 },
{ "Page.PageInfo",BROWSER_PAGE_INFO, &dialog_pageinfo },
{ "Page.Save", BROWSER_SAVE, &dialog_saveas },
{ "Page.SaveComp", BROWSER_SAVE_COMPLETE, &dialog_saveas },
{ "Page.Export", NO_ACTION, 0 },
#ifdef WITH_DRAW_EXPORT
{ "Page.Export.Draw", BROWSER_EXPORT_DRAW, &dialog_saveas },
#endif
#ifdef WITH_PDF_EXPORT
{ "Page.Export.PDF", BROWSER_EXPORT_PDF, &dialog_saveas },
#endif
{ "Page.Export.Text", BROWSER_EXPORT_TEXT, &dialog_saveas },
{ "Page.SaveURL", NO_ACTION, 0 },
{ "Page.SaveURL.URI", BROWSER_SAVE_URL_URI, &dialog_saveas },
{ "Page.SaveURL.URL", BROWSER_SAVE_URL_URL, &dialog_saveas },
{ "Page.SaveURL.LinkText", BROWSER_SAVE_URL_TEXT, &dialog_saveas },
{ "_Page.Print", BROWSER_PRINT, &dialog_print },
{ "Page.NewWindow", BROWSER_NEW_WINDOW, 0 },
{ "Page.FindText", BROWSER_FIND_TEXT, &dialog_search },
{ "Page.ViewSrc", BROWSER_VIEW_SOURCE, 0 },
{ "Object", BROWSER_OBJECT, 0 },
{ "Object.Object", BROWSER_OBJECT_OBJECT, 0 },
{ "Object.Object.ObjInfo", BROWSER_OBJECT_INFO, &dialog_objinfo },
{ "Object.Object.ObjSave", BROWSER_OBJECT_SAVE, &dialog_saveas },
{ "Object.Object.Export", BROWSER_OBJECT_EXPORT, 0 },
{ "Object.Object.Export.Sprite", BROWSER_OBJECT_EXPORT_SPRITE, &dialog_saveas },
#ifdef WITH_DRAW_EXPORT
{ "Object.Object.Export.ObjDraw", BROWSER_OBJECT_EXPORT_DRAW, &dialog_saveas },
#endif
{ "Object.Object.SaveURL", NO_ACTION, 0 },
{ "Object.Object.SaveURL.URI", BROWSER_OBJECT_SAVE_URL_URI, &dialog_saveas },
{ "Object.Object.SaveURL.URL", BROWSER_OBJECT_SAVE_URL_URL, &dialog_saveas },
{ "Object.Object.SaveURL.LinkText", BROWSER_OBJECT_SAVE_URL_TEXT, &dialog_saveas },
{ "Object.Object.ObjPrint", BROWSER_OBJECT_PRINT, 0 },
{ "Object.Object.ObjReload", BROWSER_OBJECT_RELOAD, 0 },
{ "Object.Link", BROWSER_OBJECT_LINK, 0 },
{ "Object.Link.LinkSave", BROWSER_LINK_SAVE, 0 },
{ "Object.Link.LinkSave.URI", BROWSER_LINK_SAVE_URI, &dialog_saveas },
{ "Object.Link.LinkSave.URL", BROWSER_LINK_SAVE_URL, &dialog_saveas },
{ "Object.Link.LinkSave.LinkText", BROWSER_LINK_SAVE_TEXT, &dialog_saveas },
{ "_Object.Link.LinkDload", BROWSER_LINK_DOWNLOAD, 0 },
{ "Object.Link.LinkNew", BROWSER_LINK_NEW_WINDOW, 0 },
{ "Selection", BROWSER_SELECTION, 0 },
{ "_Selection.SelSave", BROWSER_SELECTION_SAVE, &dialog_saveas },
{ "Selection.Copy", BROWSER_SELECTION_COPY, 0 },
{ "Selection.Cut", BROWSER_SELECTION_CUT, 0 },
{ "_Selection.Paste", BROWSER_SELECTION_PASTE, 0 },
{ "Selection.Clear", BROWSER_SELECTION_CLEAR, 0 },
{ "Selection.SelectAll", BROWSER_SELECTION_ALL, 0 },
{ "Navigate", NO_ACTION, 0 },
{ "Navigate.Home", BROWSER_NAVIGATE_HOME, 0 },
{ "Navigate.Back", BROWSER_NAVIGATE_BACK, 0 },
{ "Navigate.Forward", BROWSER_NAVIGATE_FORWARD, 0 },
{ "_Navigate.UpLevel", BROWSER_NAVIGATE_UP, 0 },
{ "Navigate.Reload", BROWSER_NAVIGATE_RELOAD_ALL, 0 },
{ "Navigate.Stop", BROWSER_NAVIGATE_STOP, 0 },
{ "View", NO_ACTION, 0 },
{ "View.ScaleView", BROWSER_SCALE_VIEW, &dialog_zoom },
{ "View.Images", NO_ACTION, 0 },
{ "View.Images.ForeImg", BROWSER_IMAGES_FOREGROUND, 0 },
{ "View.Images.BackImg", BROWSER_IMAGES_BACKGROUND, 0 },
{ "View.Toolbars", NO_ACTION, 0 },
{ "View.Toolbars.ToolButtons", TOOLBAR_BUTTONS, 0 },
{ "View.Toolbars.ToolAddress", TOOLBAR_ADDRESS_BAR, 0 },
{ "_View.Toolbars.ToolThrob", TOOLBAR_THROBBER, 0 },
{ "View.Toolbars.EditToolbar", TOOLBAR_EDIT, 0 },
{ "_View.Render", NO_ACTION, 0 },
{ "View.Render.RenderAnims", BROWSER_BUFFER_ANIMS, 0 },
{ "View.Render.RenderAll", BROWSER_BUFFER_ALL, 0 },
{ "_View.OptDefault", BROWSER_SAVE_VIEW, 0 },
{ "View.Window", NO_ACTION, 0 },
{ "View.Window.WindowSave", BROWSER_WINDOW_DEFAULT, 0 },
{ "View.Window.WindowStagr", BROWSER_WINDOW_STAGGER, 0 },
{ "_View.Window.WindowSize", BROWSER_WINDOW_COPY, 0 },
{ "View.Window.WindowReset", BROWSER_WINDOW_RESET, 0 },
{ "Utilities", NO_ACTION, 0 },
{ "Utilities.Hotlist", HOTLIST_SHOW, 0 },
{ "Utilities.Hotlist.HotlistAdd", HOTLIST_ADD_URL, 0 },
{ "Utilities.Hotlist.HotlistShow", HOTLIST_SHOW, 0 },
{ "Utilities.History", HISTORY_SHOW_GLOBAL, 0 },
{ "Utilities.History.HistLocal", HISTORY_SHOW_LOCAL, 0 },
{ "Utilities.History.HistGlobal", HISTORY_SHOW_GLOBAL, 0 },
{ "Utilities.Cookies", COOKIES_SHOW, 0 },
{ "Utilities.Cookies.ShowCookies", COOKIES_SHOW, 0 },
{ "Utilities.Cookies.DeleteCookies", COOKIES_DELETE, 0 },
{ "Help", HELP_OPEN_CONTENTS, 0 },
{ "Help.HelpContent", HELP_OPEN_CONTENTS, 0 },
{ "Help.HelpGuide", HELP_OPEN_GUIDE, 0 },
{ "_Help.HelpInfo", HELP_OPEN_INFORMATION, 0 },
{ "_Help.HelpAbout", HELP_OPEN_ABOUT, 0 },
{ "Help.HelpInter", HELP_LAUNCH_INTERACTIVE, 0 },
{NULL, 0, 0}
}
};
browser_menu = ro_gui_menu_define_menu(&browser_definition);
/* image quality menu */
static const struct ns_menu images_definition = {
"Display", {
{ "ImgStyle0", NO_ACTION, 0 },
{ "ImgStyle1", NO_ACTION, 0 },
{ "ImgStyle2", NO_ACTION, 0 },
{ "ImgStyle3", NO_ACTION, 0 },
{NULL, 0, 0}
}
};
image_quality_menu = ro_gui_menu_define_menu(&images_definition);
/* browser toolbar menu */
static const struct ns_menu browser_toolbar_definition = {
"Toolbar", {
{ "Toolbars", NO_ACTION, 0 },
{ "Toolbars.ToolButtons", TOOLBAR_BUTTONS, 0 },
{ "Toolbars.ToolAddress", TOOLBAR_ADDRESS_BAR, 0 },
{ "Toolbars.ToolThrob", TOOLBAR_THROBBER, 0 },
{ "EditToolbar", TOOLBAR_EDIT, 0 },
{NULL, 0, 0}
}
};
browser_toolbar_menu = ro_gui_menu_define_menu(
&browser_toolbar_definition);
/* tree toolbar menu */
static const struct ns_menu tree_toolbar_definition = {
"Toolbar", {
{ "Toolbars", NO_ACTION, 0 },
{ "Toolbars.ToolButtons", TOOLBAR_BUTTONS, 0 },
{ "EditToolbar", TOOLBAR_EDIT, 0 },
{NULL, 0, 0}
}
};
tree_toolbar_menu = ro_gui_menu_define_menu(&tree_toolbar_definition);
/* proxy menu */
static const struct ns_menu proxy_type_definition = {
"ProxyType", {
{ "ProxyNone", NO_ACTION, 0 },
{ "ProxyNoAuth", NO_ACTION, 0 },
{ "ProxyBasic", NO_ACTION, 0 },
{ "ProxyNTLM", NO_ACTION, 0 },
{NULL, 0, 0}
}
};
proxy_type_menu = ro_gui_menu_define_menu(&proxy_type_definition);
/* special case menus */
ro_gui_url_suggest_init(url_suggest_menu);
/* Note: This table *must* be kept in sync with the LangNames file */
static const struct ns_menu lang_definition = {
"Languages", {
{ "lang_af", NO_ACTION, 0 },
{ "lang_bm", NO_ACTION, 0 },
{ "lang_ca", NO_ACTION, 0 },
{ "lang_cs", NO_ACTION, 0 },
{ "lang_cy", NO_ACTION, 0 },
{ "lang_da", NO_ACTION, 0 },
{ "lang_de", NO_ACTION, 0 },
{ "lang_en", NO_ACTION, 0 },
{ "lang_es", NO_ACTION, 0 },
{ "lang_et", NO_ACTION, 0 },
{ "lang_eu", NO_ACTION, 0 },
{ "lang_ff", NO_ACTION, 0 },
{ "lang_fi", NO_ACTION, 0 },
{ "lang_fr", NO_ACTION, 0 },
{ "lang_ga", NO_ACTION, 0 },
{ "lang_gl", NO_ACTION, 0 },
{ "lang_ha", NO_ACTION, 0 },
{ "lang_hr", NO_ACTION, 0 },
{ "lang_hu", NO_ACTION, 0 },
{ "lang_id", NO_ACTION, 0 },
{ "lang_is", NO_ACTION, 0 },
{ "lang_it", NO_ACTION, 0 },
{ "lang_lt", NO_ACTION, 0 },
{ "lang_lv", NO_ACTION, 0 },
{ "lang_ms", NO_ACTION, 0 },
{ "lang_mt", NO_ACTION, 0 },
{ "lang_nl", NO_ACTION, 0 },
{ "lang_no", NO_ACTION, 0 },
{ "lang_pl", NO_ACTION, 0 },
{ "lang_pt", NO_ACTION, 0 },
{ "lang_rn", NO_ACTION, 0 },
{ "lang_ro", NO_ACTION, 0 },
{ "lang_rw", NO_ACTION, 0 },
{ "lang_sk", NO_ACTION, 0 },
{ "lang_sl", NO_ACTION, 0 },
{ "lang_so", NO_ACTION, 0 },
{ "lang_sq", NO_ACTION, 0 },
{ "lang_sr", NO_ACTION, 0 },
{ "lang_sv", NO_ACTION, 0 },
{ "lang_sw", NO_ACTION, 0 },
{ "lang_tr", NO_ACTION, 0 },
{ "lang_uz", NO_ACTION, 0 },
{ "lang_vi", NO_ACTION, 0 },
{ "lang_wo", NO_ACTION, 0 },
{ "lang_xs", NO_ACTION, 0 },
{ "lang_yo", NO_ACTION, 0 },
{ "lang_zu", NO_ACTION, 0 },
{ NULL, 0, 0 }
}
};
languages_menu = ro_gui_menu_define_menu(&lang_definition);
}
/**
* Display a menu.
*
* \param *menu Pointer to the menu to be displayed.
* \param x The x position.
* \param y The y position.
* \param w The window that the menu belongs to.
* \param prepare true if the menu is to be prepared; otherwise
* false (mainly for use by wimp_event module).
*/
void ro_gui_menu_create(wimp_menu *menu, int x, int y, wimp_w w, bool prepare)
{
struct gui_window *g;
os_error *error;
os_coord pos;
int i;
menu_action action;
struct menu_definition *definition;
/* translate menu, if necessary (this returns quickly
* if there's nothing to be done) */
definition = ro_gui_menu_find_menu(menu);
if (definition) {
if (!ro_gui_menu_translate(definition)) {
warn_user("NoMemory", 0);
return;
}
}
/* read the object under the pointer for a new gui_window menu */
if ((!current_menu) && (menu == browser_menu)) {
hlcache_handle *h;
g = ro_gui_window_lookup(w);
h = g->bw->current_content;
if (!ro_gui_window_to_window_pos(g, x, y, &pos))
return;
current_menu_object = NULL;
current_menu_url = NULL;
if (h) {
switch (content_get_type(h)) {
case CONTENT_HTML: {
struct box *box;
box = box_object_at_point(h, pos.x,
pos.y);
current_menu_object = box ?
box->object : NULL;
box = box_href_at_point(h, pos.x,
pos.y);
current_menu_url = box ?
box->href : NULL;
}
break;
case CONTENT_TEXTPLAIN:
/* no object, no url */
break;
default:
current_menu_object = h;
break;
}
}
}
/* store the menu characteristics */
current_menu = menu;
current_menu_window = w;
current_menu_icon = -1;
/* prepare the menu state */
if (menu == url_suggest_menu) {
if (!ro_gui_url_suggest_prepare_menu())
return;
} else if (menu == recent_search_menu) {
if (!ro_gui_search_prepare_menu())
return;
} else if (prepare) {
i = 0;
do {
action = ro_gui_menu_find_action(menu,
&menu->entries[i]);
if (action != NO_ACTION)
ro_gui_menu_prepare_action(w, action, false);
} while (!(menu->entries[i++].menu_flags & wimp_MENU_LAST));
}
/* create the menu */
current_menu_open = true;
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);
ro_gui_menu_closed(true);
}
}
/**
* 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_menu_create(menu,
state.visible.x0 + icon_state.icon.extent.x1 + 64,
state.visible.y1 + icon_state.icon.extent.y1 -
state.yscroll, w, true);
current_menu_icon = i;
}
/**
* Clean up after a menu has been closed, or forcible close an open menu.
*
* \param cleanup Call any terminating functions (sub-window isn't going to be instantly re-opened)
*/
void ro_gui_menu_closed(bool cleanup)
{
struct gui_window *g;
struct browser_window *bw;
hlcache_handle *h;
struct toolbar *t;
os_error *error;
bool is_cookies, is_hotlist, is_global_history;
if (current_menu) {
error = xwimp_create_menu(wimp_CLOSE_MENU, 0, 0);
if (error) {
LOG(("xwimp_create_menu: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
}
ro_gui_menu_get_window_details(current_menu_window,
&g, &bw, &h, &t,
&is_cookies, &is_hotlist,
&is_global_history);
if (cleanup) {
ro_gui_wimp_event_menus_closed(current_menu_window,
current_menu_icon, current_menu);
}
current_menu = NULL;
}
current_menu_window = NULL;
current_menu_icon = 0;
current_menu_open = false;
gui_form_select_control = NULL;
}
/**
* The content has changed, reset object references
*/
void ro_gui_menu_objects_moved(void)
{
gui_form_select_control = NULL;
current_menu_object = NULL;
current_menu_url = NULL;
ro_gui_menu_prepare_action(0, BROWSER_OBJECT, false);
if ((current_menu) && (current_menu == gui_form_select_menu))
ro_gui_menu_closed(true);
}
/**
* Handle menu selection.
*/
void ro_gui_menu_selection(wimp_selection *selection)
{
int i, j;
bool needs_prepare;
wimp_menu_entry *menu_entry;
menu_action action;
wimp_pointer pointer;
struct gui_window *g = NULL;
wimp_menu *menu;
os_error *error;
int previous_menu_icon = current_menu_icon;
char *url;
/* if we are using gui_multitask then menu selection events
* may be delivered after the menu has been closed. As such,
* we simply ignore these events. */
if (!current_menu)
return
assert(current_menu_window);
/* get the menu entry and associated action and definition */
menu_entry = &current_menu->entries[selection->items[0]];
for (i = 1; selection->items[i] != -1; i++)
menu_entry = &menu_entry->sub_menu->
entries[selection->items[i]];
action = ro_gui_menu_find_action(current_menu, menu_entry);
/* Deal with the menu action. We first pass it to Wimp_Event to
* handle any automatic menus. If this doesn't recognise the details,
* it is passed on to the code in menus.c.
*/
needs_prepare = false;
if (!ro_gui_wimp_event_menu_selection(current_menu_window,
current_menu_icon, current_menu, selection, action)) {
/* perform menu action */
if (action != NO_ACTION)
ro_gui_menu_handle_action(current_menu_window,
action, false);
/* perform non-automated actions */
if (current_menu == url_suggest_menu) {
g = ro_gui_toolbar_lookup(current_menu_window);
if (g) {
url = url_suggest_menu->entries[selection->items[0]].
data.indirected_text.text;
gui_window_set_url(g, url);
browser_window_go(g->bw, url, 0, true);
}
} else if (current_menu == gui_form_select_menu) {
g = ro_gui_window_lookup(current_menu_window);
assert(g);
if (selection->items[0] >= 0) {
form_select_process_selection(g->bw->current_content,
gui_form_select_control,
selection->items[0]);
}
}
/* allow automatic menus to have their data updated */
// ro_gui_wimp_event_menu_selection(current_menu_window,
// current_menu_icon, current_menu, selection);
/* Menus not handled by ro_gui_wimp_event_menu_selection()
* will need to be re-prepared before an adjust reopening.
*/
needs_prepare = true;
}
/* re-open the menu for Adjust clicks */
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);
ro_gui_menu_closed(true);
return;
}
if (pointer.buttons != wimp_CLICK_ADJUST) {
ro_gui_menu_closed(true);
return;
}
/* re-prepare all the visible entries */
if (needs_prepare) {
i = 0;
menu = current_menu;
do {
j = 0;
do {
action = ro_gui_menu_find_action(current_menu,
&menu->entries[j]);
if (action != NO_ACTION)
ro_gui_menu_prepare_action(current_menu_window,
action, false);
} while (!(menu->entries[j++].menu_flags & wimp_MENU_LAST));
j = selection->items[i++];
if (j != -1) {
menu = menu->entries[j].sub_menu;
if ((!menu) || (menu == wimp_NO_SUB_MENU))
break;
}
} while (j != -1);
}
if (current_menu == gui_form_select_menu) {
assert(g); /* Keep scan-build happy */
gui_create_form_select_menu(g->bw, gui_form_select_control);
} else
ro_gui_menu_create(current_menu, 0, 0, current_menu_window, true);
current_menu_icon = previous_menu_icon;
}
/**
* Handle Message_MenuWarning.
*/
void ro_gui_menu_warning(wimp_message_menu_warning *warning)
{
int i;
menu_action action;
wimp_menu_entry *menu_entry;
wimp_menu *sub_menu;
os_error *error;
assert(current_menu);
assert(current_menu_window);
/* get the sub-menu of the warning */
if (warning->selection.items[0] == -1)
return;
menu_entry = &current_menu->entries[warning->selection.items[0]];
for (i = 1; warning->selection.items[i] != -1; i++)
menu_entry = &menu_entry->sub_menu->
entries[warning->selection.items[i]];
action = ro_gui_menu_find_action(current_menu, menu_entry);
/* We only process the menu in the old way if the wimp_event module
* hasn't processed it for us.
*/
if (!ro_gui_wimp_event_submenu_warning(current_menu_window,
current_menu_icon, current_menu, &(warning->selection),
action)) {
if (IS_MENU(menu_entry->sub_menu)) {
ro_gui_wimp_event_register_submenu((wimp_w)0);
sub_menu = menu_entry->sub_menu;
i = 0;
do {
action = ro_gui_menu_find_action(current_menu,
&sub_menu->entries[i]);
if (action != NO_ACTION)
ro_gui_menu_prepare_action(current_menu_window,
action, false);
} while (!(sub_menu->entries[i++].menu_flags &
wimp_MENU_LAST));
} else {
ro_gui_wimp_event_register_submenu((wimp_w)menu_entry->sub_menu);
action = ro_gui_menu_find_action(current_menu, menu_entry);
if (action != NO_ACTION)
ro_gui_menu_prepare_action(current_menu_window,
action, true);
}
}
/* If this is a dialogue box, remove the close and back icons. */
if (!(IS_MENU(menu_entry->sub_menu)))
ro_gui_wimp_update_window_furniture((wimp_w)menu_entry->sub_menu,
wimp_WINDOW_CLOSE_ICON | wimp_WINDOW_BACK_ICON, 0);
/* open the sub-menu */
error = xwimp_create_sub_menu(menu_entry->sub_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);
}
}
/**
* Update navigate menu status and toolbar icons.
*
* /param gui the gui_window to update
*/
void ro_gui_prepare_navigate(struct gui_window *gui)
{
ro_gui_menu_prepare_action(gui->window, HOTLIST_SHOW, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_NAVIGATE_STOP, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_NAVIGATE_RELOAD_ALL,
false);
ro_gui_menu_prepare_action(gui->window, BROWSER_NAVIGATE_BACK, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_NAVIGATE_FORWARD,
false);
ro_gui_menu_prepare_action(gui->window, BROWSER_NAVIGATE_UP, false);
ro_gui_menu_prepare_action(gui->window, HOTLIST_SHOW, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_SAVE, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_PRINT, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_SCALE_VIEW, false);
ro_gui_menu_prepare_action(gui->window, BROWSER_FIND_TEXT, false);
if (gui->toolbar) {
ro_gui_set_icon_shaded_state(gui->toolbar->toolbar_handle,
ICON_TOOLBAR_SUGGEST,
!ro_gui_url_suggest_prepare_menu());
}
}
/**
* Prepare the page info window for use
*
* \param g the gui_window to set the display icons for
*/
void ro_gui_menu_prepare_pageinfo(struct gui_window *g)
{
hlcache_handle *h = g->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, *url, *mime;
const char *enc = "-";
assert(h);
title = content_get_title(h);
if (title == NULL)
title = "-";
url = content_get_url(h);
if (url == NULL)
url = "-";
mime = content_get_mime_type(h);
if (mime == NULL)
mime = "-";
sprintf(icon_buf, "file_%x", ro_content_filetype(h));
if (!ro_gui_wimp_sprite_exists(icon_buf))
sprintf(icon_buf, "file_xxx");
if (content_get_type(h) == CONTENT_HTML) {
if (html_get_encoding(h)) {
enc_token[8] = '0' + html_get_encoding_source(h);
snprintf(enc_buf, sizeof enc_buf, "%s (%s)",
html_get_encoding(h),
messages_get(enc_token));
enc = enc_buf;
} else {
enc = messages_get("EncodingUnk");
}
}
ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_ICON, icon, true);
ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_TITLE, title, true);
ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_URL, url, true);
ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_ENC, enc, true);
ro_gui_set_icon_string(dialog_pageinfo, ICON_PAGEINFO_TYPE, mime, true);
}
/**
* Prepare the object info window for use
*
* \param object the object for which information is to be displayed
* \param href corresponding href, if any
*/
void ro_gui_menu_prepare_objectinfo(hlcache_handle *object, const char *href)
{
char icon_buf[20] = "file_xxx";
const char *url, *mime;
const char *target = "-";
sprintf(icon_buf, "file_%.3x",
ro_content_filetype(object));
if (!ro_gui_wimp_sprite_exists(icon_buf))
sprintf(icon_buf, "file_xxx");
url = content_get_url(object);
if (url == NULL)
url = "-";
mime = content_get_mime_type(object);
if (mime == NULL)
mime = "-";
if (href)
target = href;
ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_ICON, icon_buf, true);
ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_URL, url, true);
ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_TARGET, target, true);
ro_gui_set_icon_string(dialog_objinfo, ICON_OBJINFO_TYPE, mime, true);
}
/**
* 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, entries;
char *text_convert, *temp;
struct form_option *option;
wimp_pointer pointer;
os_error *error;
bool reopen = true;
utf8_convert_ret err;
assert(control);
for (entries = 0, option = control->data.select.items; option;
option = option->next)
entries++;
if (entries == 0) {
ro_gui_menu_closed(true);
return;
}
if ((gui_form_select_menu) && (control != gui_form_select_control)) {
for (i = 0; ; i++) {
free(gui_form_select_menu->entries[i].data.
indirected_text.text);
if (gui_form_select_menu->entries[i].menu_flags &
wimp_MENU_LAST)
break;
}
free(gui_form_select_menu->title_data.indirected_text.text);
free(gui_form_select_menu);
gui_form_select_menu = 0;
}
if (!gui_form_select_menu) {
reopen = false;
gui_form_select_menu = malloc(wimp_SIZEOF_MENU(entries));
if (!gui_form_select_menu) {
warn_user("NoMemory", 0);
ro_gui_menu_closed(true);
return;
}
err = utf8_to_local_encoding(messages_get("SelectMenu"), 0,
&text_convert);
if (err != UTF8_CONVERT_OK) {
/* badenc should never happen */
assert(err != UTF8_CONVERT_BADENC);
LOG(("utf8_to_local_encoding failed"));
warn_user("NoMemory", 0);
ro_gui_menu_closed(true);
return;
}
gui_form_select_menu->title_data.indirected_text.text =
text_convert;
ro_gui_menu_init_structure(gui_form_select_menu, entries);
}
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;
if (!reopen) {
/* 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.
*/
temp = cnv_space2nbsp(option->text);
if (!temp) {
LOG(("cnv_space2nbsp failed"));
warn_user("NoMemory", 0);
ro_gui_menu_closed(true);
return;
}
err = utf8_to_local_encoding(temp,
0, &text_convert);
if (err != UTF8_CONVERT_OK) {
/* A bad encoding should never happen,
* so assert this */
assert(err != UTF8_CONVERT_BADENC);
LOG(("utf8_to_enc failed"));
warn_user("NoMemory", 0);
ro_gui_menu_closed(true);
return;
}
free(temp);
gui_form_select_menu->entries[i].data.indirected_text.text =
text_convert;
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);
ro_gui_menu_closed(true);
return;
}
gui_form_select_control = control;
ro_gui_menu_create(gui_form_select_menu,
pointer.pos.x, pointer.pos.y, bw->window->window, true);
}
/**
* Creates a wimp_menu and adds it to the list to handle actions for.
*
* \param *menu The data to create the menu with
* \param *callbacks A callback table for the menu (NULL if to be
* handled in the 'old-fashined way' by menus.c).
* \return The menu created, or NULL on failure
*/
wimp_menu *ro_gui_menu_define_menu(const struct ns_menu *menu)
{
struct menu_definition *definition;
int entry;
definition = calloc(sizeof(struct menu_definition), 1);
if (!definition) {
die("No memory to create menu definition.");
return NULL; /* For the benefit of scan-build */
}
/* link in the menu to our list */
definition->next = ro_gui_menu_definitions;
ro_gui_menu_definitions = definition;
/* count number of menu entries */
for (entry = 0; menu->entries[entry].text; entry++)
/* do nothing */;
/* create our definitions */
ro_gui_menu_define_menu_add(definition, menu, 0, NULL,
0, entry, NULL, 0);
/* and translate menu into current encoding */
if (!ro_gui_menu_translate(definition))
die("No memory to translate menu.");
return definition->menu;
}
/**
* Create a wimp menu tree from ns_menu data.
* This function does *not* deal with the menu textual content - it simply
* creates and populates the appropriate structures. Textual content is
* generated by ro_gui_menu_translate_menu()
*
* \param definition Top level menu definition
* \param menu Menu declaration data
* \param depth Depth of menu we're currently building
* \param parent_entry Entry in parent menu, or NULL if root menu
* \param first First index in declaration data that is used by this menu
* \param last Last index in declaration data that is used by this menu
* \param prefix Prefix pf menu declaration string already seen
* \param prefix_length Length of prefix
*/
void ro_gui_menu_define_menu_add(struct menu_definition *definition,
const struct ns_menu *menu, int depth,
wimp_menu_entry *parent_entry, int first, int last,
const char *prefix, int prefix_length)
{
int entry, id, cur_depth;
int entries = 0;
int matches[last - first + 1];
const char *match;
const char *text, *menu_text;
wimp_menu *new_menu;
struct menu_definition_entry *definition_entry;
/* step 1: store the matches for depth and subset string */
for (entry = first; entry < last; entry++) {
cur_depth = 0;
match = menu->entries[entry].text;
/* skip specials at start of string */
while (!isalnum(*match))
match++;
/* attempt prefix match */
if ((prefix) && (strncmp(match, prefix, prefix_length)))
continue;
/* Find depth of this entry */
while (*match)
if (*match++ == '.')
cur_depth++;
if (depth == cur_depth)
matches[entries++] = entry;
}
matches[entries] = last;
/* no entries, so exit */
if (entries == 0)
return;
/* step 2: build and link the menu. we must use realloc to stop
* our memory fragmenting so we can test for sub-menus easily */
new_menu = (wimp_menu *)malloc(wimp_SIZEOF_MENU(entries));
if (!new_menu)
die("No memory to create menu.");
if (parent_entry) {
/* Fix up sub menu pointer */
parent_entry->sub_menu = new_menu;
} else {
/* Root menu => fill in definition struct */
definition->title_key = menu->title;
definition->current_encoding = 0;
definition->menu = new_menu;
}
/* this is fixed up in ro_gui_menu_translate() */
new_menu->title_data.indirected_text.text = NULL;
/* fill in menu flags */
ro_gui_menu_init_structure(new_menu, entries);
/* and then create the entries */
for (entry = 0; entry < entries; entry++) {
/* add the entry */
id = matches[entry];
text = menu->entries[id].text;
/* fill in menu flags from specials at start of string */
new_menu->entries[entry].menu_flags = 0;
while (!isalnum(*text)) {
if (*text == '_')
new_menu->entries[entry].menu_flags |=
wimp_MENU_SEPARATE;
text++;
}
/* get messages key for menu entry */
menu_text = strrchr(text, '.');
if (!menu_text)
/* no '.' => top-level entry */
menu_text = text;
else
menu_text++; /* and move past the '.' */
/* fill in submenu data */
if (menu->entries[id].sub_window)
new_menu->entries[entry].sub_menu =
(wimp_menu *) (*menu->entries[id].sub_window);
/* this is fixed up in ro_gui_menu_translate() */
new_menu->entries[entry].data.indirected_text.text = NULL;
/* create definition entry */
definition_entry =
malloc(sizeof(struct menu_definition_entry));
if (!definition_entry)
die("Unable to create menu definition entry");
definition_entry->action = menu->entries[id].action;
definition_entry->menu_entry = &new_menu->entries[entry];
definition_entry->entry_key = menu_text;
definition_entry->next = definition->entries;
definition->entries = definition_entry;
/* recurse */
if (new_menu->entries[entry].sub_menu == wimp_NO_SUB_MENU) {
ro_gui_menu_define_menu_add(definition, menu,
depth + 1, &new_menu->entries[entry],
matches[entry], matches[entry + 1],
text, strlen(text));
}
/* give menu warnings */
if (new_menu->entries[entry].sub_menu != wimp_NO_SUB_MENU)
new_menu->entries[entry].menu_flags |=
wimp_MENU_GIVE_WARNING;
}
new_menu->entries[0].menu_flags |= wimp_MENU_TITLE_INDIRECTED;
new_menu->entries[entries - 1].menu_flags |= wimp_MENU_LAST;
}
/**
* Initialise the basic state of a menu structure so all entries are
* indirected text with no flags, no submenu.
*/
void ro_gui_menu_init_structure(wimp_menu *menu, int entries)
{
int i;
menu->title_fg = wimp_COLOUR_BLACK;
menu->title_bg = wimp_COLOUR_LIGHT_GREY;
menu->work_fg = wimp_COLOUR_BLACK;
menu->work_bg = wimp_COLOUR_WHITE;
menu->width = 200;
menu->height = wimp_MENU_ITEM_HEIGHT;
menu->gap = wimp_MENU_ITEM_GAP;
for (i = 0; i < entries; i++) {
menu->entries[i].menu_flags = 0;
menu->entries[i].sub_menu = wimp_NO_SUB_MENU;
menu->entries[i].icon_flags =
DEFAULT_FLAGS | wimp_ICON_INDIRECTED;
menu->entries[i].data.indirected_text.validation =
(char *)-1;
}
menu->entries[0].menu_flags |= wimp_MENU_TITLE_INDIRECTED;
menu->entries[i - 1].menu_flags |= wimp_MENU_LAST;
}
/**
* Finds the menu_definition corresponding to a wimp_menu.
*
* \param menu the menu to find the definition for
* \return the associated definition, or NULL if one could not be found
*/
struct menu_definition *ro_gui_menu_find_menu(wimp_menu *menu)
{
struct menu_definition *definition;
if (!menu)
return NULL;
for (definition = ro_gui_menu_definitions; definition;
definition = definition->next)
if (definition->menu == menu)
return definition;
return NULL;
}
/**
* Finds the key associated with a menu entry translation.
*
* \param menu the menu to search
* \param translated the translated text
* \return the original message key, or NULL if one could not be found
*/
const char *ro_gui_menu_find_menu_entry_key(wimp_menu *menu,
const char *translated)
{
struct menu_definition_entry *entry;
struct menu_definition *definition = ro_gui_menu_find_menu(menu);
if (!definition)
return NULL;
for (entry = definition->entries; entry; entry = entry->next)
if (!strcmp(entry->menu_entry->data.indirected_text.text, translated))
return entry->entry_key;
return NULL;
}
/**
* Finds the menu_definition_entry corresponding to an action for a wimp_menu.
*
* \param menu the menu to search for an action within
* \param action the action to find
* \return the associated menu entry, or NULL if one could not be found
*/
struct menu_definition_entry *ro_gui_menu_find_entry(wimp_menu *menu,
menu_action action)
{
struct menu_definition_entry *entry;
struct menu_definition *definition = ro_gui_menu_find_menu(menu);
if (!definition)
return NULL;
for (entry = definition->entries; entry; entry = entry->next)
if (entry->action == action)
return entry;
return NULL;
}
/**
* Finds the action corresponding to a wimp_menu_entry for a wimp_menu.
*
* \param menu the menu to search for an action within
* \param menu_entry the menu_entry to find
* \return the associated action, or 0 if one could not be found
*/
menu_action ro_gui_menu_find_action(wimp_menu *menu, wimp_menu_entry *menu_entry)
{
struct menu_definition_entry *entry;
struct menu_definition *definition = ro_gui_menu_find_menu(menu);
if (!definition)
return NO_ACTION;
for (entry = definition->entries; entry; entry = entry->next) {
if (entry->menu_entry == menu_entry)
return entry->action;
}
return NO_ACTION;
}
/**
* Sets an action within a menu as having a specific ticked status.
*
* \param menu the menu containing the action
* \param action the action to tick/untick
* \param ticked whether to set the item as ticked
*/
void ro_gui_menu_set_entry_shaded(wimp_menu *menu, menu_action action,
bool shaded)
{
struct menu_definition_entry *entry;
struct menu_definition *definition = ro_gui_menu_find_menu(menu);
if (!definition)
return;
/* we can't use find_entry as multiple actions may appear in one menu */
for (entry = definition->entries; entry; entry = entry->next)
if (entry->action == action) {
if (shaded)
entry->menu_entry->icon_flags |= wimp_ICON_SHADED;
else
entry->menu_entry->icon_flags &= ~wimp_ICON_SHADED;
}
}
/**
* Sets an action within a menu as having a specific ticked status.
*
* \param menu the menu containing the action
* \param action the action to tick/untick
* \param ticked whether to set the item as ticked
*/
void ro_gui_menu_set_entry_ticked(wimp_menu *menu, menu_action action,
bool ticked)
{
struct menu_definition_entry *entry =
ro_gui_menu_find_entry(menu, action);
if (entry) {
if (ticked)
entry->menu_entry->menu_flags |= wimp_MENU_TICKED;
else
entry->menu_entry->menu_flags &= ~wimp_MENU_TICKED;
}
}
/**
* Handles an action.
*
* \param owner the window to handle the action for
* \param action the action to handle
* \param windows_at_pointer whether to open any windows at the pointer location
*/
bool ro_gui_menu_handle_action(wimp_w owner, menu_action action,
bool windows_at_pointer)
{
wimp_window_state state;
struct gui_window *g = NULL;
struct browser_window *bw = NULL;
hlcache_handle *h = NULL;
struct toolbar *t = NULL;
os_error *error;
char url[80];
bool is_cookies, is_hotlist, is_global_history;
ro_gui_menu_get_window_details(owner, &g, &bw, &h, &t,
&is_cookies, &is_hotlist, &is_global_history);
switch (action) {
/* help actions */
case HELP_OPEN_CONTENTS:
ro_gui_open_help_page("documentation/index");
return true;
case HELP_OPEN_GUIDE:
ro_gui_open_help_page("documentation/guide");
return true;
case HELP_OPEN_INFORMATION:
ro_gui_open_help_page("documentation/info");
return true;
case HELP_OPEN_ABOUT:
ro_gui_open_help_page("about/index");
return true;
case HELP_LAUNCH_INTERACTIVE:
if (!ro_gui_interactive_help_available()) {
ro_gui_interactive_help_start();
option_interactive_help = true;
} else {
option_interactive_help = !option_interactive_help;
}
return true;
/* history actions */
case HISTORY_SHOW_LOCAL:
if ((!bw) || (!bw->history))
return false;
ro_gui_history_open(bw, bw->history,
windows_at_pointer);
return true;
case HISTORY_SHOW_GLOBAL:
ro_gui_global_history_open();
return true;
/* hotlist actions */
case HOTLIST_ADD_URL:
if (h == NULL || content_get_url(h) == NULL)
return false;
hotlist_add_page(content_get_url(h));
return true;
case HOTLIST_SHOW:
ro_gui_hotlist_open();
return true;
/* cookies actions */
case COOKIES_SHOW:
ro_gui_cookies_open();
return true;
case COOKIES_DELETE:
cookies_delete_all();
return true;
/* page actions */
case BROWSER_PAGE_INFO:
if (!h)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(g->window,
dialog_pageinfo, windows_at_pointer);
return true;
case BROWSER_PRINT:
if (!h)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(g->window,
dialog_print, windows_at_pointer);
return true;
case BROWSER_NEW_WINDOW:
if (!h)
return false;
browser_window_create(content_get_url(h), bw, 0, false,
false);
return true;
case BROWSER_VIEW_SOURCE:
if (!h)
return false;
ro_gui_view_source(h);
return true;
/* object actions */
case BROWSER_OBJECT_INFO:
if (!current_menu_object)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(g->window,
dialog_objinfo, windows_at_pointer);
return true;
case BROWSER_OBJECT_RELOAD:
if (!current_menu_object)
return false;
content_invalidate_reuse_data(current_menu_object);
browser_window_reload(bw, false);
return true;
/* link actions */
case BROWSER_LINK_SAVE_URI:
case BROWSER_LINK_SAVE_URL:
case BROWSER_LINK_SAVE_TEXT:
if (!current_menu_url)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(owner, dialog_saveas,
windows_at_pointer);
break;
case BROWSER_LINK_DOWNLOAD:
if (!current_menu_url)
return false;
browser_window_download(bw, current_menu_url,
content_get_url(h));
break;
case BROWSER_LINK_NEW_WINDOW:
if (!current_menu_url)
return false;
browser_window_create(current_menu_url, bw,
content_get_url(h), true, false);
break;
/* save actions */
case BROWSER_OBJECT_SAVE:
case BROWSER_OBJECT_EXPORT_SPRITE:
case BROWSER_OBJECT_EXPORT_DRAW:
h = current_menu_object;
/* Fall through */
case BROWSER_SAVE:
case BROWSER_SAVE_COMPLETE:
case BROWSER_EXPORT_DRAW:
case BROWSER_EXPORT_PDF:
case BROWSER_EXPORT_TEXT:
case BROWSER_SAVE_URL_URI:
case BROWSER_SAVE_URL_URL:
case BROWSER_SAVE_URL_TEXT:
if (!h)
return false;
/* Fall through */
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(owner, dialog_saveas,
windows_at_pointer);
return true;
/* selection actions */
case BROWSER_SELECTION_SAVE:
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(owner, dialog_saveas,
windows_at_pointer);
return true;
case BROWSER_SELECTION_COPY:
browser_window_key_press(bw, KEY_COPY_SELECTION);
break;
case BROWSER_SELECTION_CUT:
browser_window_key_press(bw, KEY_CUT_SELECTION);
return true;
case BROWSER_SELECTION_PASTE:
browser_window_key_press(bw, KEY_PASTE);
return true;
case BROWSER_SELECTION_ALL:
browser_window_key_press(bw, KEY_SELECT_ALL);
break;
case BROWSER_SELECTION_CLEAR:
browser_window_key_press(bw, KEY_CLEAR_SELECTION);
break;
/* navigation actions */
case BROWSER_NAVIGATE_HOME:
if (!bw)
return false;
if ((option_homepage_url) &&
(option_homepage_url[0])) {
browser_window_go(g->bw,
option_homepage_url, 0, true);
} else {
snprintf(url, sizeof url,
"file:///<NetSurf$Dir>/Docs/welcome/index_%s",
option_language);
browser_window_go(g->bw, url, 0, true);
}
return true;
case BROWSER_NAVIGATE_BACK:
if ((!bw) || (!bw->history))
return false;
history_back(bw, bw->history);
return true;
case BROWSER_NAVIGATE_FORWARD:
if ((!bw) || (!bw->history))
return false;
history_forward(bw, bw->history);
return true;
case BROWSER_NAVIGATE_UP:
if ((!bw) || (!h))
return false;
return ro_gui_window_navigate_up(bw->window,
content_get_url(h));
case BROWSER_NAVIGATE_RELOAD:
case BROWSER_NAVIGATE_RELOAD_ALL:
if (!bw)
return false;
browser_window_reload(bw,
(action == BROWSER_NAVIGATE_RELOAD_ALL));
return true;
case BROWSER_NAVIGATE_STOP:
if (!bw)
return false;
browser_window_stop(bw);
return true;
case BROWSER_NAVIGATE_URL:
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(NULL, dialog_openurl,
windows_at_pointer);
return true;
/* browser window/display actions */
case BROWSER_SCALE_VIEW:
if (!h)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(g->window, dialog_zoom,
windows_at_pointer);
return true;
case BROWSER_FIND_TEXT:
if (!h || (content_get_type(h) != CONTENT_TEXTPLAIN &&
content_get_type(h) != CONTENT_HTML))
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistent(g->window,
dialog_search, windows_at_pointer);
return true;
case BROWSER_IMAGES_BACKGROUND:
if (!g)
return false;
g->option.background_images =
!g->option.background_images;
gui_window_redraw_window(g);
return true;
case BROWSER_BUFFER_ANIMS:
if (!g)
return false;
g->option.buffer_animations =
!g->option.buffer_animations;
break;
case BROWSER_BUFFER_ALL:
if (!g)
return false;
g->option.buffer_everything =
!g->option.buffer_everything;
break;
case BROWSER_SAVE_VIEW:
if (!bw)
return false;
ro_gui_window_default_options(bw);
ro_gui_save_options();
return true;
case BROWSER_WINDOW_DEFAULT:
if (!g)
return false;
ro_gui_screen_size(&option_window_screen_width,
&option_window_screen_height);
state.w = current_menu_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;
ro_gui_save_options();
return true;
case BROWSER_WINDOW_STAGGER:
option_window_stagger = !option_window_stagger;
ro_gui_save_options();
return true;
case BROWSER_WINDOW_COPY:
option_window_size_clone = !option_window_size_clone;
ro_gui_save_options();
return true;
case BROWSER_WINDOW_RESET:
option_window_screen_width = 0;
option_window_screen_height = 0;
ro_gui_save_options();
return true;
/* toolbar actions */
case TOOLBAR_BUTTONS:
assert(t);
t->display_buttons = !t->display_buttons;
ro_gui_theme_refresh_toolbar(t);
return true;
case TOOLBAR_ADDRESS_BAR:
assert(t);
t->display_url = !t->display_url;
ro_gui_theme_refresh_toolbar(t);
if (t->display_url)
ro_gui_set_caret_first(t->toolbar_handle);
return true;
case TOOLBAR_THROBBER:
assert(t);
t->display_throbber = !t->display_throbber;
ro_gui_theme_refresh_toolbar(t);
return true;
case TOOLBAR_EDIT:
assert(t);
ro_gui_theme_toggle_edit(t);
return true;
/* misc actions */
case APPLICATION_QUIT:
if (ro_gui_prequit()) {
LOG(("QUIT in response to user request"));
netsurf_quit = true;
}
return true;
case CHOICES_SHOW:
ro_gui_configure_show();
return true;
/* unknown action */
default:
return false;
}
return false;
}
/**
* Prepares an action for use.
*
* \param owner the window to prepare the action for
* \param action the action to prepare
* \param windows whether to update sub-windows
*/
void ro_gui_menu_prepare_action(wimp_w owner, menu_action action,
bool windows)
{
struct gui_window *g;
struct browser_window *bw;
hlcache_handle *h;
struct toolbar *t;
bool result = false;
int checksum = 0;
os_error *error;
char *parent;
url_func_result res;
bool compare;
bool is_cookies, is_hotlist, is_global_history;
ro_gui_menu_get_window_details(owner, &g, &bw, &h, &t,
&is_cookies, &is_hotlist, &is_global_history);
if (current_menu_open)
checksum = ro_gui_menu_get_checksum();
if (!h) {
current_menu_object = NULL;
current_menu_url = NULL;
}
switch (action) {
/* help actions */
case HELP_LAUNCH_INTERACTIVE:
result = ro_gui_interactive_help_available()
&& option_interactive_help;
ro_gui_menu_set_entry_ticked(current_menu,
action, result);
ro_gui_save_options();
break;
/* history actions */
case HISTORY_SHOW_LOCAL:
ro_gui_menu_set_entry_shaded(current_menu, action,
(!bw || (!bw->history) ||
!(h || history_back_available(bw->history) ||
history_forward_available(bw->history))));
break;
/* hotlist actions */
case HOTLIST_ADD_URL:
ro_gui_menu_set_entry_shaded(current_menu, action,
h == NULL);
break;
/* page actions */
case BROWSER_PAGE:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h ||
(content_get_type(h) != CONTENT_HTML &&
content_get_type(h) != CONTENT_TEXTPLAIN));
break;
case BROWSER_PAGE_INFO:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((windows) && (h))
ro_gui_menu_prepare_pageinfo(g);
break;
case BROWSER_PRINT:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((t) && (t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_PRINT, !h);
if ((windows) && (h))
ro_gui_print_prepare(g);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_PRINT, !h);
break;
case BROWSER_NEW_WINDOW:
case BROWSER_VIEW_SOURCE:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
break;
/* object actions */
case BROWSER_OBJECT:
ro_gui_menu_set_entry_shaded(current_menu, action,
!current_menu_object &&
!current_menu_url);
break;
case BROWSER_OBJECT_LINK:
ro_gui_menu_set_entry_shaded(current_menu, action,
!current_menu_url);
break;
case BROWSER_OBJECT_INFO:
if (windows && current_menu_object)
ro_gui_menu_prepare_objectinfo(
current_menu_object,
current_menu_url);
/* Fall through */
case BROWSER_OBJECT_RELOAD:
case BROWSER_OBJECT_OBJECT:
ro_gui_menu_set_entry_shaded(current_menu, action,
!current_menu_object);
break;
case BROWSER_OBJECT_PRINT:
/* not yet implemented */
ro_gui_menu_set_entry_shaded(current_menu, action,
true);
break;
/* save actions (browser, hotlist, history) */
case BROWSER_OBJECT_SAVE:
ro_gui_menu_set_entry_shaded(current_menu,
action, !current_menu_object);
if (windows && current_menu_object)
ro_gui_save_prepare(GUI_SAVE_OBJECT_ORIG,
current_menu_object,
NULL, NULL, NULL);
break;
case BROWSER_OBJECT_EXPORT:
case BROWSER_OBJECT_EXPORT_SPRITE:
case BROWSER_OBJECT_EXPORT_DRAW: {
bool exp_sprite = false;
bool exp_draw = false;
if (current_menu_object)
h = current_menu_object;
if (h) {
switch (content_get_type(h)) {
/* \todo - this classification should prob be done in content_() */
/* bitmap types (Sprite export possible) */
#ifdef WITH_JPEG
case CONTENT_JPEG:
#endif
#ifdef WITH_MNG
case CONTENT_JNG:
case CONTENT_MNG:
#endif
#ifdef WITH_GIF
case CONTENT_GIF:
#endif
#ifdef WITH_BMP
case CONTENT_BMP:
case CONTENT_ICO:
#endif
#if defined(WITH_MNG) || defined(WITH_PNG)
case CONTENT_PNG:
#endif
#ifdef WITH_SPRITE
case CONTENT_SPRITE:
#endif
exp_sprite = true;
break;
/* vector types (Draw export possible) */
#if defined(WITH_NS_SVG) || defined(WITH_RSVG)
case CONTENT_SVG:
#endif
#ifdef WITH_DRAW
case CONTENT_DRAW:
#endif
exp_draw = true;
break;
default: break;
}
}
switch (action) {
case BROWSER_OBJECT_EXPORT_SPRITE:
if (!exp_sprite)
h = NULL;
break;
case BROWSER_OBJECT_EXPORT_DRAW:
if (!exp_draw)
h = NULL;
break;
default:
if (!exp_sprite && !exp_draw)
h = NULL;
break;
}
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_OBJECT_NATIVE, h, NULL, NULL, NULL);
}
break;
case BROWSER_LINK_SAVE_URI:
case BROWSER_LINK_SAVE_URL:
case BROWSER_LINK_SAVE_TEXT:
ro_gui_menu_set_entry_shaded(current_menu,
action, !current_menu_url);
if (windows && current_menu_url) {
gui_save_type save_type;
switch (action) {
case BROWSER_LINK_SAVE_URI:
save_type = GUI_SAVE_LINK_URI;
break;
case BROWSER_LINK_SAVE_URL:
save_type = GUI_SAVE_LINK_URL;
break;
default:
save_type = GUI_SAVE_LINK_TEXT;
break;
}
ro_gui_save_prepare(save_type, NULL, NULL,
current_menu_url, NULL);
}
break;
case BROWSER_SELECTION:
/* make menu available if there's anything that /could/
* be selected */
ro_gui_menu_set_entry_shaded(current_menu, action,
!h || (content_get_type(h) != CONTENT_HTML &&
content_get_type(h) != CONTENT_TEXTPLAIN));
break;
case BROWSER_SELECTION_SAVE:
if (h && (!bw->sel || !selection_defined(bw->sel)))
h = NULL;
ro_gui_menu_set_entry_shaded(current_menu, action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_TEXT_SELECTION, NULL, bw->sel, NULL, NULL);
break;
case BROWSER_SELECTION_COPY:
ro_gui_menu_set_entry_shaded(current_menu, action,
!(h && bw->sel && selection_defined(bw->sel)));
break;
case BROWSER_SELECTION_CUT:
ro_gui_menu_set_entry_shaded(current_menu, action,
!(h && bw->sel && selection_defined(bw->sel)
&& !selection_read_only(bw->sel)));
break;
case BROWSER_SELECTION_PASTE:
ro_gui_menu_set_entry_shaded(current_menu, action,
!(h && bw->paste_callback));
break;
case BROWSER_SAVE:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_SOURCE, h, NULL, NULL, NULL);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_SAVE, !h);
break;
case BROWSER_SAVE_COMPLETE:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_COMPLETE, h, NULL, NULL, NULL);
break;
case BROWSER_EXPORT_DRAW:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_DRAW, h, NULL, NULL, NULL);
break;
case BROWSER_EXPORT_PDF:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_PDF, h, NULL, NULL, NULL);
break;
case BROWSER_EXPORT_TEXT:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_TEXT, h, NULL, NULL, NULL);
break;
case BROWSER_OBJECT_SAVE_URL_URI:
if (h && content_get_type(h) == CONTENT_HTML)
h = current_menu_object;
/* Fall through */
case BROWSER_SAVE_URL_URI:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_LINK_URI, NULL,
NULL,
content_get_url(h),
content_get_title(h));
break;
case BROWSER_OBJECT_SAVE_URL_URL:
if (h && content_get_type(h) == CONTENT_HTML)
h = current_menu_object;
/* Fall through */
case BROWSER_SAVE_URL_URL:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_LINK_URL, NULL,
NULL,
content_get_url(h),
content_get_title(h));
break;
case BROWSER_OBJECT_SAVE_URL_TEXT:
h = current_menu_object;
/* Fall through */
case BROWSER_SAVE_URL_TEXT:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_save_prepare(GUI_SAVE_LINK_TEXT, NULL,
NULL,
content_get_url(h),
content_get_title(h));
break;
/* navigation actions */
case BROWSER_NAVIGATE_BACK:
result = browser_window_back_available(bw);
ro_gui_menu_set_entry_shaded(current_menu,
action, !result);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_BACK, !result);
break;
case BROWSER_NAVIGATE_FORWARD:
result = browser_window_forward_available(bw);
ro_gui_menu_set_entry_shaded(current_menu,
action, !result);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_FORWARD, !result);
break;
case BROWSER_NAVIGATE_UP:
result = (bw && h);
if (result) {
res = url_parent(content_get_url(h), &parent);
if (res == URL_FUNC_OK) {
res = url_compare(content_get_url(h),
parent, false,
&compare);
if (res == URL_FUNC_OK)
result = !compare;
free(parent);
} else {
result = false;
}
}
ro_gui_menu_set_entry_shaded(current_menu,
action, !result);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_UP, !result);
break;
case BROWSER_NAVIGATE_RELOAD:
case BROWSER_NAVIGATE_RELOAD_ALL:
result = browser_window_reload_available(bw);
ro_gui_menu_set_entry_shaded(current_menu,
action, !result);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_RELOAD, !result);
break;
case BROWSER_NAVIGATE_STOP:
result = browser_window_stop_available(bw);
ro_gui_menu_set_entry_shaded(current_menu,
action, !result);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_STOP, !result);
break;
case BROWSER_NAVIGATE_URL:
if (windows)
ro_gui_dialog_prepare_open_url();
break;
/* display actions */
case BROWSER_SCALE_VIEW:
ro_gui_menu_set_entry_shaded(current_menu,
action, !h);
if ((h) && (windows))
ro_gui_dialog_prepare_zoom(g);
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_SCALE, !h);
break;
case BROWSER_FIND_TEXT:
result = !h || (content_get_type(h) != CONTENT_HTML &&
content_get_type(h) != CONTENT_TEXTPLAIN);
ro_gui_menu_set_entry_shaded(current_menu,
action, result);
if ((!result) && (windows)) {
ro_gui_search_prepare(g->bw);
}
if ((t) && (!t->editor) &&
(t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(
t->toolbar_handle,
ICON_TOOLBAR_SEARCH, result);
break;
case BROWSER_IMAGES_FOREGROUND:
ro_gui_menu_set_entry_shaded(current_menu,
action, true);
ro_gui_menu_set_entry_ticked(current_menu,
action, true);
break;
case BROWSER_IMAGES_BACKGROUND:
if (g)
ro_gui_menu_set_entry_ticked(current_menu,
action, g->option.background_images);
break;
case BROWSER_BUFFER_ANIMS:
if (g) {
ro_gui_menu_set_entry_shaded(current_menu,
action, g->option.buffer_everything);
ro_gui_menu_set_entry_ticked(current_menu,
action,
g->option.buffer_animations ||
g->option.buffer_everything);
}
break;
case BROWSER_BUFFER_ALL:
if (g)
ro_gui_menu_set_entry_ticked(current_menu,
action, g->option.buffer_everything);
break;
case BROWSER_WINDOW_STAGGER:
ro_gui_menu_set_entry_shaded(current_menu, action,
option_window_screen_width == 0);
ro_gui_menu_set_entry_ticked(current_menu, action,
((option_window_screen_width == 0) ||
option_window_stagger));
break;
case BROWSER_WINDOW_COPY:
ro_gui_menu_set_entry_ticked(current_menu, action,
option_window_size_clone);
break;
case BROWSER_WINDOW_RESET:
ro_gui_menu_set_entry_shaded(current_menu, action,
option_window_screen_width == 0);
break;
/* tree actions */
case TREE_SELECTION:
break;
/* toolbar actions */
case TOOLBAR_BUTTONS:
ro_gui_menu_set_entry_shaded(current_menu,
action, (!t || (t->editor)));
ro_gui_menu_set_entry_ticked(current_menu,
action, (t &&
((t->display_buttons) || (t->editor))));
break;
case TOOLBAR_ADDRESS_BAR:
ro_gui_menu_set_entry_shaded(current_menu,
action, !t);
ro_gui_menu_set_entry_ticked(current_menu, action,
(t && t->display_url));
break;
case TOOLBAR_THROBBER:
ro_gui_menu_set_entry_shaded(current_menu,
action, !t);
ro_gui_menu_set_entry_ticked(current_menu, action,
(t && t->display_throbber));
break;
case TOOLBAR_EDIT:
ro_gui_menu_set_entry_shaded(current_menu,
action, !t);
ro_gui_menu_set_entry_ticked(current_menu, action,
(t && t->editor));
break;
/* unknown action */
default:
return;
}
/* update open menus */
if ((current_menu_open) &&
(checksum != ro_gui_menu_get_checksum())) {
error = xwimp_create_menu(current_menu, 0, 0);
if (error) {
LOG(("xwimp_create_menu: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
}
}
}
/**
* Gets various details relating to a window
*
* \param w the window to complete information for
*/
void ro_gui_menu_get_window_details(wimp_w w, struct gui_window **g,
struct browser_window **bw, hlcache_handle **h,
struct toolbar **toolbar,
bool *is_cookies, bool *is_hotlist, bool *is_global_history)
{
*is_cookies = false;
*is_hotlist = false;
*is_global_history = false;
*g = ro_gui_window_lookup(w);
if (*g) {
*bw = (*g)->bw;
*toolbar = (*g)->toolbar;
if (*bw)
*h = (*bw)->current_content;
} else {
*bw = NULL;
*h = NULL;
if (ro_gui_hotlist_check_window(w)) {
*is_hotlist = true;
// *toolbar = treeview_window->toolbar;
} else if (ro_gui_global_history_check_window(w)) {
*is_global_history = true;
// *toolbar = treeview_window->toolbar;
} else if (ro_gui_cookies_check_window(w)) {
*is_cookies = true;
// *toolbar = treeview_window->toolbar;
} else {
*toolbar = NULL;
}
}
}
/**
* Calculates a simple checksum for the current menu state
*/
int ro_gui_menu_get_checksum(void)
{
wimp_selection menu_tree;
int i = 0, j, checksum = 0;
os_error *error;
wimp_menu *menu;
if (!current_menu_open)
return 0;
error = xwimp_get_menu_state((wimp_menu_state_flags)0,
&menu_tree, 0, 0);
if (error) {
LOG(("xwimp_get_menu_state: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
return 0;
}
menu = current_menu;
do {
j = 0;
do {
if (menu->entries[j].icon_flags & wimp_ICON_SHADED)
checksum ^= (1 << (i + j * 2));
if (menu->entries[j].menu_flags & wimp_MENU_TICKED)
checksum ^= (2 << (i + j * 2));
} while (!(menu->entries[j++].menu_flags & wimp_MENU_LAST));
j = menu_tree.items[i++];
if (j != -1) {
menu = menu->entries[j].sub_menu;
if ((!menu) || (menu == wimp_NO_SUB_MENU) || (!IS_MENU(menu)))
break;
}
} while (j != -1);
return checksum;
}
/**
* Translate a menu's textual content into the system local encoding
*
* \param menu The menu to translate
* \return false if out of memory, true otherwise
*/
bool ro_gui_menu_translate(struct menu_definition *menu)
{
os_error *error;
int alphabet;
struct menu_definition_entry *entry;
char *translated;
utf8_convert_ret err;
/* read current alphabet */
error = xosbyte1(osbyte_ALPHABET_NUMBER, 127, 0, &alphabet);
if (error) {
LOG(("failed reading alphabet: 0x%x: %s",
error->errnum, error->errmess));
/* assume Latin1 */
alphabet = territory_ALPHABET_LATIN1;
}
if (menu->current_encoding == alphabet)
/* menu text is already in the correct encoding */
return true;
/* translate root menu title text */
free(menu->menu->title_data.indirected_text.text);
err = utf8_to_local_encoding(messages_get(menu->title_key),
0, &translated);
if (err != UTF8_CONVERT_OK) {
assert(err != UTF8_CONVERT_BADENC);
LOG(("utf8_to_enc failed"));
return false;
}
/* and fill in WIMP menu field */
menu->menu->title_data.indirected_text.text = translated;
/* now the menu entries */
for (entry = menu->entries; entry; entry = entry->next) {
wimp_menu *submenu = entry->menu_entry->sub_menu;
/* tranlate menu entry text */
free(entry->menu_entry->data.indirected_text.text);
err = utf8_to_local_encoding(messages_get(entry->entry_key),
0, &translated);
if (err != UTF8_CONVERT_OK) {
assert(err != UTF8_CONVERT_BADENC);
LOG(("utf8_to_enc failed"));
return false;
}
/* fill in WIMP menu fields */
entry->menu_entry->data.indirected_text.text = translated;
entry->menu_entry->data.indirected_text.validation =
(char *) -1;
entry->menu_entry->data.indirected_text.size =
strlen(translated);
/* child menu title - this is the same as the text of
* the parent menu entry, so just copy the pointer */
if (submenu != wimp_NO_SUB_MENU && IS_MENU(submenu)) {
submenu->title_data.indirected_text.text =
translated;
}
}
/* finally, set the current encoding of the menu */
menu->current_encoding = alphabet;
return true;
}
Reference in New Issue View Git Blame Copy Permalink