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
c17dc661ea
netsurf/riscos/menus.c
Richard Wilson 3e82c07a88 [project @ 2005-04-14 01:34:23 by rjw] 
Only close menus we own.

svn path=/import/netsurf/; revision=1629
2005-04-14 01:34:23 +00:00

2020 lines
60 KiB
C
Raw Blame History

/*
* 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/os.h"
#include "oslib/osgbpb.h"
#include "oslib/wimp.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/menus.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/utils.h"
struct ns_menu_entry {
const char *text; /**< menu text (from messages) */
menu_action action; /**< associated action */
wimp_w sub_window; /**< sub-window if any */
};
struct ns_menu {
const char *title;
struct ns_menu_entry entries[1];
};
#define NS_MENU(N) \
struct { \
const char *title; \
struct ns_menu_entry entries[N]; \
}
struct menu_definition_entry {
menu_action action; /**< menu action */
wimp_menu_entry *menu_entry; /**< corresponding menu entry */
struct menu_definition_entry *next; /**< next menu entry */
};
struct menu_definition {
wimp_menu *menu; /**< corresponding menu */
struct menu_definition_entry *entries; /**< menu entries */
struct menu_definition *next; /**< next menu */
};
static wimp_menu *ro_gui_menu_define_menu(struct ns_menu *menu);
static void ro_gui_menu_define_menu_add(struct menu_definition *definition,
struct ns_menu *menu, int depth, wimp_menu_entry *link,
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_set_entry_shaded(wimp_menu *menu, menu_action action,
bool shaded);
static void ro_gui_menu_set_entry_ticked(wimp_menu *menu, menu_action action,
bool ticked);
static void ro_gui_menu_get_window_details(wimp_w w, struct gui_window **g,
struct browser_window **bw, struct content **content,
struct toolbar **toolbar, struct tree **tree);
static int ro_gui_menu_get_checksum(void);
static bool ro_gui_menu_prepare_url_suggest(void);
static void ro_gui_menu_prepare_pageinfo(struct gui_window *g);
static void ro_gui_menu_prepare_objectinfo(struct box *box);
static void ro_gui_menu_refresh_toolbar(struct toolbar *toolbar);
/* 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 */
static bool current_menu_open = false;
/** Box for object under menu, or 0 if no object. */
static struct box *current_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;
/** Window that owns the current menu */
static wimp_w current_menu_window;
/** The height of the iconbar menu */
int iconbar_menu_height = 5 * 44;
/** The available menus */
wimp_menu *iconbar_menu, *browser_menu, *hotlist_menu, *global_history_menu,
*image_quality_menu, *browser_toolbar_menu,
*tree_toolbar_menu, *proxy_auth_menu, *languages_menu;
/** URL suggestion menu */
static wimp_MENU(GLOBAL_HISTORY_RECENT_URLS) url_suggest;
wimp_menu *url_suggest_menu = (wimp_menu *)&url_suggest;
/**
* Create menu structures.
*/
void ro_gui_menu_init(void) {
int context = 0, read_count, entries = 0;
os_error *error;
osgbpb_INFO(100) info;
char lang[8] = {0};
char *lang_name;
void *temp;
/* iconbar menu */
NS_MENU(9) iconbar_definition = {
"NetSurf", {
{ "Info", NO_ACTION, dialog_info },
{ "AppHelp", HELP_OPEN_CONTENTS, 0 },
{ "Open", NO_ACTION, 0 },
{ "Open.OpenURL", BROWSER_NAVIGATE_URL, dialog_openurl },
{ "Open.HotlistShow", HOTLIST_SHOW, 0 },
{ "Open.HistGlobal", HISTORY_SHOW_GLOBAL, 0 },
{ "Choices", CHOICES_SHOW, 0 },
{ "Quit", APPLICATION_QUIT, 0 },
{NULL, 0, 0}
}
};
iconbar_menu = ro_gui_menu_define_menu(
(struct ns_menu *)&iconbar_definition);
/* browser menu */
NS_MENU(66) 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 },
{ "Page.Export.Draw", BROWSER_EXPORT_DRAW, dialog_saveas },
{ "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.ViewSrc", BROWSER_VIEW_SOURCE, 0 },
{ "Object", BROWSER_OBJECT, 0 },
{ "Object.ObjInfo", BROWSER_OBJECT_INFO, dialog_objinfo },
{ "Object.ObjSave", BROWSER_OBJECT_SAVE, dialog_saveas },
{ "Object.Export", NO_ACTION, 0 },
{ "Object.Export.Sprite", BROWSER_OBJECT_EXPORT_SPRITE, dialog_saveas },
{ "Object.SaveURL_", NO_ACTION, 0 },
{ "Object.SaveURL.URI", BROWSER_OBJECT_SAVE_URL_URI, dialog_saveas },
{ "Object.SaveURL.URL", BROWSER_OBJECT_SAVE_URL_URL, dialog_saveas },
{ "Object.SaveURL.LinkText", BROWSER_OBJECT_SAVE_URL_TEXT, dialog_saveas },
{ "Object.ObjReload", BROWSER_OBJECT_RELOAD, 0 },
{ "Navigate", NO_ACTION, 0 },
{ "Navigate.Home", BROWSER_NAVIGATE_HOME, 0 },
{ "Navigate.Back", BROWSER_NAVIGATE_BACK, 0 },
{ "Navigate.Forward_", BROWSER_NAVIGATE_FORWARD, 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.ToolStatus_", TOOLBAR_STATUS_BAR, 0 },
{ "View.Toolbars.EditToolbar", TOOLBAR_EDIT, 0 },
{ "View.Render_", NO_ACTION, 0 },
{ "View.Render.RenderText_", BROWSER_BLEND_TEXT, 0 },
{ "View.Render.RenderAnims", BROWSER_BUFFER_ANIMS, 0 },
{ "View.Render.RenderAll", BROWSER_BUFFER_ALL, 0 },
{ "View.OptDefault", BROWSER_SAVE_VIEW, 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.FindText", BROWSER_FIND_TEXT, dialog_search },
{ "Utilities.Window", NO_ACTION, 0 },
{ "Utilities.Window.WindowSave", BROWSER_WINDOW_DEFAULT, 0 },
{ "Utilities.Window.WindowStagr", BROWSER_WINDOW_STAGGER, 0 },
{ "Utilities.Window.WindowSize_", BROWSER_WINDOW_COPY, 0 },
{ "Utilities.Window.WindowReset", BROWSER_WINDOW_RESET, 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(
(struct ns_menu *)&browser_definition);
/* hotlist menu */
NS_MENU(24) hotlist_definition = {
"Hotlist", {
{ "Hotlist", NO_ACTION, 0 },
{ "Hotlist.New", NO_ACTION, 0 },
{ "Hotlist.New.Folder", TREE_NEW_FOLDER, dialog_folder },
{ "Hotlist.New.Link", TREE_NEW_LINK, dialog_entry },
{ "Hotlist.Export_", HOTLIST_EXPORT, dialog_saveas },
{ "Hotlist.Expand", TREE_EXPAND_ALL, 0 },
{ "Hotlist.Expand.All", TREE_EXPAND_ALL, 0 },
{ "Hotlist.Expand.Folders", TREE_EXPAND_FOLDERS, 0 },
{ "Hotlist.Expand.Links", TREE_EXPAND_LINKS, 0 },
{ "Hotlist.Collapse", TREE_COLLAPSE_ALL, 0 },
{ "Hotlist.Collapse.All", TREE_COLLAPSE_ALL, 0 },
{ "Hotlist.Collapse.Folders", TREE_COLLAPSE_FOLDERS, 0 },
{ "Hotlist.Collapse.Links", TREE_COLLAPSE_LINKS, 0 },
{ "Hotlist.Toolbars", NO_ACTION, 0 },
{ "Hotlist.Toolbars.ToolButtons_", TOOLBAR_BUTTONS, 0 },
{ "Hotlist.Toolbars.EditToolbar", TOOLBAR_EDIT, 0 },
{ "Selection", TREE_SELECTION, 0 },
{ "Selection.Edit", TREE_SELECTION_EDIT, (wimp_w)1 },
{ "Selection.Launch", TREE_SELECTION_LAUNCH, 0 },
{ "Selection.Delete", TREE_SELECTION_DELETE, 0 },
{ "Selection.ResetUsage", TREE_SELECTION_RESET, 0 },
{ "SelectAll", TREE_SELECT_ALL, 0 },
{ "Clear", TREE_CLEAR_SELECTION, 0 },
{NULL, 0, 0}
}
};
hotlist_menu = ro_gui_menu_define_menu(
(struct ns_menu *)&hotlist_definition);
/* history menu */
NS_MENU(19) global_history_definition = {
"History", {
{ "History", NO_ACTION, 0 },
{ "History.Export_", HISTORY_EXPORT, dialog_saveas },
{ "History.Expand", TREE_EXPAND_ALL, 0 },
{ "History.Expand.All", TREE_EXPAND_ALL, 0 },
{ "History.Expand.Folders", TREE_EXPAND_FOLDERS, 0 },
{ "History.Expand.Links", TREE_EXPAND_LINKS, 0 },
{ "History.Collapse", TREE_COLLAPSE_ALL, 0 },
{ "History.Collapse.All", TREE_COLLAPSE_ALL, 0 },
{ "History.Collapse.Folders", TREE_COLLAPSE_FOLDERS, 0 },
{ "History.Collapse.Links", TREE_COLLAPSE_LINKS, 0 },
{ "History.Toolbars", NO_ACTION, 0 },
{ "History.Toolbars.ToolButtons_", TOOLBAR_BUTTONS, 0 },
{ "History.Toolbars.EditToolbar",TOOLBAR_EDIT, 0 },
{ "Selection", TREE_SELECTION, 0 },
{ "Selection.Launch", TREE_SELECTION_LAUNCH, 0 },
{ "Selection.Delete", TREE_SELECTION_DELETE, 0 },
{ "SelectAll", TREE_SELECT_ALL, 0 },
{ "Clear", TREE_CLEAR_SELECTION, 0 },
{NULL, 0, 0}
}
};
global_history_menu = ro_gui_menu_define_menu(
(struct ns_menu *)&global_history_definition);
/* image quality menu */
NS_MENU(5) 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(
(struct ns_menu *)&images_definition);
/* browser toolbar menu */
NS_MENU(7) browser_toolbar_definition = {
"Toolbar", {
{ "Toolbars", NO_ACTION, 0 },
{ "Toolbars.ToolButtons", TOOLBAR_BUTTONS, 0 },
{ "Toolbars.ToolAddress", TOOLBAR_ADDRESS_BAR, 0 },
{ "Toolbars.ToolThrob", TOOLBAR_THROBBER, 0 },
{ "Toolbars.ToolStatus", TOOLBAR_STATUS_BAR, 0 },
{ "EditToolbar", TOOLBAR_EDIT, 0 },
{NULL, 0, 0}
}
};
browser_toolbar_menu = ro_gui_menu_define_menu(
(struct ns_menu *)&browser_toolbar_definition);
/* tree toolbar menu */
NS_MENU(4) 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(
(struct ns_menu *)&tree_toolbar_definition);
/* proxy menu */
NS_MENU(4) proxy_auth_definition = {
"ProxyAuth", {
{ "ProxyNone", NO_ACTION, 0 },
{ "ProxyBasic", NO_ACTION, 0 },
{ "ProxyNTLM", NO_ACTION, 0 },
{NULL, 0, 0}
}
};
proxy_auth_menu = ro_gui_menu_define_menu(
(struct ns_menu *)&proxy_auth_definition);
/* special case menus */
url_suggest_menu->title_data.indirected_text.text =
messages_get("URLSuggest");
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 = 200;
url_suggest_menu->height = wimp_MENU_ITEM_HEIGHT;
url_suggest_menu->gap = wimp_MENU_ITEM_GAP;
/* language menu */
languages_menu = calloc(1, wimp_SIZEOF_MENU(1));
if (!languages_menu)
die("Insufficient memory for languages menu.");
languages_menu->title_data.indirected_text.text =
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 = 200;
languages_menu->height = wimp_MENU_ITEM_HEIGHT;
languages_menu->gap = wimp_MENU_ITEM_GAP;
while (context != -1) {
error = xosgbpb_dir_entries_info("<NetSurf$Dir>.Resources",
(osgbpb_info_list*)&info, 1, context,
sizeof(info), 0, &read_count, &context);
if (error)
die(error->errmess);
if ((read_count == 0) || (info.obj_type != fileswitch_IS_DIR))
continue;
snprintf(lang, sizeof lang, "lang_%2s", info.name);
/* we can't duplicate the string returned from our messages as
* it causes value->key lookups to fail */
lang_name = messages_get(lang);
if ((lang_name == lang) || (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;
}
/**
* Display a menu.
*/
void ro_gui_menu_create(wimp_menu *menu, int x, int y, wimp_w w) {
int doc_x, doc_y;
wimp_window_state state;
struct gui_window *g;
os_error *error;
int i;
menu_action action;
/* read the object under the pointer for a new gui_window menu */
if ((!current_menu) && (menu == browser_menu)) {
state.w = w;
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;
}
g = ro_gui_window_lookup(w);
assert(g);
doc_x = window_x_units(x, &state) / 2 / g->option.scale;
doc_y = -window_y_units(y, &state) / 2 / g->option.scale;
current_menu_object_box = NULL;
if (g->bw->current_content &&
g->bw->current_content->type == CONTENT_HTML)
current_menu_object_box = box_object_at_point(
g->bw->current_content, doc_x, doc_y);
}
/* store the menu characteristics */
current_menu = menu;
current_menu_window = w;
/* prepare the menu state */
if (menu == url_suggest_menu) {
if (!ro_gui_menu_prepare_url_suggest())
return;
} else {
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();
}
}
/**
* 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);
}
/**
* Clean up after a menu has been closed, or forcible close an open menu.
*/
void ro_gui_menu_closed(void) {
struct gui_window *g;
struct browser_window *bw;
struct content *c;
struct toolbar *t;
struct tree *tree;
os_error *error;
if (!current_menu)
return;
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, &c, &t, &tree);
current_menu = NULL;
current_menu_window = NULL;
current_menu_open = false;
if (tree)
ro_gui_tree_menu_closed(tree);
}
/**
* The content has changed, reset object references
*/
void ro_gui_menu_objects_moved(void) {
gui_form_select_control = NULL;
current_menu_object_box = NULL;
ro_gui_menu_prepare_action(0, BROWSER_OBJECT, false);
if (current_menu == gui_form_select_menu)
ro_gui_menu_closed();
}
/**
* Handle menu selection.
*/
void ro_gui_menu_selection(wimp_selection *selection) {
int i, j;
wimp_menu_entry *menu_entry;
menu_action action;
wimp_pointer pointer;
struct gui_window *g = NULL;
wimp_menu *menu;
os_error *error;
assert(current_menu);
assert(current_menu_window);
/* get the menu entry and associated action */
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);
/* 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);
assert(g);
browser_window_go(g->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 == proxy_auth_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]);
} else if ((current_menu == gui_form_select_menu) &&
(selection->items[0] >= 0)) {
g = ro_gui_window_lookup(current_menu_window);
assert(g);
browser_window_form_select(g->bw,
gui_form_select_control,
selection->items[0]);
}
/* 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();
return;
}
if (pointer.buttons != wimp_CLICK_ADJUST) {
ro_gui_menu_closed();
return;
}
/* re-prepare all the visible enties */
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;
} while (j != -1);
if (current_menu == gui_form_select_menu)
gui_create_form_select_menu(g->bw,
gui_form_select_control);
else
ro_gui_menu_create(current_menu, 0, 0, current_menu_window);
}
/**
* 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;
int menu_check;
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]];
/* 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 is within
* 256KB of its parent */
menu_check = abs((int)menu_entry->sub_menu - (int)menu_entry);
if (menu_check < 0x40000) {
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 {
action = ro_gui_menu_find_action(current_menu, menu_entry);
if (action != NO_ACTION)
ro_gui_menu_prepare_action(current_menu_window,
action, true);
/* remove the close icon */
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);
}
}
/**
* Refresh a toolbar after it has been updated
*
* \param toolbar the toolbar to update
*/
void ro_gui_menu_refresh_toolbar(struct toolbar *toolbar) {
int height;
assert(toolbar);
toolbar->reformat_buttons = true;
height = toolbar->height;
ro_gui_theme_process_toolbar(toolbar, -1);
if (toolbar->type == THEME_BROWSER_TOOLBAR) {
ro_gui_window_update_dimensions(
ro_gui_window_lookup(current_menu_window),
height - toolbar->height);
} else if (toolbar->type == THEME_HOTLIST_TOOLBAR) {
tree_resized(hotlist_tree);
xwimp_force_redraw((wimp_w)hotlist_tree->handle,
0,-16384, 16384, 16384);
} else if (toolbar->type == THEME_HISTORY_TOOLBAR) {
tree_resized(global_history_tree);
xwimp_force_redraw((wimp_w)global_history_tree->handle,
0,-16384, 16384, 16384);
}
}
/**
* 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;
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;
}
/**
* Update navigate menu status and toolbar icons.
*
* /param gui the gui_window to update
*/
void ro_gui_prepare_navigate(struct gui_window *gui) {
int suggestions;
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, 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) {
global_history_get_recent(&suggestions);
ro_gui_set_icon_shaded_state(gui->toolbar->toolbar_handle,
ICON_TOOLBAR_SUGGEST, (suggestions <= 0));
}
}
/**
* Prepare the image quality menu for use
*
* \param tinct_options the options to set the menu status for
*/
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;
}
/**
* 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) {
struct content *c = 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 = "-";
const char *url = "-";
const char *enc = "-";
const char *mime = "-";
assert(c);
if (c->title)
title = c->title;
if (c->url)
url = c->url;
if (c->mime_type)
mime = c->mime_type;
sprintf(icon_buf, "file_%x", ro_content_filetype(c));
if (!ro_gui_wimp_sprite_exists(icon_buf))
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);
}
/**
* Prepare the object info window for use
*
* \param box the box to set the display icons for
*/
void ro_gui_menu_prepare_objectinfo(struct box *box) {
char icon_buf[20] = "file_xxx";
const char *url = "-";
const char *target = "-";
const char *mime = "-";
sprintf(icon_buf, "file_%.3x",
ro_content_filetype(box->object));
if (!ro_gui_wimp_sprite_exists(icon_buf))
sprintf(icon_buf, "file_xxx");
if (box->object->url)
url = box->object->url;
if (box->href)
target = box->href;
if (box->object->mime_type)
mime = 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);
}
/**
* 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;
gui_form_select_control = NULL;
for (option = control->data.select.items; option; option = option->next)
i++;
if (i == 0)
return;
if (gui_form_select_menu) {
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);
ro_gui_menu_closed();
return;
}
gui_form_select_menu->title_data.indirected_text.text =
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 = (char *)-1;
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();
return;
}
gui_form_select_control = control;
ro_gui_menu_create(gui_form_select_menu,
pointer.pos.x, pointer.pos.y, bw->window->window);
}
/**
* Creates a wimp_menu and adds it to the list to handle actions for.
*
* \param menu the data to create the menu with
* \return the menu created, or NULL on failure
*/
wimp_menu *ro_gui_menu_define_menu(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.");
/* link in the menu to our list */
definition->next = ro_gui_menu_definitions;
ro_gui_menu_definitions = definition;
/* create our definitions */
for (entry = 0; menu->entries[entry].text; entry++);
ro_gui_menu_define_menu_add(definition, menu, 0, NULL,
0, entry, NULL, 0);
return definition->menu;
}
void ro_gui_menu_define_menu_add(struct menu_definition *definition,
struct ns_menu *menu, int depth, wimp_menu_entry *link,
int first, int last, const char *prefix, int prefix_length) {
int entry, id, cur_depth, new_prefix_length;
int entries = 0;
int matches[last - first + 1];
const char *match;
char *text, *menu_text, *search;
char *title, *translated;
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;
if ((prefix) && (strncmp(match, prefix, prefix_length)))
continue;
while (*match)
if (*match++ == '.')
cur_depth++;
if (depth == cur_depth)
matches[entries++] = entry;
}
matches[entries] = last;
/* step 2: build and link the menu. we must use realloc to stop
* our memory fragmenting so we can test for sub-menus easily */
if (entries == 0)
return;
new_menu = (wimp_menu *)malloc(wimp_SIZEOF_MENU(entries));
if (!new_menu)
die("No memory to create menu.");
if (link) {
title = link->data.indirected_text.text;
link->sub_menu = new_menu;
} else {
title = messages_get(menu->title);
if (!title)
die("No memory to translate root menu title");
definition->menu = new_menu;
}
new_menu->title_data.indirected_text.text = title;
new_menu->title_fg = wimp_COLOUR_BLACK;
new_menu->title_bg = wimp_COLOUR_LIGHT_GREY;
new_menu->work_fg = wimp_COLOUR_BLACK;
new_menu->work_bg = wimp_COLOUR_WHITE;
new_menu->width = 200;
new_menu->height = wimp_MENU_ITEM_HEIGHT;
new_menu->gap = wimp_MENU_ITEM_GAP;
for (entry = 0; entry < entries; entry++) {
/* add the entry */
id = matches[entry];
text = strdup(menu->entries[id].text);
if (!text)
die("No memory to examine menu text");
search = menu_text = text;
while (*search)
if (*search++ == '.')
menu_text = search;
new_menu->entries[entry].menu_flags = 0;
search = menu_text;
while (*search)
if (*search++ == '_') {
new_menu->entries[entry].menu_flags |=
wimp_MENU_SEPARATE;
search[-1] = 0;
break;
}
if (menu->entries[id].sub_window)
new_menu->entries[entry].sub_menu = (wimp_menu *)menu->
entries[id].sub_window;
else
new_menu->entries[entry].sub_menu = wimp_NO_SUB_MENU;
new_menu->entries[entry].icon_flags = DEFAULT_FLAGS |
wimp_ICON_INDIRECTED;
translated = messages_get(menu_text);
if (translated != menu_text)
free(text);
new_menu->entries[entry].data.indirected_text.text = translated;
new_menu->entries[entry].data.indirected_text.validation =
(char *)-1;
new_menu->entries[entry].data.indirected_text.size =
strlen(translated);
/* store action */
if (menu->entries[id].action != NO_ACTION) {
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->next = definition->entries;
definition->entries = definition_entry;
}
/* recurse */
if (new_menu->entries[entry].sub_menu == wimp_NO_SUB_MENU) {
new_prefix_length = strlen(menu->entries[id].text);
if (menu->entries[id].text[new_prefix_length - 1] == '_')
new_prefix_length--;
ro_gui_menu_define_menu_add(definition, menu, depth + 1,
&new_menu->entries[entry],
matches[entry], matches[entry + 1],
menu->entries[id].text,
new_prefix_length);
}
/* 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;
}
/**
* 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 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 =
ro_gui_menu_find_entry(menu, action);
if (entry) {
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;
struct content *c = NULL;
struct toolbar *t = NULL;
struct tree *tree;
struct node *node;
os_error *error;
char url[80];
ro_gui_menu_get_window_details(owner, &g, &bw, &c, &t, &tree);
switch (action) {
/* help actions */
case HELP_OPEN_CONTENTS:
ro_gui_open_help_page("docs");
return true;
case HELP_OPEN_GUIDE:
ro_gui_open_help_page("guide");
return true;
case HELP_OPEN_INFORMATION:
ro_gui_open_help_page("info");
return true;
case HELP_OPEN_ABOUT:
browser_window_create("file:/<NetSurf$Dir>/Docs/about",
0, 0);
return true;
case HELP_LAUNCH_INTERACTIVE:
ro_gui_interactive_help_start();
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_tree_show(global_history_tree);
return true;
/* hotlist actions */
case HOTLIST_ADD_URL:
if ((!hotlist_tree) || (!c))
return false;
node = tree_create_URL_node(hotlist_tree->root,
c->title, c->url, ro_content_filetype(c),
time(NULL), -1, 0);
if (node) {
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);
}
return true;
case HOTLIST_SHOW:
ro_gui_tree_show(hotlist_tree);
return true;
/* page actions */
case BROWSER_PAGE_INFO:
if (!c)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(g->window, dialog_pageinfo,
windows_at_pointer);
return true;
case BROWSER_PRINT:
if (!c)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(g->window, dialog_print,
windows_at_pointer);
return true;
case BROWSER_NEW_WINDOW:
if (!c)
return false;
browser_window_create(c->url, bw, 0);
return true;
case BROWSER_VIEW_SOURCE:
if (!c)
return false;
ro_gui_view_source(c);
return true;
/* object actions */
case BROWSER_OBJECT_INFO:
if (!current_menu_object_box)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(g->window, dialog_objinfo,
windows_at_pointer);
return true;
case BROWSER_OBJECT_RELOAD:
if (!current_menu_object_box)
return false;
current_menu_object_box->object->fresh = false;
browser_window_reload(bw, false);
return true;
/* save actions */
case BROWSER_OBJECT_SAVE:
case BROWSER_OBJECT_EXPORT_SPRITE:
case BROWSER_OBJECT_SAVE_URL_URI:
case BROWSER_OBJECT_SAVE_URL_URL:
case BROWSER_OBJECT_SAVE_URL_TEXT:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
case BROWSER_SAVE:
case BROWSER_SAVE_COMPLETE:
case BROWSER_EXPORT_DRAW:
case BROWSER_EXPORT_TEXT:
case BROWSER_SAVE_URL_URI:
case BROWSER_SAVE_URL_URL:
case BROWSER_SAVE_URL_TEXT:
if (!c)
return false;
case HOTLIST_EXPORT:
case HISTORY_EXPORT:
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(owner, dialog_saveas,
windows_at_pointer);
return true;
/* 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);
} else {
snprintf(url, sizeof url,
"file:/<NetSurf$Dir>/Docs/intro_%s",
option_language);
browser_window_go(g->bw, url, 0);
}
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_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_persistant(NULL, dialog_openurl,
windows_at_pointer);
return true;
/* browser window/display actions */
case BROWSER_SCALE_VIEW:
if (!c)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(g->window, dialog_zoom,
windows_at_pointer);
return true;
case BROWSER_FIND_TEXT:
if (!c)
return false;
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(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_BLEND_TEXT:
if (!g)
return false;
g->option.background_blending = !g->option.background_blending;
break;
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;
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;
/* tree actions */
case TREE_NEW_FOLDER:
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(g->window, dialog_folder,
windows_at_pointer);
return true;
case TREE_NEW_LINK:
ro_gui_menu_prepare_action(owner, action, true);
ro_gui_dialog_open_persistant(g->window, dialog_entry,
windows_at_pointer);
return true;
case TREE_EXPAND_ALL:
case TREE_EXPAND_FOLDERS:
case TREE_EXPAND_LINKS:
tree_handle_expansion(tree, tree->root, true,
(action != TREE_EXPAND_LINKS),
(action != TREE_EXPAND_FOLDERS));
return true;
case TREE_COLLAPSE_ALL:
case TREE_COLLAPSE_FOLDERS:
case TREE_COLLAPSE_LINKS:
tree_handle_expansion(tree, tree->root, false,
(action != TREE_COLLAPSE_LINKS),
(action != TREE_COLLAPSE_FOLDERS));
return true;
case TREE_SELECTION_EDIT:
return true;
case TREE_SELECTION_LAUNCH:
ro_gui_tree_launch_selected(tree);
return true;
case TREE_SELECTION_DELETE:
tree_delete_selected_nodes(tree, tree->root);
return true;
case TREE_SELECTION_RESET:
tree_reset_URL_nodes(tree, tree->root, true);
return true;
case TREE_SELECT_ALL:
ro_gui_tree_keypress(1, tree); /* CTRL-A */
return true;
case TREE_CLEAR_SELECTION:
ro_gui_tree_keypress(26, tree); /* CTRL-Z */
return true;
/* toolbar actions */
case TOOLBAR_BUTTONS:
assert(t);
t->display_buttons = !t->display_buttons;
ro_gui_menu_refresh_toolbar(t);
return true;
case TOOLBAR_ADDRESS_BAR:
assert(t);
t->display_url = !t->display_url;
ro_gui_menu_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_menu_refresh_toolbar(t);
return true;
case TOOLBAR_STATUS_BAR:
assert(t);
t->display_status = !t->display_status;
ro_gui_menu_refresh_toolbar(t);
return true;
case TOOLBAR_EDIT:
assert(t);
ro_gui_theme_toggle_edit(t);
return true;
/* misc actions */
case APPLICATION_QUIT:
netsurf_quit = true;
return true;
case CHOICES_SHOW:
ro_gui_dialog_open_config();
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 menu_definition_entry *entry;
struct gui_window *g;
struct browser_window *bw;
struct content *c;
struct toolbar *t;
struct tree *tree;
struct node *node;
bool result = false;
int checksum = 0;
os_error *error;
ro_gui_menu_get_window_details(owner, &g, &bw, &c, &t, &tree);
if (current_menu_open)
checksum = ro_gui_menu_get_checksum();
switch (action) {
/* help actions */
case HELP_LAUNCH_INTERACTIVE:
result = ro_gui_interactive_help_available();
ro_gui_menu_set_entry_shaded(current_menu, action, result);
ro_gui_menu_set_entry_ticked(current_menu, action, result);
break;
/* history actions */
case HISTORY_SHOW_LOCAL:
ro_gui_menu_set_entry_shaded(current_menu, action,
(!bw || (!bw->history) ||
!(c || history_back_available(bw->history) ||
history_forward_available(bw->history))));
break;
case HISTORY_SHOW_GLOBAL:
ro_gui_menu_set_entry_shaded(current_menu, action,
!global_history_tree);
break;
/* hotlist actions */
case HOTLIST_ADD_URL:
ro_gui_menu_set_entry_shaded(current_menu, action,
(!c || !hotlist_tree));
break;
case HOTLIST_SHOW:
ro_gui_menu_set_entry_shaded(current_menu, action,
!hotlist_tree);
if ((t) && (!t->editor) && (t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(t->toolbar_handle,
ICON_TOOLBAR_BOOKMARK, !hotlist_tree);
break;
/* page actions */
case BROWSER_PAGE_INFO:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((windows) && (c))
ro_gui_menu_prepare_pageinfo(g);
break;
case BROWSER_PRINT:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((t) && (t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(t->toolbar_handle,
ICON_TOOLBAR_PRINT, !c);
if ((windows) && (c))
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, !c);
break;
case BROWSER_PAGE:
case BROWSER_NEW_WINDOW:
case BROWSER_VIEW_SOURCE:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
break;
/* object actions */
case BROWSER_OBJECT:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
break;
case BROWSER_OBJECT_INFO:
if ((windows) && (current_menu_object_box))
ro_gui_menu_prepare_objectinfo(
current_menu_object_box);
case BROWSER_OBJECT_RELOAD:
ro_gui_menu_set_entry_shaded(current_menu, action,
!current_menu_object_box);
break;
/* save actions (browser, hotlist, history) */
case BROWSER_OBJECT_SAVE:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_OBJECT_ORIG, c);
break;
case BROWSER_OBJECT_EXPORT_SPRITE:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_OBJECT_NATIVE, c);
break;
case BROWSER_SAVE:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_SOURCE, c);
if ((t) && (!t->editor) && (t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(t->toolbar_handle,
ICON_TOOLBAR_SAVE, !c);
break;
case BROWSER_SAVE_COMPLETE:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_COMPLETE, c);
break;
case BROWSER_EXPORT_DRAW:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_DRAW, c);
break;
case BROWSER_EXPORT_TEXT:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_TEXT, c);
break;
case BROWSER_OBJECT_SAVE_URL_URI:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
case BROWSER_SAVE_URL_URI:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_LINK_URI, c);
break;
case BROWSER_OBJECT_SAVE_URL_URL:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
case BROWSER_SAVE_URL_URL:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_LINK_URL, c);
break;
case BROWSER_OBJECT_SAVE_URL_TEXT:
c = current_menu_object_box ?
current_menu_object_box->object : NULL;
case BROWSER_SAVE_URL_TEXT:
ro_gui_menu_set_entry_shaded(current_menu, action, !c);
if ((c) && (windows))
ro_gui_save_prepare(GUI_SAVE_LINK_TEXT, c);
break;
case HOTLIST_EXPORT:
if ((tree) && (windows))
ro_gui_save_prepare(GUI_SAVE_HOTLIST_EXPORT_HTML,
NULL);
break;
case HISTORY_EXPORT:
if ((tree) && (windows))
ro_gui_save_prepare(GUI_SAVE_HISTORY_EXPORT_HTML,
NULL);
break;
/* navigation actions */
case BROWSER_NAVIGATE_BACK:
result = (!bw || !bw->history ||
!history_back_available(bw->history));
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 = (!bw || !bw->history ||
!history_forward_available(bw->history));
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_RELOAD:
case BROWSER_NAVIGATE_RELOAD_ALL:
result = (bw->current_content && !bw->loading_content);
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 = (bw->loading_content || (bw->current_content &&
(bw->current_content->status !=
CONTENT_STATUS_DONE)));
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, !c);
if ((c) && (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, !c);
break;
case BROWSER_FIND_TEXT:
if ((c) && (windows))
ro_gui_search_prepare(g);
if ((t) && (!t->editor) && (t->type == THEME_BROWSER_TOOLBAR))
ro_gui_set_icon_shaded_state(t->toolbar_handle,
ICON_TOOLBAR_SEARCH, !c);
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_BLEND_TEXT:
if (g)
ro_gui_menu_set_entry_ticked(current_menu, action,
g->option.background_blending);
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_NEW_FOLDER:
ro_gui_hotlist_prepare_folder_dialog(NULL);
break;
case TREE_NEW_LINK:
ro_gui_hotlist_prepare_entry_dialog(NULL);
break;
case TREE_EXPAND_ALL:
case TREE_EXPAND_FOLDERS:
case TREE_EXPAND_LINKS:
case TREE_COLLAPSE_ALL:
case TREE_COLLAPSE_FOLDERS:
case TREE_COLLAPSE_LINKS:
if ((tree) && (tree->root))
ro_gui_menu_set_entry_shaded(current_menu, action,
!tree->root->child);
break;
case TREE_SELECTION:
if ((!tree) || (!tree->root))
break;
if (tree->root->child)
result = tree_has_selection(tree->root->child);
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_DELETE, !result);
ro_gui_set_icon_shaded_state(t->toolbar_handle,
ICON_TOOLBAR_LAUNCH, !result);
}
break;
case TREE_SELECTION_EDIT:
node = tree_get_selected_node(tree->root);
entry = ro_gui_menu_find_entry(current_menu, action);
if ((!node) || (!entry))
break;
if (node->folder) {
entry->menu_entry->sub_menu =
(wimp_menu *)dialog_folder;
if (windows)
ro_gui_hotlist_prepare_folder_dialog(node);
} else {
entry->menu_entry->sub_menu =
(wimp_menu *)dialog_entry;
if (windows)
ro_gui_hotlist_prepare_entry_dialog(node);
}
break;
case TREE_SELECTION_LAUNCH:
case TREE_SELECTION_DELETE:
case TREE_SELECTION_RESET:
if ((!tree) || (!tree->root))
break;
if (tree->root->child)
result = tree_has_selection(tree->root->child);
ro_gui_menu_set_entry_shaded(current_menu, action, !result);
break;
case TREE_SELECT_ALL:
ro_gui_menu_set_entry_shaded(current_menu, action,
!tree->root->child);
break;
case TREE_CLEAR_SELECTION:
if ((!tree) || (!tree->root))
break;
if (tree->root->child)
result = tree_has_selection(tree->root->child);
ro_gui_menu_set_entry_shaded(current_menu, action, !result);
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_STATUS_BAR:
ro_gui_menu_set_entry_shaded(current_menu, action, !t);
ro_gui_menu_set_entry_ticked(current_menu, action,
(t && t->display_status));
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, struct content **content,
struct toolbar **toolbar, struct tree **tree) {
*g = ro_gui_window_lookup(w);
if (*g) {
*bw = (*g)->bw;
*toolbar = (*g)->toolbar;
if (*bw)
*content = (*bw)->current_content;
*tree = NULL;
} else {
*bw = NULL;
*content = NULL;
if ((hotlist_tree) && (w == (wimp_w)hotlist_tree->handle))
*tree = hotlist_tree;
else if ((global_history_tree) &&
(w == (wimp_w)global_history_tree->handle))
*tree = global_history_tree;
else
*tree = NULL;
if (*tree)
*toolbar = (*tree)->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;
} while (j != -1);
return checksum;
}
Reference in New Issue View Git Blame Copy Permalink