mirrors/netsurf
1
0
Fork 0
mirror of https://github.com/netsurf-browser/netsurf synced 2024-11-26 00:09:41 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'vince/ro-corewindow'

Browse Source 
Conflicts:
	frontends/riscos/sslcert.h
This commit is contained in:
Vincent Sanders 2016-12-28 16:14:19 +00:00
commit 96e073a297
30 changed files with 2807 additions and 2590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
desktop/treeview.c
View File

@ -3670,6 +3670,8 @@ static void treeview_init_resources(void)
for (i = 0; i < TREE_RES_LAST; i++) {
nsurl *url;
treeview_res[i].ready = false;
treeview_res[i].height = 0;
if (nsurl_create(treeview_res[i].url, &url) == NSERROR_OK) {
hlcache_handle_retrieve(url, 0, NULL, NULL,
treeview_res_cb,

24
frontends/gtk/corewindow.c
View File

@ -620,11 +620,11 @@ nsgtk_cw_scroll_visible(struct core_window *cw, const struct rect *r)
/**
* get window size core window callback
* Callback from the core to obtain the window viewport dimensions
*
* \param cw core window handle.
* \param[out] width The width value to update
* \param[out] height The height value to update
* \param[in] cw the core window object
* \param[out] width to be set to viewport width in px
* \param[out] height to be set to viewport height in px
*/
static void
nsgtk_cw_get_window_dimensions(struct core_window *cw, int *width, int *height)
@ -634,17 +634,13 @@ nsgtk_cw_get_window_dimensions(struct core_window *cw, int *width, int *height)
GtkAdjustment *hadj;
gdouble page;
if (width != NULL) {
hadj = gtk_scrolled_window_get_hadjustment(nsgtk_cw->scrolled);
g_object_get(hadj, "page-size", &page, NULL);
*width = page;
}
hadj = gtk_scrolled_window_get_hadjustment(nsgtk_cw->scrolled);
g_object_get(hadj, "page-size", &page, NULL);
*width = page;
if (height != NULL) {
vadj = gtk_scrolled_window_get_vadjustment(nsgtk_cw->scrolled);
g_object_get(vadj, "page-size", &page, NULL);
*height = page;
}
vadj = gtk_scrolled_window_get_vadjustment(nsgtk_cw->scrolled);
g_object_get(vadj, "page-size", &page, NULL);
*height = page;
}

3
frontends/gtk/hotlist.c
View File

@ -38,6 +38,9 @@
#include "gtk/corewindow.h"
#include "gtk/hotlist.h"
/**
* hotlist window container for gtk.
*/
struct nsgtk_hotlist_window {
struct nsgtk_corewindow core;
GtkBuilder *builder;

15
frontends/riscos/Makefile
View File

@ -46,15 +46,14 @@ endif
# ----------------------------------------------------------------------------
# S_RISCOS are sources purely for the RISC OS build
S_FRONTEND := 401login.c assert.c bitmap.c buffer.c cookies.c configure.c \
dialog.c download.c filetype.c font.c \
global_history.c gui.c help.c history.c hotlist.c iconbar.c \
image.c menus.c message.c mouse.c palettes.c plotters.c \
S_FRONTEND := 401login.c assert.c bitmap.c buffer.c configure.c gui.c \
dialog.c download.c filetype.c font.c help.c history.c image.c \
iconbar.c menus.c message.c mouse.c palettes.c plotters.c \
print.c query.c save.c save_draw.c save_pdf.c schedule.c \
search.c searchweb.c sslcert.c textarea.c \
textselection.c theme.c theme_install.c toolbar.c \
treeview.c ucstables.c uri.c url_complete.c url_protocol.c \
url_suggest.c wimp.c wimp_event.c window.c \
search.c searchweb.c textarea.c textselection.c theme.c \
theme_install.c toolbar.c url_suggest.c wimp.c wimp_event.c \
ucstables.c uri.c url_complete.c url_protocol.c window.c \
corewindow.c cookies.c sslcert.c global_history.c hotlist.c \
$(addprefix content-handlers/,artworks.c awrender.s draw.c \
sprite.c) \
$(addprefix gui/,button_bar.c progress_bar.c status_bar.c \

533
frontends/riscos/cookies.c
View File

@ -1,6 +1,5 @@
/*
* Copyright 2006 Richard Wilson <info@tinct.net>
* Copyright 2010 Stephen Fryatt <stevef@netsurf-browser.org>
* Copyright 2016 Vincent Sanders <vince@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
@ -17,176 +16,120 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* Cookies (implementation).
/**
* \file
* Implementation of RISC OS cookie manager.
*/
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "oslib/wimp.h"
#include "oslib/wimpspriteop.h"
#include <oslib/wimp.h>
#include "utils/log.h"
#include "utils/nsoption.h"
#include "utils/messages.h"
#include "utils/log.h"
#include "netsurf/plotters.h"
#include "netsurf/keypress.h"
#include "desktop/cookie_manager.h"
#include "desktop/tree.h"
#include "riscos/cookies.h"
#include "riscos/dialog.h"
#include "riscos/menus.h"
#include "riscos/toolbar.h"
#include "riscos/treeview.h"
#include "riscos/gui.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"
#include "riscos/dialog.h"
#include "riscos/toolbar.h"
#include "riscos/corewindow.h"
#include "riscos/cookies.h"
static void ro_gui_cookies_toolbar_update_buttons(void);
static void ro_gui_cookies_toolbar_save_buttons(char *config);
static bool ro_gui_cookies_menu_prepare(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_pointer *pointer);
static void ro_gui_cookies_menu_warning(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_selection *selection, menu_action action);
static bool ro_gui_cookies_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_selection *selection, menu_action action);
static void ro_gui_cookies_toolbar_click(button_bar_action action);
struct ro_treeview_callbacks ro_cookies_treeview_callbacks = {
ro_gui_cookies_toolbar_click,
ro_gui_cookies_toolbar_update_buttons,
ro_gui_cookies_toolbar_save_buttons
struct ro_cookie_window {
struct ro_corewindow core;
wimp_menu *menu;
};
/* The RISC OS cookie window, toolbar and treeview data. */
/** cookie window is a singleton */
static struct ro_cookie_window *cookie_window = NULL;
/** riscos template for cookie window */
static wimp_window *dialog_cookie_template;
static struct ro_cookies_window {
wimp_w window;
struct toolbar *toolbar;
ro_treeview *tv;
wimp_menu *menu;
} cookies_window;
/**
* Pre-Initialise the cookies tree. This is called for things that
* need to be done at the gui_init() stage, such as loading templates.
* callback to draw on drawable area of ro cookie window
*
* \param ro_cw The riscos core window structure.
* \param r The rectangle of the window that needs updating.
* \param originx The risc os plotter x origin.
* \param originy The risc os plotter y origin.
* \return NSERROR_OK on success otherwise apropriate error code
*/
void ro_gui_cookies_preinitialise(void)
static nserror
cookie_draw(struct ro_corewindow *ro_cw,
int originx,
int originy,
struct rect *r)
{
/* Create our window. */
cookies_window.window = ro_gui_dialog_create("tree");
ro_gui_set_window_title(cookies_window.window,
messages_get("Cookies"));
}
/**
* Initialise cookies tree, at the gui_init2() stage.
*/
void ro_gui_cookies_postinitialise(void)
{
/* Create our toolbar. */
cookies_window.toolbar = ro_toolbar_create(NULL, cookies_window.window,
THEME_STYLE_COOKIES_TOOLBAR, TOOLBAR_FLAGS_NONE,
ro_treeview_get_toolbar_callbacks(), NULL,
"HelpCookiesToolbar");
if (cookies_window.toolbar != NULL) {
ro_toolbar_add_buttons(cookies_window.toolbar,
cookies_toolbar_buttons,
nsoption_charp(toolbar_cookies));
ro_toolbar_rebuild(cookies_window.toolbar);
}
/* Create the treeview with the window and toolbar. */
cookies_window.tv = ro_treeview_create(cookies_window.window,
cookies_window.toolbar, &ro_cookies_treeview_callbacks,
TREE_COOKIES);
if (cookies_window.tv == NULL) {
LOG("Failed to allocate treeview");
return;
}
ro_toolbar_update_client_data(cookies_window.toolbar,
cookies_window.tv);
/* Build the cookies window menu. */
static const struct ns_menu cookies_definition = {
"Cookies", {
{ "Cookies", NO_ACTION, 0 },
{ "Cookies.Expand", TREE_EXPAND_ALL, 0 },
{ "Cookies.Expand.All", TREE_EXPAND_ALL, 0 },
{ "Cookies.Expand.Folders", TREE_EXPAND_FOLDERS, 0 },
{ "Cookies.Expand.Links", TREE_EXPAND_LINKS, 0 },
{ "Cookies.Collapse", TREE_COLLAPSE_ALL, 0 },
{ "Cookies.Collapse.All", TREE_COLLAPSE_ALL, 0 },
{ "Cookies.Collapse.Folders", TREE_COLLAPSE_FOLDERS, 0 },
{ "Cookies.Collapse.Links", TREE_COLLAPSE_LINKS, 0 },
{ "Cookies.Toolbars", NO_ACTION, 0 },
{ "_Cookies.Toolbars.ToolButtons", TOOLBAR_BUTTONS, 0 },
{ "Cookies.Toolbars.EditToolbar",TOOLBAR_EDIT, 0 },
{ "Selection", TREE_SELECTION, 0 },
{ "Selection.Delete", TREE_SELECTION_DELETE, 0 },
{ "SelectAll", TREE_SELECT_ALL, 0 },
{ "Clear", TREE_CLEAR_SELECTION, 0 },
{NULL, 0, 0}
}
struct redraw_context ctx = {
.interactive = true,
.background_images = true,
.plot = &ro_plotters
};
cookies_window.menu = ro_gui_menu_define_menu(&cookies_definition);
ro_gui_wimp_event_register_menu(cookies_window.window,
cookies_window.menu, false, false);
ro_gui_wimp_event_register_menu_prepare(cookies_window.window,
ro_gui_cookies_menu_prepare);
ro_gui_wimp_event_register_menu_selection(cookies_window.window,
ro_gui_cookies_menu_select);
ro_gui_wimp_event_register_menu_warning(cookies_window.window,
ro_gui_cookies_menu_warning);
ro_plot_origin_x = originx;
ro_plot_origin_y = originy;
no_font_blending = true;
cookie_manager_redraw(0, 0, r, &ctx);
no_font_blending = false;
return NSERROR_OK;
}
/**
* Destroy the cookies window.
*/
void ro_gui_cookies_destroy(void)
{
if (cookies_window.tv == NULL)
return;
ro_treeview_destroy(cookies_window.tv);
}
/**
* Open the cookies window.
* callback for keypress on ro cookie window
*
* \param ro_cw The ro core window structure.
* \param nskey The netsurf key code.
* \return NSERROR_OK if key processed,
* NSERROR_NOT_IMPLEMENTED if key not processed
* otherwise apropriate error code
*/
void ro_gui_cookies_open(void)
static nserror cookie_key(struct ro_corewindow *ro_cw, uint32_t nskey)
{
ro_gui_cookies_toolbar_update_buttons();
if (!ro_gui_dialog_open_top(cookies_window.window,
cookies_window.toolbar, 600, 800)) {
ro_treeview_set_origin(cookies_window.tv, 0,
-(ro_toolbar_height(cookies_window.toolbar)));
if (cookie_manager_keypress(nskey)) {
return NSERROR_OK;
}
return NSERROR_NOT_IMPLEMENTED;
}
/**
* Handle toolbar button clicks.
* callback for mouse event on ro cookie window
*
* \param action The action to handle
* \param ro_cw The ro core window structure.
* \param mouse_state mouse state
* \param x location of event
* \param y location of event
* \return NSERROR_OK on sucess otherwise apropriate error code.
*/
static nserror
cookie_mouse(struct ro_corewindow *ro_cw,
browser_mouse_state mouse_state,
int x, int y)
{
cookie_manager_mouse_action(mouse_state, x, y);
void ro_gui_cookies_toolbar_click(button_bar_action action)
return NSERROR_OK;
}
/**
* handle clicks in ro core window toolbar.
*
* \param ro_cw The ro core window structure.
* \param action The button bar action.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
static nserror
cookie_toolbar_click(struct ro_corewindow *ro_cw, button_bar_action action)
{
switch (action) {
case TOOLBAR_BUTTON_DELETE:
@ -212,139 +155,178 @@ void ro_gui_cookies_toolbar_click(button_bar_action action)
default:
break;
}
return NSERROR_OK;
}
/**
* Update the button state in the cookies toolbar.
* Handle updating state of buttons in ro core window toolbar.
*
* \param ro_cw The ro core window structure.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
void ro_gui_cookies_toolbar_update_buttons(void)
static nserror cookie_toolbar_update(struct ro_corewindow *ro_cw)
{
ro_toolbar_set_button_shaded_state(cookies_window.toolbar,
ro_toolbar_set_button_shaded_state(ro_cw->toolbar,
TOOLBAR_BUTTON_DELETE,
!cookie_manager_has_selection());
return NSERROR_OK;
}
/**
* Save a new button arrangement in the cookies toolbar.
* callback for saving of toolbar state in ro cookie window
*
* \param *config The new button configuration string.
* \param ro_cw The ro core window structure.
* \param config The new toolbar configuration.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
void ro_gui_cookies_toolbar_save_buttons(char *config)
static nserror cookie_toolbar_save(struct ro_corewindow *ro_cw, char *config)
{
nsoption_set_charp(toolbar_cookies, config);
ro_gui_save_options();
return NSERROR_OK;
}
/**
* Prepare the cookies menu for opening
* Prepare the cookie meu for display
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param *menu The menu about to be opened.
* \param *pointer Pointer to the relevant wimp event block, or
* NULL for an Adjust click.
* \return true if the event was handled; else false.
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param menu The menu from which the selection was made.
* \param pointer The pointer shape
* \return true if action accepted; else false.
*/
bool ro_gui_cookies_menu_prepare(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_pointer *pointer)
static bool
cookie_menu_prepare(wimp_w w,
wimp_i i,
wimp_menu *menu,
wimp_pointer *pointer)
{
bool selection;
struct ro_cookie_window *cookiew;
if (menu != cookies_window.menu)
cookiew = (struct ro_cookie_window *)ro_gui_wimp_event_get_user_data(w);
if ((cookiew == NULL) ||
(menu != cookiew->menu)) {
return false;
}
selection = cookie_manager_has_selection();
ro_gui_menu_set_entry_shaded(cookies_window.menu,
TREE_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(cookies_window.menu,
TREE_CLEAR_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(menu, TREE_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(menu, TREE_CLEAR_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(menu, TOOLBAR_BUTTONS,
ro_toolbar_menu_option_shade(cookies_window.toolbar));
ro_toolbar_menu_option_shade(cookiew->core.toolbar));
ro_gui_menu_set_entry_ticked(menu, TOOLBAR_BUTTONS,
ro_toolbar_menu_buttons_tick(cookies_window.toolbar));
ro_toolbar_menu_buttons_tick(cookiew->core.toolbar));
ro_gui_menu_set_entry_shaded(menu, TOOLBAR_EDIT,
ro_toolbar_menu_edit_shade(cookies_window.toolbar));
ro_toolbar_menu_edit_shade(cookiew->core.toolbar));
ro_gui_menu_set_entry_ticked(menu, TOOLBAR_EDIT,
ro_toolbar_menu_edit_tick(cookies_window.toolbar));
ro_toolbar_menu_edit_tick(cookiew->core.toolbar));
return true;
}
/**
* Handle submenu warnings for the cookies menu
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param *menu The menu to which the warning applies.
* \param *selection The wimp menu selection data.
* \param action The selected menu action.
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param menu The menu to which the warning applies.
* \param selection The wimp menu selection data.
* \param action The selected menu action.
*/
void ro_gui_cookies_menu_warning(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_selection *selection, menu_action action)
static void
cookie_menu_warning(wimp_w w,
wimp_i i,
wimp_menu *menu,
wimp_selection *selection,
menu_action action)
{
/* Do nothing */
}
/**
* Handle selections from the cookies menu
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param *menu The menu from which the selection was made.
* \param *selection The wimp menu selection data.
* \param action The selected menu action.
* \return true if action accepted; else false.
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param menu The menu from which the selection was made.
* \param selection The wimp menu selection data.
* \param action The selected menu action.
* \return true if action accepted; else false.
*/
bool ro_gui_cookies_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_selection *selection, menu_action action)
static bool
cookie_menu_select(wimp_w w,
wimp_i i,
wimp_menu *menu,
wimp_selection *selection,
menu_action action)
{
struct ro_cookie_window *cookiew;
cookiew = (struct ro_cookie_window *)ro_gui_wimp_event_get_user_data(w);
if ((cookiew == NULL) ||
(menu != cookiew->menu)) {
return false;
}
switch (action) {
case TREE_EXPAND_ALL:
cookie_manager_expand(false);
return true;
case TREE_EXPAND_FOLDERS:
cookie_manager_expand(true);
return true;
case TREE_EXPAND_LINKS:
cookie_manager_expand(false);
return true;
case TREE_COLLAPSE_ALL:
cookie_manager_contract(true);
return true;
case TREE_COLLAPSE_FOLDERS:
cookie_manager_contract(true);
return true;
case TREE_COLLAPSE_LINKS:
cookie_manager_contract(false);
return true;
case TREE_SELECTION_DELETE:
cookie_manager_keypress(NS_KEY_DELETE_LEFT);
return true;
case TREE_SELECT_ALL:
cookie_manager_keypress(NS_KEY_SELECT_ALL);
return true;
case TREE_CLEAR_SELECTION:
cookie_manager_keypress(NS_KEY_CLEAR_SELECTION);
return true;
case TOOLBAR_BUTTONS:
ro_toolbar_set_display_buttons(cookies_window.toolbar,
!ro_toolbar_get_display_buttons(
cookies_window.toolbar));
ro_toolbar_set_display_buttons(cookiew->core.toolbar,
!ro_toolbar_get_display_buttons(cookiew->core.toolbar));
return true;
case TOOLBAR_EDIT:
ro_toolbar_toggle_edit(cookies_window.toolbar);
ro_toolbar_toggle_edit(cookiew->core.toolbar);
return true;
default:
return false;
}
@ -352,33 +334,174 @@ bool ro_gui_cookies_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
return false;
}
/**
* Check if a particular window handle is the cookies window
*
* \param window the window in question
* \return true if this window is the cookies
*/
bool ro_gui_cookies_check_window(wimp_w window)
/**
* Creates the window for the cookie tree.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
static nserror ro_cookie_init(void)
{
if (cookies_window.window == window)
return true;
else
return false;
struct ro_cookie_window *ncwin;
nserror res;
static const struct ns_menu cookie_menu_def = {
"Cookies", {
{ "Cookies", NO_ACTION, 0 },
{ "Cookies.Expand", TREE_EXPAND_ALL, 0 },
{ "Cookies.Expand.All", TREE_EXPAND_ALL, 0 },
{ "Cookies.Expand.Folders", TREE_EXPAND_FOLDERS, 0 },
{ "Cookies.Expand.Links", TREE_EXPAND_LINKS, 0 },
{ "Cookies.Collapse", TREE_COLLAPSE_ALL, 0 },
{ "Cookies.Collapse.All", TREE_COLLAPSE_ALL, 0 },
{ "Cookies.Collapse.Folders", TREE_COLLAPSE_FOLDERS, 0 },
{ "Cookies.Collapse.Links", TREE_COLLAPSE_LINKS, 0 },
{ "Cookies.Toolbars", NO_ACTION, 0 },
{ "_Cookies.Toolbars.ToolButtons", TOOLBAR_BUTTONS, 0 },
{ "Cookies.Toolbars.EditToolbar",TOOLBAR_EDIT, 0 },
{ "Selection", TREE_SELECTION, 0 },
{ "Selection.Delete", TREE_SELECTION_DELETE, 0 },
{ "SelectAll", TREE_SELECT_ALL, 0 },
{ "Clear", TREE_CLEAR_SELECTION, 0 },
{ NULL, 0, 0}
}
};
static const struct button_bar_buttons cookies_toolbar_buttons[] = {
{ "delete", TOOLBAR_BUTTON_DELETE, TOOLBAR_BUTTON_NONE, '0', "0"},
{ "expand", TOOLBAR_BUTTON_EXPAND, TOOLBAR_BUTTON_COLLAPSE, '1', "1"},
{ "open", TOOLBAR_BUTTON_OPEN, TOOLBAR_BUTTON_CLOSE, '2', "2"},
{ NULL, TOOLBAR_BUTTON_NONE, TOOLBAR_BUTTON_NONE, '\0', ""}
};
if (cookie_window != NULL) {
return NSERROR_OK;
}
ncwin = malloc(sizeof(struct ro_cookie_window));
if (ncwin == NULL) {
return NSERROR_NOMEM;
}
/* create window from template */
ncwin->core.wh = wimp_create_window(dialog_cookie_template);
ro_gui_set_window_title(ncwin->core.wh, messages_get("Cookies"));
ncwin->core.draw = cookie_draw;
ncwin->core.key = cookie_key;
ncwin->core.mouse = cookie_mouse;
ncwin->core.toolbar_click = cookie_toolbar_click;
ncwin->core.toolbar_save = cookie_toolbar_save;
/* update is not valid untill cookie manager is initialised */
ncwin->core.toolbar_update = NULL;
/* initialise core window */
res = ro_corewindow_init(&ncwin->core,
cookies_toolbar_buttons,
nsoption_charp(toolbar_cookies),
THEME_STYLE_COOKIES_TOOLBAR,
"HelpCookiesToolbar");
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
res = cookie_manager_init(ncwin->core.cb_table,
(struct core_window *)ncwin);
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
/* setup toolbar update post cookie manager initialisation */
ncwin->core.toolbar_update = cookie_toolbar_update;
cookie_toolbar_update(&ncwin->core);
/* Build the cookies window menu. */
ncwin->menu = ro_gui_menu_define_menu(&cookie_menu_def);
ro_gui_wimp_event_register_menu(ncwin->core.wh,
ncwin->menu, false, false);
ro_gui_wimp_event_register_menu_prepare(ncwin->core.wh,
cookie_menu_prepare);
ro_gui_wimp_event_register_menu_selection(ncwin->core.wh,
cookie_menu_select);
ro_gui_wimp_event_register_menu_warning(ncwin->core.wh,
cookie_menu_warning);
/* memoise window so it can be represented when necessary
* instead of recreating every time.
*/
cookie_window = ncwin;
return NSERROR_OK;
}
/**
* Check if a particular menu handle is the cookies menu
*
* \param *menu The menu in question.
* \return true if this menu is the cookies menu
*/
/* exported interface documented in riscos/cookies.h */
nserror ro_gui_cookies_present(void)
{
nserror res;
res = ro_cookie_init();
if (res == NSERROR_OK) {
LOG("Presenting");
ro_gui_dialog_open_top(cookie_window->core.wh,
cookie_window->core.toolbar,
600, 800);
} else {
LOG("Failed presenting code %d", res);
}
return res;
}
/* exported interface documented in riscos/cookies.h */
void ro_gui_cookies_initialise(void)
{
dialog_cookie_template = ro_gui_dialog_load_template("tree");
}
/* exported interface documented in riscos/cookies.h */
nserror ro_gui_cookies_finalise(void)
{
nserror res;
if (cookie_window == NULL) {
return NSERROR_OK;
}
res = cookie_manager_fini();
if (res == NSERROR_OK) {
res = ro_corewindow_fini(&cookie_window->core);
free(cookie_window);
cookie_window = NULL;
}
return res;
}
/* exported interface documented in riscos/cookies.h */
bool ro_gui_cookies_check_window(wimp_w wh)
{
if ((cookie_window != NULL) &&
(cookie_window->core.wh == wh)) {
return true;
}
return false;
}
/* exported interface documented in riscos/cookies.h */
bool ro_gui_cookies_check_menu(wimp_menu *menu)
{
if (cookies_window.menu == menu)
if ((cookie_window != NULL) &&
(cookie_window->menu == menu)) {
return true;
else
return false;
}
return false;
}

49
frontends/riscos/cookies.h
View File

@ -17,22 +17,47 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* Cookies (interface).
/**
* \file
* Interface to riscos cookie viewing using riscos core window.
*
* The interface assumes there is only a single cookie window which is
* presented (shown) when asked for and hidden by usual toolkit
* mechanics.
*
* The destructor is called once during browser shutdown
*/
#ifndef _NETSURF_RISCOS_COOKIES_H_
#define _NETSURF_RISCOS_COOKIES_H_
#ifndef NETSURF_RISCOS_COOKIES_H
#define NETSURF_RISCOS_COOKIES_H
#include "riscos/menus.h"
/**
* initialise the cookies window template ready for subsequent use.
*/
void ro_gui_cookies_initialise(void);
void ro_gui_cookies_preinitialise(void);
void ro_gui_cookies_postinitialise(void);
void ro_gui_cookies_destroy(void);
/**
* make the cookie window visible.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
nserror ro_gui_cookies_present(void);
/**
* Free any resources allocated for the cookie window.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
nserror ro_gui_cookies_finalise(void);
/**
* check if window handle is for the cookies window
*/
bool ro_gui_cookies_check_window(wimp_w window);
/**
* check if menu handle is for the cookies menu
*/
bool ro_gui_cookies_check_menu(wimp_menu *menu);
void ro_gui_cookies_open(void);
#endif
#endif /* NETSURF_RISCOS_COOKIES_H */

932
frontends/riscos/corewindow.c Normal file
View File

@ -0,0 +1,932 @@
/*
* Copyright 2016 Vincent Sanders <vince@netsurf-browser.org>
*
* 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
* RISC OS generic core window implementation.
*
* Provides interface for core renderers to a risc os drawing area.
*
* This module is an object that must be encapsulated. Client users
* should embed a struct ro_corewindow at the beginning of their
* context for this display surface, fill in relevant data and then
* call ro_corewindow_init()
*
* The ro core window structure requires the callback for draw, key
* and mouse operations.
*/
#include <stdint.h>
#include <oslib/wimp.h>
#include "utils/utils.h"
#include "utils/log.h"
#include "netsurf/mouse.h"
#include "netsurf/keypress.h"
#include "riscos/wimp_event.h"
#include "riscos/dialog.h"
#include "riscos/gui.h"
#include "riscos/toolbar.h"
#include "riscos/mouse.h"
#include "riscos/corewindow.h"
#ifndef wimp_KEY_END
#define wimp_KEY_END wimp_KEY_COPY
#endif
/**
* Update a windows scrollbars.
*
* in the wimp this is done by setting the extent and calling window open
*/
static void update_scrollbars(struct ro_corewindow *ro_cw, wimp_open *open)
{
os_error *error;
int extent_width;
int extent_height;
os_box extent;
LOG("RO corewindow context %p", ro_cw);
/* extent of content in not smaller than window so start there */
extent_width = open->visible.x1 - open->visible.x0;
extent_height = open->visible.y0 - open->visible.y1;
LOG("extent w:%d h:%d content w:%d h:%d origin h:%d",
extent_width, extent_height,
ro_cw->content_width, ro_cw->content_height, ro_cw->origin_y);
if (ro_cw->content_width > extent_width) {
extent_width = ro_cw->content_width;
}
if (extent_height > (ro_cw->origin_y + ro_cw->content_height)) {
extent_height = ro_cw->origin_y + ro_cw->content_height;
}
LOG("extent w:%d h:%d",
extent_width, extent_height);
extent.x0 = 0;
extent.y0 = extent_height;
extent.x1 = extent_width;
extent.y1 = 0;
error = xwimp_set_extent(ro_cw->wh, &extent);
if (error) {
LOG("xwimp_set_extent: 0x%x: %s",
error->errnum, error->errmess);
return;
}
error = xwimp_open_window(open);
if (error) {
LOG("xwimp_open_window: 0x%x: %s",
error->errnum, error->errmess);
}
}
/**
* wimp callback on redraw event
*/
static void ro_cw_redraw(wimp_draw *redraw)
{
struct ro_corewindow *ro_cw;
osbool more;
os_error *error;
struct rect r;
int origin_x;
int origin_y;
ro_cw = (struct ro_corewindow *)ro_gui_wimp_event_get_user_data(redraw->w);
error = xwimp_redraw_window(redraw, &more);
while ((error == NULL) && (more)) {
/* compute rectangle to redraw */
origin_x = redraw->box.x0 - redraw->xscroll;
origin_y = redraw->box.y1 + ro_cw->origin_y - redraw->yscroll;
r.x0 = (redraw->clip.x0 - origin_x) / 2;
r.y0 = (origin_y - redraw->clip.y1) / 2;
r.x1 = r.x0 + ((redraw->clip.x1 - redraw->clip.x0) / 2);
r.y1 = r.y0 + ((redraw->clip.y1 - redraw->clip.y0) / 2);
/* call the draw callback */
ro_cw->draw(ro_cw, origin_x, origin_y, &r);
error = xwimp_get_rectangle(redraw, &more);
}
if (error != NULL) {
LOG("xwimp_redraw_window: 0x%x: %s",
error->errnum, error->errmess);
}
}
static void ro_cw_scroll(wimp_scroll *scroll)
{
os_error *error;
int page_x;
int page_y;
struct ro_corewindow *ro_cw;
wimp_open open;
ro_cw = (struct ro_corewindow *)ro_gui_wimp_event_get_user_data(scroll->w);
LOG("RO corewindow context %p", ro_cw);
page_x = scroll->visible.x1 - scroll->visible.x0 - 32;
page_y = scroll->visible.y1 - scroll->visible.y0 - 32;
page_y += ro_cw->origin_y;
open.w = scroll->w;
open.visible = scroll->visible;
open.next = scroll->next;
switch (scroll->xmin) {
case wimp_SCROLL_PAGE_LEFT:
open.xscroll = scroll->xscroll - page_x;
break;
case wimp_SCROLL_COLUMN_LEFT:
open.xscroll = scroll->xscroll - 32;
break;
case wimp_SCROLL_COLUMN_RIGHT:
open.xscroll = scroll->xscroll + 32;
break;
case wimp_SCROLL_PAGE_RIGHT:
open.xscroll = scroll->xscroll + page_x;
break;
default:
open.xscroll = scroll->xscroll + ((page_x * (scroll->xmin>>2)) >> 2);
break;
}
switch (scroll->ymin) {
case wimp_SCROLL_PAGE_UP:
open.yscroll = scroll->yscroll + page_y;
break;
case wimp_SCROLL_LINE_UP:
open.yscroll = scroll->yscroll + 32;
break;
case wimp_SCROLL_LINE_DOWN:
open.yscroll = scroll->yscroll - 32;
break;
case wimp_SCROLL_PAGE_DOWN:
open.yscroll = scroll->yscroll - page_y;
break;
default:
open.yscroll = scroll->yscroll + ((page_y * (scroll->ymin>>2)) >> 2);
break;
}
error = xwimp_open_window(&open);
if (error) {
LOG("xwimp_open_window: 0x%x: %s",
error->errnum, error->errmess);
}
}
/**
* Track the mouse under Null Polls from the wimp, to support dragging.
*
* \param pointer Pointer to a Wimp Pointer block.
* \param data NULL to allow use as a ro_mouse callback.
*/
static void ro_cw_mouse_at(wimp_pointer *pointer, void *data)
{
os_error *error;
struct ro_corewindow *ro_cw;
wimp_window_state state;
int xpos, ypos;
browser_mouse_state mouse;
/* ignore menu clicks */
if (pointer->buttons & (wimp_CLICK_MENU)) {
return;
}
ro_cw = (struct ro_corewindow *)ro_gui_wimp_event_get_user_data(pointer->w);
if (ro_cw == NULL) {
LOG("no corewindow conext for window: 0x%x",
(unsigned int)pointer->w);
return;
}
LOG("RO corewindow context %p", ro_cw);
/* no futher processing required if no drag in progress */
if (ro_cw->drag_status == CORE_WINDOW_DRAG_NONE) {
return;
}
/* Not a Menu click and a drag is in progress. */
state.w = pointer->w;
error = xwimp_get_window_state(&state);
if (error) {
LOG("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess);
return;
}
/* Convert the returned mouse coordinates into NetSurf's internal
* units.
*/
xpos = ((pointer->pos.x - state.visible.x0) + state.xscroll) / 2;
ypos = ((state.visible.y1 - pointer->pos.y) -
state.yscroll + ro_cw->origin_y) / 2;
/* Start to process the mouse click. */
mouse = ro_gui_mouse_drag_state(pointer->buttons,
wimp_BUTTON_DOUBLE_CLICK_DRAG);
ro_cw->mouse(ro_cw, mouse, xpos, ypos);
if (!(mouse & BROWSER_MOUSE_DRAG_ON)) {
ro_cw->mouse(ro_cw, BROWSER_MOUSE_HOVER, xpos, ypos);
ro_cw->drag_status = CORE_WINDOW_DRAG_NONE;
}
ro_cw->toolbar_update(ro_cw);
}
/**
* Process RISC OS User Drag Box events which relate to us: in effect, drags
* started by ro_cw_drag_start().
*
* \param drag Pointer to the User Drag Box Event block.
* \param data NULL to allow use as a ro_mouse callback.
*/
static void ro_cw_drag_end(wimp_dragged *drag, void *data)
{
os_error *error;
error = xwimp_drag_box((wimp_drag *) -1);
if (error) {
LOG("xwimp_drag_box: 0x%x: %s", error->errnum, error->errmess);
ro_warn_user("WimpError", error->errmess);
}
error = xwimp_auto_scroll(0, NULL, NULL);
if (error) {
LOG("xwimp_auto_scroll: 0x%x: %s",
error->errnum, error->errmess);
ro_warn_user("WimpError", error->errmess);
}
}
/**
* Start a RISC OS drag event to reflect on screen what is happening
* during the core tree drag.
*
* \param ro_cw The RO corewindow to which the drag is attached.
* \param pointer The RO pointer event data block starting the drag.
* \param state The RO window state block for the treeview window.
*/
static void
ro_cw_drag_start(struct ro_corewindow *ro_cw,
wimp_pointer *pointer,
wimp_window_state *state)
{
os_error *error;
wimp_drag drag;
wimp_auto_scroll_info auto_scroll;
drag.w = ro_cw->wh;
drag.bbox.x0 = state->visible.x0;
drag.bbox.y0 = state->visible.y0;
drag.bbox.x1 = state->visible.x1;
drag.bbox.y1 = state->visible.y1 - ro_toolbar_height(ro_cw->toolbar) - 2;
switch (ro_cw->drag_status) {
case CORE_WINDOW_DRAG_SELECTION:
drag.type = wimp_DRAG_USER_RUBBER;
drag.initial.x0 = pointer->pos.x;
drag.initial.y0 = pointer->pos.y;
drag.initial.x1 = pointer->pos.x;
drag.initial.y1 = pointer->pos.y;
break;
case CORE_WINDOW_DRAG_MOVE:
drag.type = wimp_DRAG_USER_POINT;
drag.initial.x0 = pointer->pos.x - 4;
drag.initial.y0 = pointer->pos.y - 48;
drag.initial.x1 = pointer->pos.x + 48;
drag.initial.y1 = pointer->pos.y + 4;
break;
default:
/* No other drag types are supported. */
break;
}
LOG("Drag start...");
error = xwimp_drag_box_with_flags(&drag,
wimp_DRAG_BOX_KEEP_IN_LINE | wimp_DRAG_BOX_CLIP);
if (error) {
LOG("xwimp_drag_box: 0x%x: %s", error->errnum, error->errmess);
ro_warn_user("WimpError", error->errmess);
} else {
auto_scroll.w = ro_cw->wh;
auto_scroll.pause_zone_sizes.x0 = 80;
auto_scroll.pause_zone_sizes.y0 = 80;
auto_scroll.pause_zone_sizes.x1 = 80;
auto_scroll.pause_zone_sizes.y1 = 80 + ro_toolbar_height(ro_cw->toolbar);
auto_scroll.pause_duration = 0;
auto_scroll.state_change = (void *) 1;
error = xwimp_auto_scroll(wimp_AUTO_SCROLL_ENABLE_VERTICAL,
&auto_scroll, NULL);
if (error) {
LOG("xwimp_auto_scroll: 0x%x: %s", error->errnum, error->errmess);
ro_warn_user("WimpError", error->errmess);
}
ro_mouse_drag_start(ro_cw_drag_end, ro_cw_mouse_at, NULL, NULL);
}
}
/**
* Wimp callback on pointer entering window.
*
* The wimp has issued an event to the window because the pointer has
* entered it.
*
* \param open The open event to be processed
*/
static void ro_cw_pointer_entering(wimp_entering *entering)
{
ro_mouse_track_start(NULL, ro_cw_mouse_at, NULL);
}
/**
* Wimp callback on window open event.
*
* The wimp has issued an event to the window because an attempt has
* been made to open or resize it. This requires the new dimensions to
* be calculated and set within the wimp.
*
* \param open The open event to be processed
*/
static void ro_cw_open(wimp_open *open)
{
struct ro_corewindow *ro_cw;
ro_cw = (struct ro_corewindow *)ro_gui_wimp_event_get_user_data(open->w);
update_scrollbars(ro_cw, open);
}
static bool ro_cw_mouse_click(wimp_pointer *pointer)
{
os_error *error;
wimp_window_state state;
int xpos, ypos;
browser_mouse_state mouse;
bool handled = false;
struct ro_corewindow *ro_cw;
ro_cw = (struct ro_corewindow *)ro_gui_wimp_event_get_user_data(pointer->w);
LOG("RO corewindow context %p", ro_cw);
state.w = ro_cw->wh;
error = xwimp_get_window_state(&state);
if (error) {
LOG("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess);
return false;
}
/* Convert the returned mouse coordinates into NetSurf's internal
* units.
*/
xpos = ((pointer->pos.x - state.visible.x0) + state.xscroll) / 2;
ypos = ((state.visible.y1 - pointer->pos.y) -
state.yscroll + ro_cw->origin_y) / 2;
if (pointer->buttons != wimp_CLICK_MENU) {
mouse = ro_gui_mouse_click_state(pointer->buttons,
wimp_BUTTON_DOUBLE_CLICK_DRAG);
/* Give the window input focus on Select-clicks. This wouldn't
* be necessary if the core used the RISC OS caret.
*/
if (mouse & BROWSER_MOUSE_CLICK_1) {
xwimp_set_caret_position(ro_cw->wh,
-1, -100, -100, 32, -1);
}
}
/* call the mouse callback */
if (mouse != 0) {
ro_cw->mouse(ro_cw, mouse, xpos, ypos);
/* If it's a visible drag, start the RO side of the visible
* effects.
*/
if ((ro_cw->drag_status == CORE_WINDOW_DRAG_SELECTION) ||
(ro_cw->drag_status == CORE_WINDOW_DRAG_MOVE)) {
ro_cw_drag_start(ro_cw, pointer, &state);
}
ro_cw->toolbar_update(ro_cw);
}
/* Special actions for some mouse buttons. Adjust closes the dialog;
* Menu opens a menu. For the latter, we assume that the owning module
* will have attached a window menu to our parent window with the auto
* flag unset (so that we can fudge the selection above). If it hasn't,
* the call will quietly fail.
*
* \TODO -- Adjust-click close isn't a perfect copy of what the RO
* version did: adjust clicks anywhere close the tree, and
* selections persist.
*/
switch(pointer->buttons) {
case wimp_CLICK_ADJUST:
if (handled) {
ro_gui_dialog_close(ro_cw->wh);
}
break;
case wimp_CLICK_MENU:
ro_gui_wimp_event_process_window_menu_click(pointer);
break;
}
return true;
}
static bool ro_cw_keypress(wimp_key *key)
{
uint32_t c;
struct ro_corewindow *ro_cw;
nserror res;
ro_cw = (struct ro_corewindow *)ro_gui_wimp_event_get_user_data(key->w);
LOG("RO corewindow context %p", ro_cw);
c = (uint32_t) key->c;
if ((unsigned)c < 0x20 ||
(0x7f <= c && c <= 0x9f) ||
(c & IS_WIMP_KEY)) {
/* Munge control keys into unused control chars */
/* We can't map onto 1->26 (reserved for ctrl+<qwerty>
That leaves 27->31 and 128->159 */
switch (c & ~IS_WIMP_KEY) {
case wimp_KEY_TAB:
c = 9;
break;
case wimp_KEY_SHIFT | wimp_KEY_TAB:
c = 11;
break;
/* cursor movement keys */
case wimp_KEY_HOME:
case wimp_KEY_CONTROL | wimp_KEY_LEFT:
c = NS_KEY_LINE_START;
break;
case wimp_KEY_END:
if (os_version >= RISCOS5)
c = NS_KEY_LINE_END;
else
c = NS_KEY_DELETE_RIGHT;
break;
case wimp_KEY_CONTROL | wimp_KEY_RIGHT:
c = NS_KEY_LINE_END;
break;
case wimp_KEY_CONTROL | wimp_KEY_UP:
c = NS_KEY_TEXT_START;
break;
case wimp_KEY_CONTROL | wimp_KEY_DOWN:
c = NS_KEY_TEXT_END;
break;
case wimp_KEY_SHIFT | wimp_KEY_LEFT:
c = NS_KEY_WORD_LEFT;
break;
case wimp_KEY_SHIFT | wimp_KEY_RIGHT:
c = NS_KEY_WORD_RIGHT;
break;
case wimp_KEY_SHIFT | wimp_KEY_UP:
c = NS_KEY_PAGE_UP;
break;
case wimp_KEY_SHIFT | wimp_KEY_DOWN:
c = NS_KEY_PAGE_DOWN;
break;
case wimp_KEY_LEFT:
c = NS_KEY_LEFT;
break;
case wimp_KEY_RIGHT:
c = NS_KEY_RIGHT;
break;
case wimp_KEY_UP:
c = NS_KEY_UP;
break;
case wimp_KEY_DOWN:
c = NS_KEY_DOWN;
break;
/* editing */
case wimp_KEY_CONTROL | wimp_KEY_END:
c = NS_KEY_DELETE_LINE_END;
break;
case wimp_KEY_DELETE:
if (ro_gui_ctrl_pressed())
c = NS_KEY_DELETE_LINE_START;
else if (os_version < RISCOS5)
c = NS_KEY_DELETE_LEFT;
break;
default:
break;
}
}
if (!(c & IS_WIMP_KEY)) {
res = ro_cw->key(ro_cw, c);
if (res == NSERROR_OK) {
ro_cw->toolbar_update(ro_cw);
return true;
}
}
return false;
}
/**
* Update a corewindow toolbar to a new size.
*
* \param ctx Context as passed to toolbar creation.
*/
static void cw_tb_size(void *ctx)
{
struct ro_corewindow *ro_cw;
wimp_window_state state;
os_error *error;
ro_cw = (struct ro_corewindow *)ctx;
ro_cw->origin_y = -(ro_toolbar_height(ro_cw->toolbar));
state.w = ro_cw->wh;
error = xwimp_get_window_state(&state);
if (error) {
LOG("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess);
return;
}
error = xwimp_force_redraw(ro_cw->wh,
0, state.visible.y0 - state.visible.y1,
state.visible.x1 - state.visible.x0, 0);
if (error) {
LOG("xwimp_force_redraw: 0x%x: %s",
error->errnum, error->errmess);
return;
}
}
/**
* Update a corewindow toolbar to use a new theme.
*
* \param ctx Context as passed to toolbar creation.
* \param exists true if the bar still exists; else false.
*/
static void cw_tb_theme(void *ctx, bool exists)
{
if (exists) {
cw_tb_size(ctx);
}
}
/**
* Allow a corewindow toolbar button state to be updated.
*
* \param ctx Context as passed to toolbar creation.
*/
static void cw_tb_update(void *ctx)
{
struct ro_corewindow *ro_cw;
ro_cw = (struct ro_corewindow *)ctx;
ro_cw->toolbar_update(ro_cw);
}
/**
* Respond to user actions (click) in a corewindow.
*
* \param ctx Context as passed to toolbar creation.
*/
static void
cw_tb_click(void *ctx,
toolbar_action_type action_type,
union toolbar_action action)
{
struct ro_corewindow *ro_cw;
ro_cw = (struct ro_corewindow *)ctx;
if (action_type == TOOLBAR_ACTION_BUTTON) {
ro_cw->toolbar_click(ro_cw, action.button);
ro_cw->toolbar_update(ro_cw);
}
}
/**
* Save positions of core window toolbar buttons.
*
* \param ctx Context as passed to toolbar creation.
* \param config The new button config string.
*/
static void cw_tb_save(void *ctx, char *config)
{
struct ro_corewindow *ro_cw;
ro_cw = (struct ro_corewindow *)ctx;
ro_cw->toolbar_save(ro_cw, config);
}
/** core window toolbar callbacks */
static const struct toolbar_callbacks corewindow_toolbar_callbacks = {
.theme_update = cw_tb_theme,
.change_size = cw_tb_size,
.update_buttons = cw_tb_update,
.user_action = cw_tb_click,
.save_buttons = cw_tb_save,
};
/**
* callback from core to request a redraw.
*/
static void
ro_cw_redraw_request(struct core_window *cw, const struct rect *r)
{
struct ro_corewindow *ro_cw = (struct ro_corewindow *)cw;
os_error *error;
error = xwimp_force_redraw(ro_cw->wh,
(2 * r->x0),
(-2 * (r->y0 + (r->y1 - r->y0))) + ro_cw->origin_y,
(2 * (r->x0 + (r->x1 - r->x0))),
(-2 * r->y0) + ro_cw->origin_y);
if (error) {
LOG("xwimp_force_redraw: 0x%x: %s",
error->errnum, error->errmess);
}
}
/**
* Callback from the core to update the content area size.
*/
static void
ro_cw_update_size(struct core_window *cw, int width, int height)
{
struct ro_corewindow *ro_cw = (struct ro_corewindow *)cw;
wimp_open open;
wimp_window_state state;
os_error *error;
LOG("content resize from w:%d h:%d to w:%d h:%d",
ro_cw->content_width, ro_cw->content_height, width, height);
ro_cw->content_width = width;
ro_cw->content_height = -(2 * height);
state.w = ro_cw->wh;
error = xwimp_get_window_state(&state);
if (error) {
LOG("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess);
return;
}
open.w = ro_cw->wh;
open.visible = state.visible;
open.xscroll = state.xscroll;
open.yscroll = state.yscroll;
open.next = state.next;
update_scrollbars(ro_cw, &open);
}
/**
* Callback from the core to scroll the visible content.
*/
static void
ro_cw_scroll_visible(struct core_window *cw, const struct rect *r)
{
//struct ro_corewindow *ro_cw = (struct ro_corewindow *)cw;
}
/**
* Callback from the core to obtain the window viewport dimensions
*
* \param[in] cw the core window object
* \param[out] width to be set to viewport width in px
* \param[out] height to be set to viewport height in px
*/
static void
ro_cw_get_window_dimensions(struct core_window *cw, int *width, int *height)
{
struct ro_corewindow *ro_cw = (struct ro_corewindow *)cw;
os_error *error;
wimp_window_state state;
state.w = ro_cw->wh;
error = xwimp_get_window_state(&state);
if (error) {
LOG("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess);
return;
}
*width = (state.visible.x1 - state.visible.x0) / 2;
*height = (state.visible.y1 - state.visible.y0) / 2;
}
/**
* Callback from the core to update the drag status.
*/
static void
ro_cw_drag_status(struct core_window *cw, core_window_drag_status ds)
{
struct ro_corewindow *ro_cw = (struct ro_corewindow *)cw;
ro_cw->drag_status = ds;
}
struct core_window_callback_table ro_cw_cb_table = {
.redraw_request = ro_cw_redraw_request,
.update_size = ro_cw_update_size,
.scroll_visible = ro_cw_scroll_visible,
.get_window_dimensions = ro_cw_get_window_dimensions,
.drag_status = ro_cw_drag_status
};
/**
* dummy toolbar click callback
*
*/
static nserror dummy_toolbar_click(struct ro_corewindow *ro_cw, button_bar_action action)
{
return NSERROR_OK;
}
/**
* dummy toolbar update callback
*/
static nserror dummy_toolbar_update(struct ro_corewindow *ro_cw)
{
return NSERROR_OK;
}
/**
* dummy toolbar save callback
*/
static nserror dummy_toolbar_save(struct ro_corewindow *ro_cw, char *config)
{
return NSERROR_OK;
}
/* exported function documented ro/corewindow.h */
nserror
ro_corewindow_init(struct ro_corewindow *ro_cw,
const struct button_bar_buttons *tb_buttons,
char *tb_order,
theme_style tb_style,
const char *tb_help)
{
/* setup the core window callback table */
ro_cw->cb_table = &ro_cw_cb_table;
/* start with the content area being as small as possible */
ro_cw->content_width = -1;
ro_cw->content_height = -1;
ro_cw->origin_y = 0; /* no offset */
ro_cw->drag_status = CORE_WINDOW_DRAG_NONE; /* no drag */
/* Create toolbar. */
if (tb_buttons != NULL) {
/* ensure toolbar callbacks are always valid so calls
* do not have to be conditional
*/
if (ro_cw->toolbar_click == NULL) {
ro_cw->toolbar_click = dummy_toolbar_click;
}
if (ro_cw->toolbar_save == NULL) {
ro_cw->toolbar_save = dummy_toolbar_save;
}
if (ro_cw->toolbar_update == NULL) {
ro_cw->toolbar_update = dummy_toolbar_update;
}
ro_cw->toolbar = ro_toolbar_create(NULL,
ro_cw->wh,
tb_style,
TOOLBAR_FLAGS_NONE,
&corewindow_toolbar_callbacks,
ro_cw,
tb_help);
if (ro_cw->toolbar == NULL) {
return NSERROR_INIT_FAILED;
}
ro_toolbar_add_buttons(ro_cw->toolbar, tb_buttons, tb_order);
ro_toolbar_rebuild(ro_cw->toolbar);
ro_cw->origin_y = -(ro_toolbar_height(ro_cw->toolbar));
} else {
ro_cw->toolbar = NULL; /* no toolbar */
/* ensure callback functions are set to defaults when
* no toolbar
*/
ro_cw->toolbar_click = dummy_toolbar_click;
ro_cw->toolbar_save = dummy_toolbar_save;
ro_cw->toolbar_update = dummy_toolbar_update;
}
/* setup context for event handlers */
ro_gui_wimp_event_set_user_data(ro_cw->wh, ro_cw);
/* register wimp events. */
ro_gui_wimp_event_register_redraw_window(ro_cw->wh,
ro_cw_redraw);
ro_gui_wimp_event_register_scroll_window(ro_cw->wh,
ro_cw_scroll);
ro_gui_wimp_event_register_pointer_entering_window(ro_cw->wh,
ro_cw_pointer_entering);
ro_gui_wimp_event_register_open_window(ro_cw->wh,
ro_cw_open);
ro_gui_wimp_event_register_mouse_click(ro_cw->wh,
ro_cw_mouse_click);
ro_gui_wimp_event_register_keypress(ro_cw->wh,
ro_cw_keypress);
return NSERROR_OK;
}
/* exported interface documented in ro/corewindow.h */
nserror ro_corewindow_fini(struct ro_corewindow *ro_cw)
{
ro_gui_wimp_event_finalise(ro_cw->wh);
/** \todo need to consider freeing of toolbar */
return NSERROR_OK;
}

139
frontends/riscos/corewindow.h Normal file
View File

@ -0,0 +1,139 @@
/*
* Copyright 2016 Vincent Sanders <vince@netsurf-browser.org>
*
* 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
* RISC OS core window interface
*
* This module is an object that must be encapsulated. Client users
* should embed a struct ro_corewindow at the beginning of their
* context for this display surface, fill in relevant data and then
* call ro_corewindow_init()
*/
#ifndef NETSURF_RISCOS_COREWINDOW_H
#define NETSURF_RISCOS_COREWINDOW_H
#include "netsurf/core_window.h"
/**
* ro core window state
*/
struct ro_corewindow {
/** window handle */
wimp_w wh;
/** toolbar */
struct toolbar *toolbar;
/** content plot origin y relative to window */
int origin_y;
/** content width */
int content_width;
/** content height */
int content_height;
/** drag status set by core */
core_window_drag_status drag_status;
/** table of callbacks for core window operations */
struct core_window_callback_table *cb_table;
/**
* callback to draw on drawable area of ro core window
*
* \param ro_cw The riscos core window structure.
* \param originx The risc os plotter x origin.
* \param originy The risc os plotter y origin.
* \param r The rectangle of the window that needs updating.
* \return NSERROR_OK on success otherwise apropriate error code
*/
nserror (*draw)(struct ro_corewindow *ro_cw, int originx, int originy, struct rect *r);
/**
* callback for keypress on ro core window
*
* \param ro_cw The ro core window structure.
* \param nskey The netsurf key code.
* \return NSERROR_OK if key processed,
* NSERROR_NOT_IMPLEMENTED if key not processed
* otherwise apropriate error code
*/
nserror (*key)(struct ro_corewindow *ro_cw, uint32_t nskey);
/**
* callback for mouse event on ro core window
*
* \param ro_cw The ro core window structure.
* \param mouse_state mouse state
* \param x location of event
* \param y location of event
* \return NSERROR_OK on sucess otherwise apropriate error code.
*/
nserror (*mouse)(struct ro_corewindow *ro_cw, browser_mouse_state mouse_state, int x, int y);
/**
* callback for clicks in ro core window toolbar.
*
* \param ro_cw The ro core window structure.
* \param action The button bar action.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
nserror (*toolbar_click)(struct ro_corewindow *ro_cw, button_bar_action action);
/**
* callback for updating state of buttons in ro core window toolbar.
*
* \param ro_cw The ro core window structure.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
nserror (*toolbar_update)(struct ro_corewindow *ro_cw);
/**
* callback for saving ro core window toolbar state.
*
* \param ro_cw The ro core window structure.
* \param config The new toolbar configuration.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
nserror (*toolbar_save)(struct ro_corewindow *ro_cw, char *config);
};
/**
* initialise elements of riscos core window.
*
* As a pre-requisite the draw, key and mouse callbacks must be defined
*
* \param ro_cw A riscos core window structure to initialise
* \return NSERROR_OK on successful initialisation otherwise error code.
*/
nserror ro_corewindow_init(struct ro_corewindow *ro_cw, const struct button_bar_buttons *tb_buttons, char *tb_order, theme_style tb_style, const char *tb_help);
/**
* finalise elements of ro core window.
*
* \param ro_cw A riscos core window structure to initialise
* \return NSERROR_OK on successful finalisation otherwise error code.
*/
nserror ro_corewindow_fini(struct ro_corewindow *ro_cw);
#endif

8
frontends/riscos/dialog.c
View File

@ -181,16 +181,16 @@ void ro_gui_dialog_init(void)
*/
/* certificate verification window */
ro_gui_cert_preinitialise();
ro_gui_cert_initialise();
/* hotlist window */
ro_gui_hotlist_preinitialise();
ro_gui_hotlist_initialise();
/* global history window */
ro_gui_global_history_preinitialise();
ro_gui_global_history_initialise();
/* cookies window */
ro_gui_cookies_preinitialise();
ro_gui_cookies_initialise();
}

586
frontends/riscos/global_history.c
View File

@ -1,6 +1,6 @@
/*
* Copyright 2005 Richard Wilson <info@tinct.net>
* Copyright 2010 Stephen Fryatt <stevef@netsurf-browser.org>
* Copyright 2016 Vincent Sanders <vince@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
@ -19,183 +19,122 @@
/**
* \file
* Global history implementation for RISC OS.
* Implementation of RISC OS global history.
*/
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "oslib/wimp.h"
#include "oslib/wimpspriteop.h"
#include <oslib/wimp.h>
#include "utils/nsoption.h"
#include "utils/messages.h"
#include "utils/log.h"
#include "netsurf/window.h"
#include "netsurf/plotters.h"
#include "netsurf/keypress.h"
#include "desktop/global_history.h"
#include "desktop/tree.h"
#include "riscos/dialog.h"
#include "riscos/global_history.h"
#include "riscos/gui.h"
#include "riscos/menus.h"
#include "riscos/save.h"
#include "riscos/toolbar.h"
#include "riscos/treeview.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"
#include "riscos/corewindow.h"
#include "riscos/global_history.h"
static void ro_gui_global_history_toolbar_update_buttons(void);
static void ro_gui_global_history_toolbar_save_buttons(char *config);
static bool ro_gui_global_history_menu_prepare(wimp_w w, wimp_i i,
wimp_menu *menu, wimp_pointer *pointer);
static void ro_gui_global_history_menu_warning(wimp_w w, wimp_i i,
wimp_menu *menu, wimp_selection *selection, menu_action action);
static bool ro_gui_global_history_menu_select(wimp_w w, wimp_i i,
wimp_menu *menu, wimp_selection *selection, menu_action action);
static void ro_gui_global_history_toolbar_click(button_bar_action action);
struct ro_treeview_callbacks ro_global_history_treeview_callbacks = {
ro_gui_global_history_toolbar_click,
ro_gui_global_history_toolbar_update_buttons,
ro_gui_global_history_toolbar_save_buttons
struct ro_global_history_window {
struct ro_corewindow core;
wimp_menu *menu;
};
/* The RISC OS global history window, toolbar and treeview data */
/** global_history window is a singleton */
static struct ro_global_history_window *global_history_window = NULL;
/** riscos template for global_history window */
static wimp_window *dialog_global_history_template;
static struct ro_global_history_window {
wimp_w window;
struct toolbar *toolbar;
ro_treeview *tv;
wimp_menu *menu;
} global_history_window;
/**
* Pre-Initialise the global history tree. This is called for things that
* need to be done at the gui_init() stage, such as loading templates.
*/
void ro_gui_global_history_preinitialise(void)
{
/* Create our window. */
global_history_window.window = ro_gui_dialog_create("tree");
ro_gui_set_window_title(global_history_window.window,
messages_get("GlobalHistory"));
}
/**
* Initialise global history tree, at the gui_init2() stage.
*/
void ro_gui_global_history_postinitialise(void)
{
/* Create our toolbar. */
global_history_window.toolbar = ro_toolbar_create(NULL,
global_history_window.window,
THEME_STYLE_GLOBAL_HISTORY_TOOLBAR, TOOLBAR_FLAGS_NONE,
ro_treeview_get_toolbar_callbacks(), NULL,
"HelpGHistoryToolbar");
if (global_history_window.toolbar != NULL) {
ro_toolbar_add_buttons(global_history_window.toolbar,
global_history_toolbar_buttons,
nsoption_charp(toolbar_history));
ro_toolbar_rebuild(global_history_window.toolbar);
}
/* Create the treeview with the window and toolbar. */
global_history_window.tv =
ro_treeview_create(global_history_window.window,
global_history_window.toolbar,
&ro_global_history_treeview_callbacks,
TREE_HISTORY);
if (global_history_window.tv == NULL) {
LOG("Failed to allocate treeview");
return;
}
ro_toolbar_update_client_data(global_history_window.toolbar,
global_history_window.tv);
/* Build the global history window menu. */
static const struct ns_menu 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_window.menu = ro_gui_menu_define_menu(
&global_history_definition);
ro_gui_wimp_event_register_menu(global_history_window.window,
global_history_window.menu, false, false);
ro_gui_wimp_event_register_menu_prepare(global_history_window.window,
ro_gui_global_history_menu_prepare);
ro_gui_wimp_event_register_menu_selection(global_history_window.window,
ro_gui_global_history_menu_select);
ro_gui_wimp_event_register_menu_warning(global_history_window.window,
ro_gui_global_history_menu_warning);
}
/**
* Destroy the global history window.
*/
void ro_gui_global_history_destroy(void)
{
if (global_history_window.tv == NULL)
return;
ro_treeview_destroy(global_history_window.tv);
}
/**
* Open the global history window.
*/
void ro_gui_global_history_open(void)
{
ro_gui_global_history_toolbar_update_buttons();
if (!ro_gui_dialog_open_top(global_history_window.window,
global_history_window.toolbar, 600, 800)) {
ro_treeview_set_origin(global_history_window.tv, 0,
-(ro_toolbar_height(
global_history_window.toolbar)));
}
}
/**
* Handle toolbar button clicks.
* callback to draw on drawable area of ro global_history window
*
* \param action The action to handle
* \param ro_cw The riscos core window structure.
* \param r The rectangle of the window that needs updating.
* \param originx The risc os plotter x origin.
* \param originy The risc os plotter y origin.
* \return NSERROR_OK on success otherwise apropriate error code
*/
static nserror
global_history_draw(struct ro_corewindow *ro_cw,
int originx,
int originy,
struct rect *r)
{
struct redraw_context ctx = {
.interactive = true,
.background_images = true,
.plot = &ro_plotters
};
void ro_gui_global_history_toolbar_click(button_bar_action action)
ro_plot_origin_x = originx;
ro_plot_origin_y = originy;
no_font_blending = true;
global_history_redraw(0, 0, r, &ctx);
no_font_blending = false;
return NSERROR_OK;
}
/**
* callback for keypress on ro coookie window
*
* \param ro_cw The ro core window structure.
* \param nskey The netsurf key code.
* \return NSERROR_OK if key processed,
* NSERROR_NOT_IMPLEMENTED if key not processed
* otherwise apropriate error code
*/
static nserror global_history_key(struct ro_corewindow *ro_cw, uint32_t nskey)
{
if (global_history_keypress(nskey)) {
return NSERROR_OK;
}
return NSERROR_NOT_IMPLEMENTED;
}
/**
* callback for mouse event on ro global_history window
*
* \param ro_cw The ro core window structure.
* \param mouse_state mouse state
* \param x location of event
* \param y location of event
* \return NSERROR_OK on sucess otherwise apropriate error code.
*/
static nserror
global_history_mouse(struct ro_corewindow *ro_cw,
browser_mouse_state mouse_state,
int x, int y)
{
global_history_mouse_action(mouse_state, x, y);
return NSERROR_OK;
}
/**
* handle clicks in ro core window toolbar.
*
* \param ro_cw The ro core window structure.
* \param action The button bar action.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
static nserror
global_history_toolbar_click(struct ro_corewindow *ro_cw,
button_bar_action action)
{
switch (action) {
case TOOLBAR_BUTTON_DELETE:
@ -225,156 +164,194 @@ void ro_gui_global_history_toolbar_click(button_bar_action action)
default:
break;
}
return NSERROR_OK;
}
/**
* Update the button state in the global history toolbar.
* Handle updating state of buttons in ro core window toolbar.
*
* \param ro_cw The ro core window structure.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
void ro_gui_global_history_toolbar_update_buttons(void)
static nserror global_history_toolbar_update(struct ro_corewindow *ro_cw)
{
ro_toolbar_set_button_shaded_state(global_history_window.toolbar,
ro_toolbar_set_button_shaded_state(ro_cw->toolbar,
TOOLBAR_BUTTON_DELETE,
!global_history_has_selection());
ro_toolbar_set_button_shaded_state(global_history_window.toolbar,
ro_toolbar_set_button_shaded_state(ro_cw->toolbar,
TOOLBAR_BUTTON_LAUNCH,
!global_history_has_selection());
return NSERROR_OK;
}
/**
* Save a new button arrangement in the global history toolbar.
* callback for saving of toolbar state in ro global history window
*
* \param *config The new button configuration string.
* \param ro_cw The ro core window structure.
* \param config The new toolbar configuration.
* \return NSERROR_OK if config saved, otherwise apropriate error code
*/
void ro_gui_global_history_toolbar_save_buttons(char *config)
static nserror
global_history_toolbar_save(struct ro_corewindow *ro_cw, char *config)
{
nsoption_set_charp(toolbar_history, config);
ro_gui_save_options();
return NSERROR_OK;
}
/**
* Prepare the global history menu for opening
* Prepare the global_history menu for display
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param *menu The menu about to be opened.
* \param *pointer Pointer to the relevant wimp event block, or
* NULL for an Adjust click.
* \return true if the event was handled; else false.
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param menu The menu from which the selection was made.
* \param pointer The pointer shape
* \return true if action accepted; else false.
*/
bool ro_gui_global_history_menu_prepare(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_pointer *pointer)
static bool
global_history_menu_prepare(wimp_w w,
wimp_i i,
wimp_menu *menu,
wimp_pointer *pointer)
{
bool selection;
struct ro_global_history_window *global_historyw;
if (menu != global_history_window.menu)
global_historyw = (struct ro_global_history_window *)ro_gui_wimp_event_get_user_data(w);
if ((global_historyw == NULL) ||
(menu != global_historyw->menu)) {
return false;
}
selection = global_history_has_selection();
ro_gui_menu_set_entry_shaded(global_history_window.menu,
TREE_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(global_history_window.menu,
TREE_CLEAR_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(menu, TREE_SELECTION, !selection);
ro_gui_menu_set_entry_shaded(menu, TREE_CLEAR_SELECTION, !selection);
ro_gui_save_prepare(GUI_SAVE_HISTORY_EXPORT_HTML,
NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL);
ro_gui_menu_set_entry_shaded(menu, TOOLBAR_BUTTONS,
ro_toolbar_menu_option_shade(
global_history_window.toolbar));
ro_toolbar_menu_option_shade(global_historyw->core.toolbar));
ro_gui_menu_set_entry_ticked(menu, TOOLBAR_BUTTONS,
ro_toolbar_menu_buttons_tick(
global_history_window.toolbar));
ro_toolbar_menu_buttons_tick(global_historyw->core.toolbar));
ro_gui_menu_set_entry_shaded(menu, TOOLBAR_EDIT,
ro_toolbar_menu_edit_shade(
global_history_window.toolbar));
ro_toolbar_menu_edit_shade(global_historyw->core.toolbar));
ro_gui_menu_set_entry_ticked(menu, TOOLBAR_EDIT,
ro_toolbar_menu_edit_tick(
global_history_window.toolbar));
ro_toolbar_menu_edit_tick(global_historyw->core.toolbar));
return true;
}
/**
* Handle submenu warnings for the global_hostory menu
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param *menu The menu to which the warning applies.
* \param *selection The wimp menu selection data.
* \param action The selected menu action.
*/
void ro_gui_global_history_menu_warning(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_selection *selection, menu_action action)
/**
* Handle submenu warnings for the global_history menu
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param menu The menu to which the warning applies.
* \param selection The wimp menu selection data.
* \param action The selected menu action.
*/
static void
global_history_menu_warning(wimp_w w,
wimp_i i,
wimp_menu *menu,
wimp_selection *selection,
menu_action action)
{
/* Do nothing */
}
/**
* Handle selections from the global history menu
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param *menu The menu from which the selection was made.
* \param *selection The wimp menu selection data.
* \param action The selected menu action.
* \return true if action accepted; else false.
*/
bool ro_gui_global_history_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
wimp_selection *selection, menu_action action)
/**
* Handle selections from the global_history menu
*
* \param w The window owning the menu.
* \param i The icon owning the menu.
* \param menu The menu from which the selection was made.
* \param selection The wimp menu selection data.
* \param action The selected menu action.
* \return true if action accepted; else false.
*/
static bool
global_history_menu_select(wimp_w w,
wimp_i i,
wimp_menu *menu,
wimp_selection *selection,
menu_action action)
{
struct ro_global_history_window *global_historyw;
global_historyw = (struct ro_global_history_window *)ro_gui_wimp_event_get_user_data(w);
if ((global_historyw == NULL) ||
(menu != global_historyw->menu)) {
return false;
}
switch (action) {
case HISTORY_EXPORT:
ro_gui_dialog_open_persistent(w, dialog_saveas, true);
return true;
case TREE_EXPAND_ALL:
global_history_expand(false);
return true;
case TREE_EXPAND_FOLDERS:
global_history_expand(true);
return true;
case TREE_EXPAND_LINKS:
global_history_expand(false);
return true;
case TREE_COLLAPSE_ALL:
global_history_contract(true);
return true;
case TREE_COLLAPSE_FOLDERS:
global_history_contract(true);
return true;
case TREE_COLLAPSE_LINKS:
global_history_contract(false);
return true;
case TREE_SELECTION_LAUNCH:
global_history_keypress(NS_KEY_CR);
return true;
case TREE_SELECTION_DELETE:
global_history_keypress(NS_KEY_DELETE_LEFT);
return true;
case TREE_SELECT_ALL:
global_history_keypress(NS_KEY_SELECT_ALL);
return true;
case TREE_CLEAR_SELECTION:
global_history_keypress(NS_KEY_CLEAR_SELECTION);
return true;
case TOOLBAR_BUTTONS:
ro_toolbar_set_display_buttons(global_history_window.toolbar,
!ro_toolbar_get_display_buttons(
global_history_window.toolbar));
ro_toolbar_set_display_buttons(global_historyw->core.toolbar,
!ro_toolbar_get_display_buttons(global_historyw->core.toolbar));
return true;
case TOOLBAR_EDIT:
ro_toolbar_toggle_edit(global_history_window.toolbar);
ro_toolbar_toggle_edit(global_historyw->core.toolbar);
return true;
default:
return false;
}
@ -382,33 +359,178 @@ bool ro_gui_global_history_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
return false;
}
/**
* Check if a particular window handle is the global history window
*
* \param window the window in question
* \return true if this window is the global history
*/
bool ro_gui_global_history_check_window(wimp_w window)
/**
* Creates the window for the global_history tree.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
static nserror ro_global_history_init(void)
{
if (global_history_window.window == window)
return true;
else
return false;
struct ro_global_history_window *ncwin;
nserror res;
static const struct ns_menu global_history_menu_def = {
"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}
}
};
static const struct button_bar_buttons global_history_toolbar_buttons[] = {
{ "delete", TOOLBAR_BUTTON_DELETE, TOOLBAR_BUTTON_NONE, '0', "0"},
{ "expand", TOOLBAR_BUTTON_EXPAND, TOOLBAR_BUTTON_COLLAPSE, '1', "1"},
{ "open", TOOLBAR_BUTTON_OPEN, TOOLBAR_BUTTON_CLOSE, '2', "2"},
{ "launch", TOOLBAR_BUTTON_LAUNCH, TOOLBAR_BUTTON_NONE, '3', "3"},
{ NULL, TOOLBAR_BUTTON_NONE, TOOLBAR_BUTTON_NONE, '\0', ""}
};
if (global_history_window != NULL) {
return NSERROR_OK;
}
ncwin = malloc(sizeof(struct ro_global_history_window));
if (ncwin == NULL) {
return NSERROR_NOMEM;
}
/* create window from template */
ncwin->core.wh = wimp_create_window(dialog_global_history_template);
ro_gui_set_window_title(ncwin->core.wh, messages_get("GlobalHistory"));
/* initialise callbacks */
ncwin->core.draw = global_history_draw;
ncwin->core.key = global_history_key;
ncwin->core.mouse = global_history_mouse;
ncwin->core.toolbar_click = global_history_toolbar_click;
ncwin->core.toolbar_save = global_history_toolbar_save;
/* update is not valid untill global history is initialised */
ncwin->core.toolbar_update = NULL;
/* initialise core window */
res = ro_corewindow_init(&ncwin->core,
global_history_toolbar_buttons,
nsoption_charp(toolbar_history),
THEME_STYLE_GLOBAL_HISTORY_TOOLBAR,
"HelpGHistoryToolbar");
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
res = global_history_init(ncwin->core.cb_table,
(struct core_window *)ncwin);
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
/* setup toolbar update post global_history manager initialisation */
ncwin->core.toolbar_update = global_history_toolbar_update;
global_history_toolbar_update(&ncwin->core);
/* Build the global_history window menu. */
ncwin->menu = ro_gui_menu_define_menu(&global_history_menu_def);
ro_gui_wimp_event_register_menu(ncwin->core.wh,
ncwin->menu, false, false);
ro_gui_wimp_event_register_menu_prepare(ncwin->core.wh,
global_history_menu_prepare);
ro_gui_wimp_event_register_menu_selection(ncwin->core.wh,
global_history_menu_select);
ro_gui_wimp_event_register_menu_warning(ncwin->core.wh,
global_history_menu_warning);
/* memoise window so it can be represented when necessary
* instead of recreating every time.
*/
global_history_window = ncwin;
return NSERROR_OK;
}
/**
* Check if a particular menu handle is the global history menu
*
* \param *menu The menu in question.
* \return true if this menu is the global history menu
*/
/* exported interface documented in riscos/global_history.h */
nserror ro_gui_global_history_present(void)
{
nserror res;
res = ro_global_history_init();
if (res == NSERROR_OK) {
LOG("Presenting");
ro_gui_dialog_open_top(global_history_window->core.wh,
global_history_window->core.toolbar,
600, 800);
} else {
LOG("Failed presenting code %d", res);
}
return res;
}
/* exported interface documented in riscos/global_history.h */
void ro_gui_global_history_initialise(void)
{
dialog_global_history_template = ro_gui_dialog_load_template("tree");
}
/* exported interface documented in riscos/global_history.h */
nserror ro_gui_global_history_finalise(void)
{
nserror res;
if (global_history_window == NULL) {
return NSERROR_OK;
}
res = global_history_fini();
if (res == NSERROR_OK) {
res = ro_corewindow_fini(&global_history_window->core);
free(global_history_window);
global_history_window = NULL;
}
return res;
}
/* exported interface documented in riscos/global_history.h */
bool ro_gui_global_history_check_window(wimp_w wh)
{
if ((global_history_window != NULL) &&
(global_history_window->core.wh == wh)) {
return true;
}
return false;
}
/* exported interface documented in riscos/global_history.h */
bool ro_gui_global_history_check_menu(wimp_menu *menu)
{
if (global_history_window.menu == menu)
if ((global_history_window != NULL) &&
(global_history_window->menu == menu)) {
return true;
else
return false;
}
return false;
}

40
frontends/riscos/global_history.h
View File

@ -17,21 +17,41 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* Global history (interface).
/**
* \file
* RISc OS global history interface.
*/
#ifndef _NETSURF_RISCOS_GLOBALHISTORY_H_
#define _NETSURF_RISCOS_GLOBALHISTORY_H_
#ifndef RISCOS_GLOBALHISTORY_H
#define RISCOS_GLOBALHISTORY_H
#include "riscos/menus.h"
/**
* initialise the global history window template ready for subsequent use.
*/
void ro_gui_global_history_initialise(void);
void ro_gui_global_history_preinitialise(void);
void ro_gui_global_history_postinitialise(void);
void ro_gui_global_history_destroy(void);
void ro_gui_global_history_open(void);
void ro_gui_global_history_save(void);
/**
* make the global history window visible.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
nserror ro_gui_global_history_present(void);
/**
* Free any resources allocated for the global history window.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
nserror ro_gui_global_history_finalise(void);
/**
* check if window handle is for the global history window
*/
bool ro_gui_global_history_check_window(wimp_w window);
/**
* check if menu handle is for the global history menu
*/
bool ro_gui_global_history_check_menu(wimp_menu *menu);
#endif

18
frontends/riscos/gui.c
View File

@ -1268,18 +1268,6 @@ static nserror gui_init(int argc, char** argv)
/* Finally, check Inet$Resolvers for sanity */
ro_gui_check_resolvers();
/* certificate verification window */
ro_gui_cert_postinitialise();
/* hotlist window */
ro_gui_hotlist_postinitialise();
/* global history window */
ro_gui_global_history_postinitialise();
/* cookies window */
ro_gui_cookies_postinitialise();
open_window = nsoption_bool(open_browser_at_startup);
/* parse command-line arguments */
@ -1567,9 +1555,9 @@ static void gui_quit(void)
urldb_save_cookies(nsoption_charp(cookie_jar));
urldb_save(nsoption_charp(url_save));
ro_gui_window_quit();
ro_gui_global_history_destroy();
ro_gui_hotlist_destroy();
ro_gui_cookies_destroy();
ro_gui_global_history_finalise();
ro_gui_hotlist_finalise();
ro_gui_cookies_finalise();
ro_gui_saveas_quit();
ro_gui_url_bar_fini();
rufl_quit();

5
frontends/riscos/gui.h
View File

@ -211,11 +211,6 @@ extern int ro_plot_origin_y;
/* in theme_install.c */
bool ro_gui_theme_install_apply(wimp_w w);
/* in sslcert.c */
nserror gui_cert_verify(struct nsurl *url,
const struct ssl_cert_info *certs, unsigned long num,
nserror (*cb)(bool proceed, void *pw), void *cbpw);
/* icon numbers */
#define ICON_STATUS_RESIZE 0
#define ICON_STATUS_TEXT 1

24
frontends/riscos/gui/button_bar.h
View File

@ -95,30 +95,6 @@ static const struct button_bar_buttons brower_toolbar_buttons[] = {
{NULL, TOOLBAR_BUTTON_NONE, TOOLBAR_BUTTON_NONE, '\0', ""}
};
static const struct button_bar_buttons cookies_toolbar_buttons[] = {
{"delete", TOOLBAR_BUTTON_DELETE, TOOLBAR_BUTTON_NONE, '0', "0"},
{"expand", TOOLBAR_BUTTON_EXPAND, TOOLBAR_BUTTON_COLLAPSE, '1', "1"},
{"open", TOOLBAR_BUTTON_OPEN, TOOLBAR_BUTTON_CLOSE, '2', "2"},
{NULL, TOOLBAR_BUTTON_NONE, TOOLBAR_BUTTON_NONE, '\0', ""}
};
static const struct button_bar_buttons global_history_toolbar_buttons[] = {
{"delete", TOOLBAR_BUTTON_DELETE, TOOLBAR_BUTTON_NONE, '0', "0"},
{"expand", TOOLBAR_BUTTON_EXPAND, TOOLBAR_BUTTON_COLLAPSE, '1', "1"},
{"open", TOOLBAR_BUTTON_OPEN, TOOLBAR_BUTTON_CLOSE, '2', "2"},
{"launch", TOOLBAR_BUTTON_LAUNCH, TOOLBAR_BUTTON_NONE, '3', "3"},
{NULL, TOOLBAR_BUTTON_NONE, TOOLBAR_BUTTON_NONE, '\0', ""}
};
static const struct button_bar_buttons hotlist_toolbar_buttons[] = {
{"delete", TOOLBAR_BUTTON_DELETE, TOOLBAR_BUTTON_NONE, '0', "0"},
{"expand", TOOLBAR_BUTTON_EXPAND, TOOLBAR_BUTTON_COLLAPSE, '1', "1"},
{"open", TOOLBAR_BUTTON_OPEN, TOOLBAR_BUTTON_CLOSE, '2', "2"},
{"launch", TOOLBAR_BUTTON_LAUNCH, TOOLBAR_BUTTON_NONE, '3', "3"},
{"create", TOOLBAR_BUTTON_CREATE, TOOLBAR_BUTTON_NONE, '4', "4"},
{NULL, TOOLBAR_BUTTON_NONE, TOOLBAR_BUTTON_NONE, '\0', ""}
};
struct button_bar;

1
frontends/riscos/gui/url_bar.h
View File

@ -40,6 +40,7 @@ typedef enum {
struct url_bar;
struct hlcache_handle;
struct gui_window;
/**
* Initialise the url bar module.

8
frontends/riscos/help.c
View File

@ -21,6 +21,7 @@
*/
#include <oslib/wimp.h>
#include <oslib/help.h>
#include <oslib/taskmanager.h>
#include "utils/nsoption.h"
@ -30,7 +31,6 @@
#include "netsurf/mouse.h"
#include "netsurf/window.h"
#include "riscos/treeview.h"
#include "riscos/help.h"
#include "riscos/wimp_event.h"
#include "riscos/hotlist.h"
@ -132,16 +132,16 @@ void ro_gui_interactive_help_request(wimp_message *message)
} else if (window == wimp_ICON_BAR)
sprintf(message_token, "HelpIconbar");
else if (ro_gui_hotlist_check_window(message->data.data_xfer.w)) {
i = ro_treeview_get_help(message_data);
i = -1;
sprintf(message_token,
(i >= 0) ? "HelpTree%i" :"HelpHotlist%i", i);
} else if (ro_gui_global_history_check_window(
message->data.data_xfer.w)) {
i = ro_treeview_get_help(message_data);
i = -1;
sprintf(message_token,
(i >= 0) ? "HelpTree%i" :"HelpGHistory%i", i);
} else if (ro_gui_cookies_check_window(message->data.data_xfer.w)) {
i = ro_treeview_get_help(message_data);
i = -1;
sprintf(message_token,
(i >= 0) ? "HelpTree%i" :"HelpCookies%i", i);
} else if (ro_gui_window_lookup(window) != NULL)

913
frontends/riscos/hotlist.c
View File

File diff suppressed because it is too large Load Diff

59
frontends/riscos/hotlist.h
View File

@ -34,20 +34,65 @@
#define message_HOTLIST_CHANGED 0x4af82
#endif
#include "riscos/menus.h"
struct nsurl;
void ro_gui_hotlist_preinitialise(void);
void ro_gui_hotlist_postinitialise(void);
void ro_gui_hotlist_destroy(void);
void ro_gui_hotlist_open(void);
void ro_gui_hotlist_save(void);
/**
* initialise the hotlist window template ready for subsequent use.
*/
void ro_gui_hotlist_initialise(void);
/**
* make the cookie window visible.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
nserror ro_gui_hotlist_present(void);
/**
* Free any resources allocated for the cookie window.
*
* \return NSERROR_OK on success else appropriate error code on faliure.
*/
nserror ro_gui_hotlist_finalise(void);
bool ro_gui_hotlist_check_window(wimp_w window);
bool ro_gui_hotlist_check_menu(wimp_menu *menu);
/**
* Add a URL to the hotlist.
*
* This will be passed on to the core hotlist, then
* Message_HotlistAddURL will broadcast to any bookmark applications
* via the Hotlist Protocol.
*
* \param *url The URL to be added.
*/
void ro_gui_hotlist_add_page(struct nsurl *url);
/**
* Clean up RMA storage used by the Message_HotlistAddURL protocol.
*/
void ro_gui_hotlist_add_cleanup(void);
/**
* Remove a URL from the hotlist.
*
* This will be passed on to the core hotlist, unless we're configured
* to use external hotlists in which case we ignore it.
*
* \param *url The URL to be removed.
*/
void ro_gui_hotlist_remove_page(struct nsurl *url);
/**
* Report whether the hotlist contains a given URL.
*
* This will be passed on to the core hotlist, unless we're configured
* to use an external hotlist in which case we always report false.
*
* \param url The URL to be tested.
* \return true if the hotlist contains the URL; else false.
*/
bool ro_gui_hotlist_has_page(struct nsurl *url);
#endif

11
frontends/riscos/iconbar.c
View File

@ -150,8 +150,9 @@ bool ro_gui_iconbar_click(wimp_pointer *pointer)
case wimp_CLICK_ADJUST:
xosbyte1(osbyte_SCAN_KEYBOARD, 0 ^ 0x80, 0, &key_down);
if (key_down == 0)
ro_gui_hotlist_open();
if (key_down == 0) {
ro_gui_hotlist_present();
}
break;
}
@ -224,13 +225,13 @@ bool ro_gui_iconbar_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
ro_gui_dialog_open_persistent(NULL, dialog_openurl, true);
return true;
case HOTLIST_SHOW:
ro_gui_hotlist_open();
ro_gui_hotlist_present();
return true;
case HISTORY_SHOW_GLOBAL:
ro_gui_global_history_open();
ro_gui_global_history_present();
return true;
case COOKIES_SHOW:
ro_gui_cookies_open();
ro_gui_cookies_present();
return true;
case CHOICES_SHOW:
ro_gui_configure_show();

1
frontends/riscos/menus.c
View File

@ -51,7 +51,6 @@
#include "riscos/save.h"
#include "riscos/tinct.h"
#include "riscos/toolbar.h"
#include "riscos/treeview.h"
#include "riscos/url_suggest.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"

612
frontends/riscos/sslcert.c
View File

@ -1,6 +1,6 @@
/*
* Copyright 2006 John M Bell <jmb202@ecs.soton.ac.uk>
* Copyright 2010 Stephen Fryatt <stevef@netsurf-browser.org>
* Copyright 2016 Vincent Sanders <vince@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
@ -17,329 +17,399 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* SSL Certificate verification UI (implementation)
/**
* \file
* Implementation of RISC OS certificate verification UI.
*/
#include "utils/config.h"
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "oslib/wimp.h"
#include <oslib/wimp.h>
#include "utils/log.h"
#include "netsurf/plotters.h"
#include "desktop/sslcert_viewer.h"
#include "desktop/tree.h"
#include "riscos/dialog.h"
#include "riscos/sslcert.h"
#include "riscos/textarea.h"
#include "riscos/treeview.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"
#include "riscos/wimputils.h"
#include "riscos/gui.h"
#include "riscos/toolbar.h"
#include "riscos/corewindow.h"
#include "riscos/sslcert.h"
/* widget ID */
#define ICON_SSL_PANE 1
#define ICON_SSL_REJECT 3
#define ICON_SSL_ACCEPT 4
static wimp_window *ro_gui_cert_dialog_template;
static wimp_window *ro_gui_cert_tree_template;
/**
* RISC OS certificate viewer context.
*/
struct ro_cert_window {
struct ro_corewindow core;
/** certificate view window handle */
wimp_w wh;
/** SSL certificate viewer context data */
struct sslcert_session_data *ssl_data;
struct ro_sslcert
{
wimp_w window;
wimp_w pane;
ro_treeview *tv;
struct sslcert_session_data *data;
};
static void ro_gui_cert_accept(wimp_pointer *pointer);
static void ro_gui_cert_reject(wimp_pointer *pointer);
static void ro_gui_cert_close_window(wimp_w w);
static void ro_gui_cert_release_window(struct ro_sslcert *s);
/** riscos dialog template for certificate viewer window. */
static wimp_window *dialog_cert_template;
/** riscos template for certificate tree pane. */
static wimp_window *cert_tree_template;
/**
* Load and initialise the certificate window template
*/
void ro_gui_cert_preinitialise(void)
{
/* Load templates for the SSL windows and adjust the tree window
* flags to suit.
*/
ro_gui_cert_dialog_template = ro_gui_dialog_load_template("sslcert");
ro_gui_cert_tree_template = ro_gui_dialog_load_template("tree");
ro_gui_cert_tree_template->flags &= ~(wimp_WINDOW_MOVEABLE |
wimp_WINDOW_BACK_ICON |
wimp_WINDOW_CLOSE_ICON |
wimp_WINDOW_TITLE_ICON |
wimp_WINDOW_SIZE_ICON |
wimp_WINDOW_TOGGLE_ICON);
}
/**
* Load and initialise the certificate window template
*/
void ro_gui_cert_postinitialise(void)
{
/* Initialise the SSL module. */
}
/**
* Prompt the user to verify a certificate with issuse.
* Handle closing of the RISC OS certificate verification dialog
*
* \param url The URL being verified.
* \param certs The certificate to be verified
* \param num The number of certificates to be verified.
* \param cb Callback upon user decision.
* \param cbpw Context pointer passed to cb
* Deleting wimp windows, freeing up the core window and ssl data block.
*
* \param certw The context associated with the dialogue.
*/
nserror gui_cert_verify(nsurl *url,
const struct ssl_cert_info *certs, unsigned long num,
nserror (*cb)(bool proceed, void *pw), void *cbpw)
static void ro_gui_cert_release_window(struct ro_cert_window *certw)
{
struct ro_sslcert *sslcert_window;
wimp_window_state state;
wimp_icon_state istate;
wimp_window_info info;
os_error *error;
bool set_extent;
os_error *error;
assert(certs);
ro_gui_wimp_event_finalise(certw->wh);
sslcert_window = malloc(sizeof(struct ro_sslcert));
if (sslcert_window == NULL) {
LOG("Failed to allocate memory for SSL Cert Dialog");
return NSERROR_NOMEM;
sslcert_viewer_fini(certw->ssl_data);
ro_corewindow_fini(&certw->core);
error = xwimp_delete_window(certw->wh);
if (error) {
LOG("xwimp_delete_window: 0x%x:%s",
error->errnum, error->errmess);
}
/* Create the SSL window and its pane. */
error = xwimp_create_window(ro_gui_cert_dialog_template,
&(sslcert_window->window));
error = xwimp_delete_window(certw->core.wh);
if (error) {
LOG("xwimp_create_window: 0x%x: %s", error->errnum, error->errmess);
free(sslcert_window);
LOG("xwimp_delete_window: 0x%x:%s",
error->errnum, error->errmess);
}
free(certw);
}
/**
* Handle acceptance of certificate via event callback.
*
* \param pointer The wimp pointer event.
*/
static void ro_gui_cert_accept(wimp_pointer *pointer)
{
struct ro_cert_window *certw;
certw = (struct ro_cert_window *)ro_gui_wimp_event_get_user_data(pointer->w);
sslcert_viewer_accept(certw->ssl_data);
ro_gui_dialog_close(certw->wh);
ro_gui_cert_release_window(certw);
}
/**
* Handle rejection of certificate via event callback.
*
* \param pointer The wimp pointer block.
*/
static void ro_gui_cert_reject(wimp_pointer *pointer)
{
struct ro_cert_window *certw;
certw = (struct ro_cert_window *)ro_gui_wimp_event_get_user_data(pointer->w);
sslcert_viewer_reject(certw->ssl_data);
ro_gui_dialog_close(certw->wh);
ro_gui_cert_release_window(certw);
}
/**
* Callback to handle the closure of the SSL dialogue by other means.
*
* \param w The window handle being closed.
*/
static void ro_gui_cert_close_window(wimp_w w)
{
struct ro_cert_window *certw;
certw = (struct ro_cert_window *)ro_gui_wimp_event_get_user_data(w);
ro_gui_cert_release_window(certw);
}
/**
* Attach tree window as a pane to ssl window.
*
* Nest the tree window inside the pane window. To do this, we:
* - Get the current pane extent,
* - Get the parent window position and the location of the pane-
* locating icon inside it,
* - Set the visible area of the pane to suit,
* - Check that the pane extents are OK for this visible area, and
* increase them if necessary,
* - Before finally opening the pane as a nested part of the parent.
*
*/
static nserror cert_attach_pane(wimp_w parent, wimp_w pane)
{
os_error *error;
wimp_window_state wstate;
wimp_window_info winfo;
wimp_icon_state istate;
bool set_extent;
winfo.w = pane;
error = xwimp_get_window_info_header_only(&winfo);
if (error) {
LOG("xwimp_get_window_info: 0x%x: %s",
error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
error = xwimp_create_window(ro_gui_cert_tree_template,
&(sslcert_window->pane));
wstate.w = parent;
error = xwimp_get_window_state(&wstate);
if (error) {
LOG("xwimp_create_window: 0x%x: %s", error->errnum, error->errmess);
free(sslcert_window);
LOG("xwimp_get_window_state: 0x%x: %s",
error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
/* Create the SSL data and build a tree from it. */
sslcert_viewer_create_session_data(num, url,
cb, cbpw, certs, &sslcert_window->data);
ssl_current_session = sslcert_window->data;
istate.w = parent;
istate.i = ICON_SSL_PANE;
error = xwimp_get_icon_state(&istate);
if (error) {
LOG("xwimp_get_icon_state: 0x%x: %s",
error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
sslcert_window->tv = ro_treeview_create(sslcert_window->pane,
NULL, NULL, TREE_SSLCERT);
if (sslcert_window->tv == NULL) {
LOG("Failed to allocate treeview");
free(sslcert_window);
wstate.w = pane;
wstate.visible.x1 = wstate.visible.x0 + istate.icon.extent.x1 - 20 - ro_get_vscroll_width(pane);
wstate.visible.x0 += istate.icon.extent.x0 + 20;
wstate.visible.y0 = wstate.visible.y1 + istate.icon.extent.y0 + 20 + ro_get_hscroll_height(pane);
wstate.visible.y1 += istate.icon.extent.y1 - 32;
set_extent = false;
if ((winfo.extent.x1 - winfo.extent.x0) <
(wstate.visible.x1 - wstate.visible.x0)) {
winfo.extent.x0 = 0;
winfo.extent.x1 = wstate.visible.x1 - wstate.visible.x0;
set_extent = true;
}
if ((winfo.extent.y1 - winfo.extent.y0) <
(wstate.visible.y1 - wstate.visible.y0)) {
winfo.extent.y1 = 0;
winfo.extent.x1 = wstate.visible.y0 - wstate.visible.y1;
set_extent = true;
}
if (set_extent) {
error = xwimp_set_extent(pane, &(winfo.extent));
if (error) {
LOG("xwimp_set_extent: 0x%x: %s",
error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
}
error = xwimp_open_window_nested(
PTR_WIMP_OPEN(&wstate),
parent,
wimp_CHILD_LINKS_PARENT_VISIBLE_BOTTOM_OR_LEFT << wimp_CHILD_XORIGIN_SHIFT |
wimp_CHILD_LINKS_PARENT_VISIBLE_TOP_OR_RIGHT << wimp_CHILD_YORIGIN_SHIFT |
wimp_CHILD_LINKS_PARENT_VISIBLE_BOTTOM_OR_LEFT << wimp_CHILD_LS_EDGE_SHIFT |
wimp_CHILD_LINKS_PARENT_VISIBLE_BOTTOM_OR_LEFT << wimp_CHILD_RS_EDGE_SHIFT);
if (error) {
LOG("xwimp_open_window_nested: 0x%x: %s",
error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
return NSERROR_OK;
}
/**
* Callback to draw on drawable area of ro certificate viewer window.
*
* \param ro_cw The riscos core window structure.
* \param originx The risc os plotter x origin.
* \param originy The risc os plotter y origin.
* \param r The rectangle of the window that needs updating.
* \return NSERROR_OK on success otherwise apropriate error code
*/
static nserror
cert_draw(struct ro_corewindow *ro_cw, int originx, int originy, struct rect *r)
{
struct ro_cert_window *certw;
struct redraw_context ctx = {
.interactive = true,
.background_images = true,
.plot = &ro_plotters
};
certw = (struct ro_cert_window *)ro_cw;
ro_plot_origin_x = originx;
ro_plot_origin_y = originy;
no_font_blending = true;
sslcert_viewer_redraw(certw->ssl_data, 0, 0, r, &ctx);
no_font_blending = false;
return NSERROR_OK;
}
/**
* callback for keypress on ro certificate viewer window
*
* \param ro_cw The ro core window structure.
* \param nskey The netsurf key code.
* \return NSERROR_OK if key processed,
* NSERROR_NOT_IMPLEMENTED if key not processed
* otherwise apropriate error code
*/
static nserror cert_key(struct ro_corewindow *ro_cw, uint32_t nskey)
{
struct ro_cert_window *certw;
certw = (struct ro_cert_window *)ro_cw;
if (sslcert_viewer_keypress(certw->ssl_data, nskey)) {
return NSERROR_OK;
}
return NSERROR_NOT_IMPLEMENTED;
}
/**
* callback for mouse event on ro certificate viewer window
*
* \param ro_cw The ro core window structure.
* \param mouse_state mouse state
* \param x location of event
* \param y location of event
* \return NSERROR_OK on sucess otherwise apropriate error code.
*/
static nserror
cert_mouse(struct ro_corewindow *ro_cw,
browser_mouse_state mouse_state,
int x, int y)
{
struct ro_cert_window *certw;
certw = (struct ro_cert_window *)ro_cw;
sslcert_viewer_mouse_action(certw->ssl_data, mouse_state, x, y);
return NSERROR_OK;
}
/* exported interface documented in riscos/sslcert.h */
nserror
gui_cert_verify(nsurl *url,
const struct ssl_cert_info *certs,
unsigned long num,
nserror (*cb)(bool proceed, void *pw),
void *cbpw)
{
os_error *error;
struct ro_cert_window *ncwin; /* new certificate window */
nserror res;
ncwin = malloc(sizeof(struct ro_cert_window));
if (ncwin == NULL) {
return NSERROR_NOMEM;
}
/* initialise certificate viewing interface */
res = sslcert_viewer_create_session_data(num, url, cb, cbpw, certs,
&ncwin->ssl_data);
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
/* Create the SSL window */
error = xwimp_create_window(dialog_cert_template, &ncwin->wh);
if (error) {
LOG("xwimp_create_window: 0x%x: %s",
error->errnum, error->errmess);
free(ncwin);
return NSERROR_INIT_FAILED;
}
/* create ssl viewer pane window */
error = xwimp_create_window(cert_tree_template, &ncwin->core.wh);
if (error) {
LOG("xwimp_create_window: 0x%x: %s",
error->errnum, error->errmess);
free(ncwin);
return NSERROR_INIT_FAILED;
}
/* setup callbacks */
ncwin->core.draw = cert_draw;
ncwin->core.key = cert_key;
ncwin->core.mouse = cert_mouse;
/* initialise core window */
res = ro_corewindow_init(&ncwin->core, NULL, NULL, 0, NULL);
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
res = sslcert_viewer_init(ncwin->core.cb_table,
(struct core_window *)ncwin,
ncwin->ssl_data);
if (res != NSERROR_OK) {
free(ncwin);
return res;
}
/* Set up the certificate window event handling.
*
* (The action buttons are registered as button events, not OK and
* Cancel, as both need to carry out actions.)
*/
ro_gui_wimp_event_set_user_data(ncwin->wh, ncwin);
ro_gui_wimp_event_register_close_window(ncwin->wh,
ro_gui_cert_close_window);
ro_gui_wimp_event_register_button(ncwin->wh,
ICON_SSL_REJECT,
ro_gui_cert_reject);
ro_gui_wimp_event_register_button(ncwin->wh,
ICON_SSL_ACCEPT,
ro_gui_cert_accept);
ro_gui_wimp_event_set_user_data(sslcert_window->window, sslcert_window);
ro_gui_wimp_event_register_close_window(sslcert_window->window,
ro_gui_cert_close_window);
ro_gui_wimp_event_register_button(sslcert_window->window,
ICON_SSL_REJECT, ro_gui_cert_reject);
ro_gui_wimp_event_register_button(sslcert_window->window,
ICON_SSL_ACCEPT, ro_gui_cert_accept);
ro_gui_dialog_open_persistent(NULL, ncwin->wh, false);
ro_gui_dialog_open_persistent(NULL, sslcert_window->window, false);
/* Nest the tree window inside the pane window. To do this, we:
* - Get the current pane extent,
* - Get the parent window position and the location of the pane-
* locating icon inside it,
* - Set the visible area of the pane to suit,
* - Check that the pane extents are OK for this visible area, and
* increase them if necessary,
* - Before finally opening the pane as a nested part of the parent.
*/
info.w = sslcert_window->pane;
error = xwimp_get_window_info_header_only(&info);
if (error) {
ro_gui_cert_release_window(sslcert_window);
LOG("xwimp_get_window_info: 0x%x: %s", error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
res = cert_attach_pane(ncwin->wh, ncwin->core.wh);
if (res != NSERROR_OK) {
ro_gui_cert_release_window(ncwin);
}
state.w = sslcert_window->window;
error = xwimp_get_window_state(&state);
if (error) {
ro_gui_cert_release_window(sslcert_window);
LOG("xwimp_get_window_state: 0x%x: %s", error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
istate.w = sslcert_window->window;
istate.i = ICON_SSL_PANE;
error = xwimp_get_icon_state(&istate);
if (error) {
ro_gui_cert_release_window(sslcert_window);
LOG("xwimp_get_icon_state: 0x%x: %s", error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
state.w = sslcert_window->pane;
state.visible.x1 = state.visible.x0 + istate.icon.extent.x1 - 20 -
ro_get_vscroll_width(sslcert_window->pane);
state.visible.x0 += istate.icon.extent.x0 + 20;
state.visible.y0 = state.visible.y1 + istate.icon.extent.y0 + 20 +
ro_get_hscroll_height(sslcert_window->pane);
state.visible.y1 += istate.icon.extent.y1 - 32;
set_extent = false;
if ((info.extent.x1 - info.extent.x0) <
(state.visible.x1 - state.visible.x0)) {
info.extent.x0 = 0;
info.extent.x1 = state.visible.x1 - state.visible.x0;
set_extent = true;
}
if ((info.extent.y1 - info.extent.y0) <
(state.visible.y1 - state.visible.y0)) {
info.extent.y1 = 0;
info.extent.x1 = state.visible.y0 - state.visible.y1;
set_extent = true;
}
if (set_extent) {
error = xwimp_set_extent(sslcert_window->pane, &(info.extent));
if (error) {
ro_gui_cert_release_window(sslcert_window);
LOG("xwimp_set_extent: 0x%x: %s", error->errnum, error->errmess);
return NSERROR_INIT_FAILED;
}
}
error = xwimp_open_window_nested(PTR_WIMP_OPEN(&state),
sslcert_window->window,
wimp_CHILD_LINKS_PARENT_VISIBLE_BOTTOM_OR_LEFT
<< wimp_CHILD_XORIGIN_SHIFT |
wimp_CHILD_LINKS_PARENT_VISIBLE_TOP_OR_RIGHT
<< wimp_CHILD_YORIGIN_SHIFT |
wimp_CHILD_LINKS_PARENT_VISIBLE_BOTTOM_OR_LEFT
<< wimp_CHILD_LS_EDGE_SHIFT |
wimp_CHILD_LINKS_PARENT_VISIBLE_BOTTOM_OR_LEFT
<< wimp_CHILD_RS_EDGE_SHIFT);
if (error) {
ro_gui_cert_release_window(sslcert_window);
LOG("xwimp_open_window_nested: 0x%x: %s", error->errnum, error->errmess);
ro_gui_cert_release_window(sslcert_window);
return NSERROR_INIT_FAILED;
}
ro_treeview_set_origin(sslcert_window->tv, 0, 0);
return NSERROR_OK;
return res;
}
/**
* Handle acceptance of certificate via event callback.
*
* \param *pointer The wimp pointer block.
*/
void ro_gui_cert_accept(wimp_pointer *pointer)
/* exported interface documented in riscos/sslcert.h */
void ro_gui_cert_initialise(void)
{
struct ro_sslcert *s;
/* Load template for the SSL certificate window */
dialog_cert_template = ro_gui_dialog_load_template("sslcert");
s = (struct ro_sslcert *) ro_gui_wimp_event_get_user_data(pointer->w);
/* load template for ssl treeview pane and adjust the window flags. */
cert_tree_template = ro_gui_dialog_load_template("tree");
if (s != NULL) {
sslcert_viewer_accept(s->data);
ro_gui_dialog_close(s->window);
ro_gui_cert_release_window(s);
}
cert_tree_template->flags &= ~(wimp_WINDOW_MOVEABLE |
wimp_WINDOW_BACK_ICON |
wimp_WINDOW_CLOSE_ICON |
wimp_WINDOW_TITLE_ICON |
wimp_WINDOW_SIZE_ICON |
wimp_WINDOW_TOGGLE_ICON);
}
/**
* Handle rejection of certificate via event callback.
*
* \param pointer The wimp pointer block.
*/
void ro_gui_cert_reject(wimp_pointer *pointer)
{
struct ro_sslcert *s;
s = (struct ro_sslcert *) ro_gui_wimp_event_get_user_data(pointer->w);
if (s != NULL) {
sslcert_viewer_reject(s->data);
ro_gui_dialog_close(s->window);
ro_gui_cert_release_window(s);
}
}
/**
* Callback to handle the closure of the SSL dialogue by other means.
*
* \param w The window being closed.
*/
static void ro_gui_cert_close_window(wimp_w w)
{
struct ro_sslcert *s;
s = (struct ro_sslcert *) ro_gui_wimp_event_get_user_data(w);
if (s != NULL)
ro_gui_cert_release_window(s);
}
/**
* Handle closing of the RISC OS certificate verification dialog, deleting
* the windows and freeing up the treeview and data block.
*
* \param *s The data block associated with the dialogue.
*/
void ro_gui_cert_release_window(struct ro_sslcert *s)
{
os_error *error;
if (s == NULL)
return;
LOG("Releasing SSL data: 0x%x", (unsigned)s);
ro_gui_wimp_event_finalise(s->window);
ro_treeview_destroy(s->tv);
error = xwimp_delete_window(s->window);
if (error) {
LOG("xwimp_delete_window: 0x%x:%s", error->errnum, error->errmess);
ro_warn_user("WimpError", error->errmess);
}
error = xwimp_delete_window(s->pane);
if (error) {
LOG("xwimp_delete_window: 0x%x:%s", error->errnum, error->errmess);
ro_warn_user("WimpError", error->errmess);
}
free(s);
}

26
frontends/riscos/sslcert.h
View File

@ -17,17 +17,31 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* SSL certificate viewer (interface).
/**
* \file
* RISC OS SSL certificate viewer interface.
*/
#ifndef _NETSURF_RISCOS_SSLCERT_H_
#define _NETSURF_RISCOS_SSLCERT_H_
#ifndef NETSURF_RISCOS_SSLCERT_H
#define NETSURF_RISCOS_SSLCERT_H
struct node;
void ro_gui_cert_preinitialise(void);
void ro_gui_cert_postinitialise(void);
/**
* Load and initialise the certificate window template.
*/
void ro_gui_cert_initialise(void);
/**
* Prompt the user to verify a certificate with issuse.
*
* \param url The URL being verified.
* \param certs The certificate to be verified
* \param num The number of certificates to be verified.
* \param cb Callback upon user decision.
* \param cbpw Context pointer passed to cb
*/
nserror gui_cert_verify(struct nsurl *url, const struct ssl_cert_info *certs, unsigned long num, nserror (*cb)(bool proceed, void *pw), void *cbpw);
#endif

2
frontends/riscos/theme.c
View File

@ -47,7 +47,7 @@
#include "riscos/hotlist.h"
#include "riscos/menus.h"
#include "riscos/theme.h"
#include "riscos/treeview.h"
#include "riscos/toolbar.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"
#include "riscos/wimputils.h"

1
frontends/riscos/toolbar.c
View File

@ -53,7 +53,6 @@
#include "riscos/save.h"
#include "riscos/theme.h"
#include "riscos/toolbar.h"
#include "riscos/treeview.h"
#include "riscos/url_complete.h"
#include "riscos/wimp.h"
#include "riscos/wimp_event.h"

1277
frontends/riscos/treeview.c
View File

File diff suppressed because it is too large Load Diff

55
frontends/riscos/treeview.h
View File

@ -1,55 +0,0 @@
/*
* Copyright 2004 Richard Wilson <not_ginger_matt@users.sourceforge.net>
* Copyright 2010 Stephen Fryatt <stevef@netsurf-browser.org>
*
* 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
* Generic tree handling (interface).
*/
#ifndef _NETSURF_RISCOS_TREEVIEW_H_
#define _NETSURF_RISCOS_TREEVIEW_H_
#include <stdbool.h>
#include <oslib/help.h>
#include <oslib/wimp.h>
#include "desktop/tree.h"
#include "riscos/toolbar.h"
typedef struct ro_treeview ro_treeview;
struct ro_treeview_callbacks {
void (*toolbar_button_click)(button_bar_action action);
void (*toolbar_button_update)(void);
void (*toolbar_button_save)(char *);
};
ro_treeview *ro_treeview_create(wimp_w window, struct toolbar *toolbar,
struct ro_treeview_callbacks *callbacks, unsigned int flags);
void ro_treeview_destroy(ro_treeview *tv);
const struct toolbar_callbacks *ro_treeview_get_toolbar_callbacks(void);
struct tree *ro_treeview_get_tree(ro_treeview *tv);
wimp_w ro_treeview_get_window(ro_treeview *tv);
void ro_treeview_set_origin(ro_treeview *tv, int x, int y);
void ro_treeview_mouse_at(wimp_pointer *pointer, void *data);
int ro_treeview_get_help(help_full_message_request *message_data);
#endif

14
frontends/riscos/window.c
View File

@ -1944,7 +1944,7 @@ bool ro_gui_window_handle_local_keypress(struct gui_window *g, wimp_key *key,
return true;
case IS_WIMP_KEY + wimp_KEY_F6: /* Hotlist */
ro_gui_hotlist_open();
ro_gui_hotlist_present();
return true;
case IS_WIMP_KEY + wimp_KEY_F7: /* Show local history */
@ -1953,7 +1953,7 @@ bool ro_gui_window_handle_local_keypress(struct gui_window *g, wimp_key *key,
case IS_WIMP_KEY + wimp_KEY_CONTROL + wimp_KEY_F7:
/* Show global history */
ro_gui_global_history_open();
ro_gui_global_history_present();
return true;
case IS_WIMP_KEY + wimp_KEY_F8: /* View source */
@ -2696,7 +2696,7 @@ bool ro_gui_window_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
ro_gui_window_action_local_history(g);
break;
case HISTORY_SHOW_GLOBAL:
ro_gui_global_history_open();
ro_gui_global_history_present();
break;
/* hotlist actions */
@ -2704,12 +2704,12 @@ bool ro_gui_window_menu_select(wimp_w w, wimp_i i, wimp_menu *menu,
ro_gui_window_action_add_bookmark(g);
break;
case HOTLIST_SHOW:
ro_gui_hotlist_open();
ro_gui_hotlist_present();
break;
/* cookies actions */
case COOKIES_SHOW:
ro_gui_cookies_open();
ro_gui_cookies_present();
break;
case COOKIES_DELETE:
@ -3607,7 +3607,7 @@ void ro_gui_window_toolbar_click(void *data,
break;
case TOOLBAR_BUTTON_HISTORY_GLOBAL:
ro_gui_global_history_open();
ro_gui_global_history_present();
break;
case TOOLBAR_BUTTON_HOME:
@ -3623,7 +3623,7 @@ void ro_gui_window_toolbar_click(void *data,
break;
case TOOLBAR_BUTTON_BOOKMARK_OPEN:
ro_gui_hotlist_open();
ro_gui_hotlist_present();
break;
case TOOLBAR_BUTTON_BOOKMARK_ADD:

11
frontends/windows/corewindow.c
View File

@ -18,7 +18,7 @@
/**
* \file
* win32 generic core window interface.
* win32 generic core window implementation.
*
* Provides interface for core renderers to a win32 api client area.
*
@ -248,7 +248,7 @@ nsw32_corewindow_close(struct nsw32_corewindow *nsw32_cw)
}
/**
* callback for hotlist window win32 events
* callback for core window win32 events
*
* \param hwnd The win32 window handle
* \param msg The win32 message identifier
@ -349,6 +349,13 @@ nsw32_cw_scroll_visible(struct core_window *cw, const struct rect *r)
}
/**
* Callback from the core to obtain the window viewport dimensions
*
* \param[in] cw the core window object
* \param[out] width to be set to viewport width in px
* \param[out] height to be set to viewport height in px
*/
static void
nsw32_cw_get_window_dimensions(struct core_window *cw, int *width, int *height)
{

4
frontends/windows/hotlist.c
View File

@ -36,12 +36,16 @@
#include "windows/hotlist.h"
/**
* Hotlist window container for win32.
*/
struct nsw32_hotlist_window {
struct nsw32_corewindow core;
const char *path; /**< path to users bookmarks */
};
/** hotlist window singleton */
static struct nsw32_hotlist_window *hotlist_window = NULL;
/**

24
include/netsurf/core_window.h
View File

@ -47,34 +47,34 @@ struct core_window_callback_table {
/**
* Request a redraw of the window
*
* \param cw the core window object
* \param r rectangle to redraw
* \param[in] cw the core window object
* \param[in] r rectangle to redraw
*/
void (*redraw_request)(struct core_window *cw, const struct rect *r);
/**
* Update the limits of the window
*
* \param cw the core window object
* \param width the width in px, or negative if don't care
* \param height the height in px, or negative if don't care
* \param[in] cw the core window object
* \param[in] width the width in px, or negative if don't care
* \param[in] height the height in px, or negative if don't care
*/
void (*update_size)(struct core_window *cw, int width, int height);
/**
* Scroll the window to make area visible
*
* \param cw the core window object
* \param r rectangle to make visible
* \param[in] cw the core window object
* \param[in] r rectangle to make visible
*/
void (*scroll_visible)(struct core_window *cw, const struct rect *r);
/**
* Get window viewport dimensions
*
* \param cw the core window object
* \param width to be set to viewport width in px, if non NULL
* \param height to be set to viewport height in px, if non NULL
* \param[in] cw the core window object
* \param[out] width to be set to viewport width in px
* \param[out] height to be set to viewport height in px
*/
void (*get_window_dimensions)(struct core_window *cw,
int *width, int *height);
@ -82,8 +82,8 @@ struct core_window_callback_table {
/**
* Inform corewindow owner of drag status
*
* \param cw the core window object
* \param ds the current drag status
* \param[in] cw the core window object
* \param[in] ds the current drag status
*/
void (*drag_status)(struct core_window *cw,
core_window_drag_status ds);