/* Copyright 1997 Acorn Computers Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************/
/* File : Windows.c */
/* */
/* Purpose: Window related functions for the */
/* browser (open, close, create, etc.). */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 20-Nov-96: Created. */
/* 15-Mar-97: Split up to form Browser.c. */
/***************************************************/
#include <stdlib.h>
#include <string.h>
#include "swis.h"
#include "flex.h"
#include "wimp.h"
#include "wimplib.h"
#include "event.h"
#include "toolbox.h"
#include "window.h"
#include "Dialler.h"
#include "NestWimp.h"
#include "svcprint.h"
#include "Global.h"
#include "FromROSLib.h"
#include "MiscDefs.h"
#include "Utils.h"
#include "Browser.h"
#include "ChoiceDefs.h"
#include "Fetch.h" /* (Which itself includes URLstat.h) */
#include "FetchHTML.h"
#include "FetchPage.h"
#include "FontManage.h"
#include "Forms.h"
#include "Frames.h"
#include "Handlers.h"
#include "History.h"
#include "Images.h"
#include "Main.h"
#include "Memory.h"
#include "Menus.h"
#include "Meta.h"
#include "Object.h"
#include "OpenURL.h"
#include "PlugIn.h"
#include "Printing.h"
#include "Redraw.h"
#include "Reformat.h"
#include "Tables.h"
#include "Toolbars.h"
#include "URLutils.h"
#include "Windows.h"
/* Static function prototypes */
static void windows_check_reformat (browser_data * b, BBox * size, int old_width);
/* Locals */
static int title_height = 0;
static int vscroll_width = 0;
static int hscroll_height = 0;
/*************************************************/
/* windows_check_reformat() */
/* */
/* After resizing, checks whether the contents */
/* of a given browser need reformatting and */
/* ensures tool presence is up to date. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the browser; */
/* */
/* Pointer to a BBox describing the */
/* new visible area of the window; */
/* */
/* The old display_width field of */
/* the browser_data struct to */
/* compare against the width defined */
/* by the given BBox. */
/*************************************************/
static void windows_check_reformat(browser_data * b, BBox * size, int old_width)
{
/* If the width has changed, need to reformat. Notice that the */
/* horizontal extent is forced up to at least a certain minimum */
/* value, but is never shrunk. */
if (size->xmax - size->xmin != old_width)
{
int h1, h2;
b->display_extent = b->display_width = size->xmax - size->xmin;
if (b->display_extent < MinimumWidth) b->display_extent = MinimumWidth;
h1 = toolbars_button_height(b) + toolbars_url_height(b);
h2 = toolbars_status_height(b);
if (h1) h1 += wimpt_dy();
if (h2) h2 += wimpt_dy();
b->display_height = size->ymax - size->ymin - h1 - h2;
if (b->ancestor || b->full_screen) windows_set_tools(b, size, !b->ancestor, 0, 0, 0);
reformat_format_from(b, -1, 1, -1);
}
// Blimey. This *really* needs sorting out. As for the windows_remember_size
// call - which duplicates this functionality more or less! - you should NOT
// need to redraw here. The display_width has not changed, so centered objects
// will not move. If it *has* changed, whatever changed it screwed up!
// /* Otherwise just force a redraw (to make sure centred objects */
// /* are OK) and check the tools are up to date. */
//
// else
// {
// WimpGetWindowStateBlock state;
//
// state.window_handle = b->window_handle;
//
// if (!wimp_get_window_state(&state))
// {
// coords_box_toworkarea(&state.visible_area, (WimpRedrawWindowBlock *) &state);
//
// wimp_force_redraw(state.window_handle,
// state.visible_area.xmin,
// state.visible_area.ymin,
// state.visible_area.xmax,
// state.visible_area.ymax);
// }
//
// windows_check_tools(b, NULL);
// }
}
/*************************************************/
/* windows_new_browser() */
/* */
/* Creates a new Browser window. Parameters are */
/* as standard for a Toolbox event handler, with */
/* void * handle being NULL to open with the */
/* current home page, else a pointer to a URL. */
/*************************************************/
int windows_new_browser(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
#ifndef SINGLE_USER
/* If in a multiuser build and not logged in, claim */
/* the event but don't do anything with it. */
if (!logged_in) return 1;
#endif
if (handle) ChkError(windows_create_browser((char *) handle, NULL, NULL, NULL, Windows_CreateBrowser_Normal));
else
{
char home[Limits_URL];
urlutils_create_home_url(home, sizeof(home));
ChkError(windows_create_browser(home, NULL, NULL, NULL, Windows_CreateBrowser_Normal));
}
return 1;
}
/*************************************************/
/* windows_shut_browser() */
/* */
/* Close a browser window. Closes the ancestor */
/* and all child frames. Parameters are as */
/* standard for a Toolbox event handler. */
/*************************************************/
int windows_shut_browser(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
browser_data * b;
ObjectId browser = idb->ancestor_id;
if (!browser) browser = idb->self_id;
ChkError(toolbox_get_client_handle(0, browser, (void *) &b));
if (!is_known_browser(b)) return 0;
/* Always use the ancestor */
b = utils_ancestor(b);
/* Close it */
return handle_close_browser(0, NULL, NULL, b);
}
/*************************************************/
/* windows_create_browser() */
/* */
/* Creates and initialises a browser_data struct */
/* and may create an associated window object. */
/* */
/* Parameters: Pointer to a URL to fetch (or */
/* NULL to fetch none); */
/* */
/* Pointer to a parent structure if */
/* this is a frame, else NULL; */
/* */
/* Pointer to a BBox describing the */
/* visible area, or NULL to use */
/* default sizes and a window */
/* position based on the last */
/* default open position; */
/* */
/* Pointer to the name for this */
/* window (for targetted URLs), or */
/* NULL for none. The string will be */
/* copied to a browser local malloc */
/* block, so it can come from pretty */
/* much anywhere that isn't going to */
/* shift over a function call */
/* boundary (i.e. not flex!); */
/* */
/* Fetch type value; see definitions */
/* in Windows.h. Note that the */
/* ForUIElement type is not */
/* implemented - don't use it! */
/*************************************************/
_kernel_oserror * windows_create_browser(const char * url, browser_data * real_parent,
BBox * size, const char * name, int save_type)
{
ObjectId o;
browser_data * b;
reformat_cell * cell;
_kernel_oserror * e = NULL;
int width, height;
/* If no size BBox is given, use the Choices file specified sizes, */
/* else use the sizes defined by the BBox. */
if (!size) width = choices.width, height = choices.height;
else width = size->xmax - size->xmin, height = size->ymax - size->ymin;
/* malloc a block of space, treating it as holding a browser_data */
/* structure. This is defined in global.h, and holds all the */
/* information needed with a given browser window (e.g. the */
/* document currently on display in that window, etc). */
#ifdef TRACE
if (tl & (1u<<12))
{
Printf("windows_create_browser: memory_alloc_and_set %d for 'browser_data' structure\n",sizeof(browser_data));
Printf(" and %d for 'reformat_cell' structure\n",sizeof(reformat_cell));
}
#endif
b = (browser_data *) memory_alloc_and_set(sizeof(browser_data), 0);
cell = (reformat_cell *) memory_alloc_and_set(sizeof(reformat_cell), 0);
if (!b || !cell)
{
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("NoMemWin:There is not enough free memory to open another browser window.",
0,
0));
return &erb;
}
else
{
#ifdef TRACE
malloccount += (sizeof(browser_data) + sizeof(reformat_cell));
if (tl & (1u<<13)) Printf("** malloccount (windows_create_browser): \0211%d\0217\n",malloccount);
#endif
/* The allocation succeeded, so create the object, fill in the browser_data */
/* stucture, and link the stucture into the list of structures for all the */
/* browser windows. The toolbox is given a pointer to the structure as a */
/* client handle for the window, so whenever we get an event relating to */
/* the window this pointer is also supplied. */
b->cell = cell;
if (save_type != Windows_CreateBrowser_Normal && controls.use_small)
{
/* If the browser is created just to save an object, */
/* build a 'mini' browser for just that. */
e = toolbox_create_object(0, "BrowsrFetch", &o);
b->small_fetch = 1;
}
else
{
/* Otherwise, build a base browser, or if this is a frame, a child */
/* browser object. */
if (!real_parent) e = toolbox_create_object(0, "Browser", &o);
else
{
if (nested_wimp) e = toolbox_create_object(0, "BrChild", &o);
else e = toolbox_create_object(0, "BrChildBrdr", &o);
}
}
if (e) return e;
RetError(toolbox_set_client_handle(0, o, b));
/* Regardless of whether this is an ancestor browser window or a frame, */
/* its next pointer must still be set to NULL. */
b->next = NULL;
/* Link this into the list of browser_data structures only if it's a parent */
/* browser window - i.e. not part of a frame set; there will be no parent */
/* browser_data struct passed into the function as this means you're a child. */
b->previous = last_browser;
if (last_browser) last_browser->next = b;
last_browser = b;
/* Sort out parent/child linking considerations */
if (!real_parent)
{
b->ancestor = NULL; /* If not a child, this is an ancestor object */
b->parent = NULL;
b->real_parent = NULL;
}
else
{
/* Allocate memory in the array of children for this entry */
RetError(memory_set_chunk_size(real_parent, NULL, CK_CHIL, (real_parent->nchildren + 1) * sizeof(browser_data *)));
/* Add the entry - nchildren hasn't been incremented yet, so */
/* [real_parent->nchildren] is correct for the new entry. */
real_parent->children[real_parent->nchildren] = b;
/* Fill in the child's parent and ancestor fields */
b->real_parent = real_parent;
b->parent = real_parent;
b->ancestor = real_parent->ancestor;
if (!b->ancestor) b->ancestor = real_parent;
/* Finally, increment the parent's number of children counter */
real_parent->nchildren++;
}
b->self_id = o;
#ifdef TRACE
if (tl & (1u<<3))
{
Printf("\nCreated object ID %p\n",(void *) o);
Printf("Associated structure is %p\n\n",(void *) b);
}
#endif
/* Opening width considerations... */
b->display_width = b->display_extent = width;
if (b->display_extent < MinimumWidth) b->display_extent = MinimumWidth, b->display_width = MinimumWidth;
/* ...and opening height */
b->display_height = height;
/* Default page layout information */
b->left_margin = choices.left_margin;
b->right_margin = choices.right_margin;
b->quote_margin = choices.quote_margin;
b->leading = choices.leading;
b->left_indent = choices.left_indent;
/* Default encoding */
b->encoding = choices.encoding;
b->encoding_priority = priority_default;
/* Set up the deferred reformatter */
b->refo_time = 0;
b->refo_line = Reformat_UnrealisticallyHighLineNumber;
/* Remember the Wimp window handle to save having to ask for it elsewhere */
RetError(window_get_wimp_handle(0,o,&(b->window_handle)));
/* Allocate memory for the fetching URL and write that */
/* URL into the block */
b->urlddata = NULL; /* No current displayed URL */
/* If handle is non-zero treat as a pointer to a URL, else */
/* fetch the Home Page. */
if (url)
{
#ifdef TRACE
if (tl & (1u<<12)) Printf("windows_create_browser: Chunk CK_FURL set to %d\n",strlen(url) + 1);
#endif
RetError(memory_set_chunk_size(b, NULL, CK_FURL, strlen(url) + 1));
strcpy(b->urlfdata, url);
}
/* If there's a given window name, set it */
if (name && *name)
{
#ifdef TRACE
if (tl & (1u<<12)) Printf("windows_create_browser: Chunk CK_NAME set to %d\n",strlen(name) + 1);
#endif
RetError(memory_set_chunk_size(b, NULL, CK_NAME, strlen(name) + 1));
strcpy(b->window_name, name);
}
/* Set some local options according to the global Choices */
b->underline_links = choices.underline_links;
b->use_source_cols = choices.use_source_cols;
b->show_foreground = choices.show_foreground;
b->show_background = choices.show_background;
/* Initialise various other fields */
b->background_image = -1;
b->full_screen = !real_parent ? choices.full_screen : 0;
b->full_size = 0;
if (save_type != Windows_CreateBrowser_Normal) b->save_link = 1;
else b->save_link = 0;
/* Register some browser-specific Wimp event handlers */
RetError(event_register_wimp_handler(o, Wimp_ERedrawWindow, (WimpEventHandler *) windows_redraw_browser, b));
RetError(event_register_wimp_handler(o, Wimp_EOpenWindow, (WimpEventHandler *) windows_open_browser, b));
RetError(event_register_wimp_handler(o, Wimp_EScrollRequest, (WimpEventHandler *) handle_scroll_requests, b));
RetError(event_register_wimp_handler(o, Wimp_EKeyPressed, (WimpEventHandler *) handle_keys_from_browser, b));
/* For toolbars and titles, need to be a parent (i.e. have no */
/* parent browser_data struct, as that means you're a child). */
if (!real_parent)
{
ObjectId ttop, tbot;
int scrap;
char text[Limits_URLBarWrit];
if (!b->small_fetch)
{
/* Set the window title to contain the default URL for rendering. */
RetError(window_set_title(0, o, lookup_token("BlankPage:Blank page",0,0)));
}
else
{
/* Set the window title to contain a default string for file fetching. */
RetError(window_set_title(0, o, lookup_token("DataFetch:Fetching to file...",0,0)));
}
/* Set various toolbar flags up, and make */
/* sure the right toolbars are visible. */
if (save_type != Windows_CreateBrowser_Normal && controls.use_small)
{
b->url_bar = 1;
b->button_bar = 1;
b->status_bar = 1;
}
else
{
b->url_bar = choices.url_bar;
b->button_bar = choices.button_bar;
b->status_bar = choices.status_bar;
}
/* Work out what toolbars are available */
RetError(window_get_tool_bars(InternalTopLeft | InternalBottomLeft,
o,
&tbot,
&ttop,
NULL,
NULL));
if (!ttop) b->all_in_bottom = 1;
if (!tbot) b->all_in_top = 1;
/* Now make sure that ttop and tbot reflect the updated values in */
/* light of the all_in_bottom/all_in_top/swap_bars flags. */
ttop = toolbars_get_upper(b);
tbot = toolbars_get_lower(b); /* (These are needed further down). */
/* Read scroll bar choices */
b->frame_hscroll = choices.h_scroll;
b->frame_vscroll = choices.v_scroll;
/* Only allow Wimp events to close a window if it's a parent; */
/* otherwise, want entirely browser-driven control of when */
/* the child closes (for example, it Would Be Bad if some */
/* dodgy PD application that closed the window under the */
/* pointer on noticing some hotkey was activated on a child). */
RetError(event_register_wimp_handler(o, Wimp_ECloseWindow, (WimpEventHandler *) handle_close_browser, b));
/* Register event handlers for toolbar items, if a parent. Similarly, work out */
/* what to do with toolbar buttons and writables, etc., only if a parent (a */
/* child as no toolbars). */
if (ttop)
{
RetError(event_register_wimp_handler(ttop, Wimp_EMouseClick, (WimpEventHandler *) handle_clicks, b));
/* If there's a dialler display field, install a long-term handler */
/* to keep it up to date. */
e = gadget_get_type(0, ttop, URLBarDiallerStatus, &scrap);
if (!e)
{
if (!taskmodule_ds_registered)
{
/* Register the dialler's 'status changed' service call */
/* with TaskModule. This allows a Wimp message to be */
/* sent whenever the status changes. */
e = _swix(TaskModule_RegisterService,
_INR(0, 2),
0,
Service_DiallerStatus,
task_handle);
/* If the above fails, don't bother reporting the error, */
/* just skip the function - it is non-essential and the */
/* most likely cause of failure - unknown SWI - is taken */
/* as an indicator that the dialler service is not */
/* needed. */
if (!e) taskmodule_ds_registered = 1;
}
else e = NULL;
if (!e)
{
/* Message handler for the TaskModule's Message_Service message, */
/* which is sent when the dialler sends out a 'status changed' */
/* service call following the above registration SWI call. */
RetError(event_register_message_handler(Message_Service, handle_dialler_service, b));
}
}
}
/* Handle border and colour control of the URL writable, status */
/* field, and dialler display field. */
if (ttop)
{
/* URL writable */
RetError(windows_process_component_text(ttop, URLBarWrit, text, sizeof(text), 0, 1));
/* Dialler status display field */
RetError(windows_process_component_text(ttop, URLBarDiallerStatus, text, sizeof(text), 0, 1));
}
if (tbot)
{
int bytes_flags;
/* Main status display field */
RetError(windows_process_component_text(tbot, StatusBarStatus, text, sizeof(text), 0, 1));
/* Progress indicator */
RetError(windows_process_component_text(tbot, StatusBarProgress, text, sizeof(text), 0, 1));
/* Remember whatever foreground colour the StatusBarProgress gadget now has */
if (!button_get_flags(0, tbot, StatusBarProgress, &bytes_flags));
{
b->progress_colour = (bytes_flags & 0x0f000000) >> 24;
}
}
/* Are the URL writable and status display to be merged? */
/* Can only merge them if the toolbars are merged. */
/* */
/* Take this opportunity to look for bistate and */
/* tristate button definitions, in the same way. */
if (b->all_in_top || b->all_in_bottom)
{
/* If the toolbars are merged, it doesn't matter if we try */
/* to get the upper or lower toolbar object ID - the */
/* returned result will be the same. */
/* */
/* Can only merge things if there's a toolbar to look at! */
if (ttop)
{
/* See if the URL writable and status displays are to be merged. */
{
BBox sta, url;
/* If finding the BBox of either generates an error, can't */
/* say they're to be merged. */
if (
!gadget_get_bbox(0, ttop, URLBarWrit, &url) &&
!gadget_get_bbox(0, ttop, StatusBarStatus, &sta)
)
{
/* Otherwise, compare their bounding boxes. If identical, */
/* the two are to be merged. */
if (
url.xmin == sta.xmin &&
url.ymin == sta.ymin &&
url.xmax == sta.xmax &&
url.ymax == sta.ymax
)
{
b->merged_url = 1;
toolbars_merged_to_status(b, ttop);
}
/* Closure of long 'if' checking that the bounding boxes of */
/* the URL writable and status display fields were obtained */
/* without error (the code above excutes if this is true). */
}
}
/* See if there are any recognised bistate buttons present. */
/* Code is similar to the above URL/status merge code. */
{
BBox s1, s2;
int scrap;
/* Must have a working gadget, component ID ButtonBarBistate, */
/* to use the bistate button. */
if (!gadget_get_type(0, ttop, ButtonBarBistate, &scrap))
{
/* Check for type BiState_Cancel_Back */
if (
!gadget_get_bbox(0, ttop, ButtonBarCancel, &s1) &&
!gadget_get_bbox(0, ttop, ButtonBarBack, &s2)
)
{
if (
s1.xmin == s2.xmin &&
s1.ymin == s2.ymin &&
s1.xmax == s2.xmax &&
s1.ymax == s2.ymax
)
{
b->bistate = BiState_Cancel_Back;
/* Ensure the reference gadgets are hidden */
hide_gadget(ttop, ButtonBarBack);
hide_gadget(ttop, ButtonBarCancel);
/* Set the default starting state to 'Back' */
toolbars_set_bistate_state(b, ttop, 1);
}
}
}
}
/* See if there are any recognised tristate buttons present. */
/* Code is similar to the above bistate button code. */
{
BBox s1, s2, s3;
int scrap;
/* Must have a working gadget, component ID ButtonBarTristate, */
/* to use the tristate button. */
if (!gadget_get_type(0, ttop, ButtonBarTristate, &scrap))
{
/* Check for type TriState_Go_GoTo_Stop */
if (
!gadget_get_bbox(0, ttop, ButtonBarGo, &s1) &&
!gadget_get_bbox(0, ttop, ButtonBarGoTo, &s2) &&
!gadget_get_bbox(0, ttop, ButtonBarStop, &s3)
)
{
if (
s1.xmin == s2.xmin &&
s1.ymin == s2.ymin &&
s1.xmax == s2.xmax &&
s1.ymax == s2.ymax &&
s1.xmin == s3.xmin &&
s1.ymin == s3.ymin &&
s1.xmax == s3.xmax &&
s1.ymax == s3.ymax
)
{
b->tristate = TriState_Go_GoTo_Stop;
/* Ensure the reference gadgets are hidden */
hide_gadget(ttop, ButtonBarGoTo);
hide_gadget(ttop, ButtonBarGo);
hide_gadget(ttop, ButtonBarStop);
/* If fetching, set the tristate to 'stop', else 'go to'. */
if (url) toolbars_set_tristate_state(b, ttop, 2);
else toolbars_set_tristate_state(b, ttop, 1);
}
}
}
}
/* Closure of long 'if' checking the upper toolbar object ID */
/* was non-zero. If so, the code above executes. */
}
/* Closure of long 'if' checking that the upper and lower toolbars */
/* are merged into one; the code above executes if so. */
}
/* Set the default status. Must do this after the */
/* routines that process icon text etc. have been */
/* run, or the status routines could trash a */
/* special icon string before it's dealt with... */
toolbars_update_status(b, Toolbars_Status_Ready);
/* Closure of long 'if' checking if the window was a parent. The */
/* code above executes if so. */
}
/* Handler for on-page clicks */
RetError(event_register_wimp_handler(o,
Wimp_EMouseClick,
(WimpEventHandler *) handle_link_clicks,
b));
/* Open the window and register a Wimp handler that will be called */
/* whenever there is an Open Window request generated for the window */
/* (this deals with window extent settings etc.). */
if (!size) b->small_size.visible_area.xmin = b->small_size.visible_area.ymin = -1;
else b->small_size.visible_area = *size;
/* This call will fill in small_size depending on the above. */
if (save_type != Windows_CreateBrowser_ForPlugIn || choices.see_fetches) windows_show_browser(b);
/* Ensure the URL bar is up to date, and set the fetch status to BS_START. */
if (url)
{
toolbars_update_url(b);
b->fetch_status = BS_START;
}
/* Must be called after windows_show_browser so the parent/ancestor IDs are set up */
if (!real_parent)
{
BBox w;
toolbars_set_presence(b, InternalTopLeft | InternalBottomLeft);
/* Ensure that the window extent is at least as wide and tall */
/* as the minimum extent settings require. */
if (!b->small_fetch)
{
RetError(window_get_extent(0,o,&w));
if ((w.xmax - w.xmin) < MinimumWidth) w.xmin = 0, w.xmax = MinimumWidth;
if ((w.ymax - w.ymin) < MinimumHeight) w.ymin = -MinimumHeight, w.ymax = 0;
RetError(window_set_extent(0,o,&w));
/* Give the window the input focus, if it's an ancestor */
RetError(browser_give_general_focus(b));
}
}
/* Start a fetch for this page's current URL. Note the allow_cancel */
/* flag is unset, so that any flags set up above, which cancel */
/* functions may touch (e.g. save_link), will not be altered. */
if (url) e = fetchpage_new(b, b->urlfdata, 0, 0);
else if (b->small_fetch)
{
/* For a small fetch window, we may have no URL (Plug-Ins - already */
/* have the data in a file, and want the fetcher to be kicked */
/* briefly to notice the fetch is finished before it even started */
/* and fire off the relevant messages). */
fetchpage_claim_nulls(b);
}
/* Now ensure that future fetches may call fetch_cancel */
/* before proceeding. */
b->allow_cancel = 1;
return e;
/* Closure of long 'if' ensuring the mallocs for the browser_data */
/* and associated reformat_cell structures were successful - the */
/* code above only executes if so. */
}
}
/*************************************************/
/* windows_open_browser() */
/* */
/* (Re)opens a Browser window, setting extent if */
/* necessary. Parameters are as standard for a */
/* Wimp event handler. */
/* */
/* Assumes: The poll block and ID block */
/* pointers may be NULL, though in */
/* the latter case only for full */
/* screen opening; */
/* */
/* The event code is not read and */
/* can by any integer value; */
/* */
/* That the browser_data pointer is */
/* not NULL. */
/*************************************************/
int windows_open_browser(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
/* Internally... */
/* */
/* 's' holds the browser window state, and is a WimpGetWindowStateBlock */
/* 'w' holds various bits of data, and is a BBox. It always ends up holding */
/* information for setting the window extent. */
/* 't' is a BBox holding the browser window's initial extent. */
/* 'o' holds the current window outline, and is a WimpGetWindowOutlineBlock. */
/* It's used for the part of the code dealing with toggle size. */
/* 'i' is a WimpGetPointerInfoBlock and is briefly used in the toggle size */
/* code to see if Adjust was pressed, since then you don't want to bring */
/* the window to the front. */
/* */
/* The Wimp will have sent a poll block containing open_window_request */
/* data; this is in 'b'. The toolbox will have filled in an ID block 'idb' */
/* and the routine is called with 'handle' containing a pointer to a */
/* browser_data structure (though it has to be declared as a void * rather */
/* than browser_data * for the function to be a Wimp event handler, hence */
/* all the casting that goes on). */
WimpGetWindowStateBlock s;
BBox w, t;
/* One simple case is Full Screen handling. The '!idb' check is */
/* used for external functions which want to go to full screen */
/* mode; they can call this function with 0, NULL, NULL and the */
/* browser_data pointer (with full_screen set to 1, as this is */
/* needed generally) without worrying that part of idb may be */
/* needed within the function for some reason - it is used */
/* further down and if conditions on this first 'if' failed, */
/* there would be a problem if idb were not filled in. */
if ((handle->full_screen && modechanged) || !idb)
{
WimpGetWindowStateBlock state;
if (modechanged)
{
windows_open_full_screen(handle,
1,
0,
choices.v_scroll,
choices.h_scroll);
modechanged = 0;
}
/* Reformat if required */
state.window_handle = handle->window_handle;
ChkError(wimp_get_window_state(&state));
ChkError(frames_resize_frameset(handle, &state.visible_area));
windows_check_reformat(handle, &state.visible_area, handle->display_width);
}
else
{
int old_display_width;
/* Remember the current visible area width for use later, */
/* to see if a page reformat is needed. */
old_display_width = handle->display_width;
s.window_handle = b->open_window_request.window_handle;
ChkError(wimp_get_window_state(&s));
ChkError(window_get_extent(0,idb->self_id,&t));
/* Was this a toggle size event? If so, handle manually */
if ((s.flags & WimpWindow_Toggled) != 0)
{
WimpGetWindowOutlineBlock o;
int shift, ctrl, cmos;
/* First check if Shift is pressed; the 'shift' variable will hold */
/* 255 if pressed or 0 if not. This is because the full size window */
/* shouldn't obscure the icon bar if shift is held down. */
_swix(OS_Byte,
_INR(0,1) | _OUT(1),
121,
128,
&shift);
/* Similarly check for Control being held down. We'll only increase */
/* the vertical size if this is the case. */
_swix(OS_Byte,
_INR(0,1) | _OUT(1),
121,
129,
&ctrl);
/* Check CMOS RAM byte 28, bit 4 - if set, reverse the sense of Shift */
_swix(OS_Byte,
_INR(0,1) | _OUT(2),
161,
28,
&cmos);
if (cmos & (1u<<4)) shift = shift ? 0 : 255;
/* Read the screen size in OS units */
w.xmin = bbc_modevar(-1, BBC_XEigFactor);
w.ymin = bbc_modevar(-1, BBC_YEigFactor);
w.xmax = bbc_modevar(-1, BBC_XWindLimit);
w.ymax = bbc_modevar(-1, BBC_YWindLimit);
w.xmax = (w.xmax + 1) << w.xmin;
w.ymax = (w.ymax + 1) << w.ymin;
/* This isn't good enough, as we need to take account of the window */
/* frame and tools. Since the window must already be open, we can */
/* use Wimp_GetWindowOutline and compare this to the visible size, */
/* where the difference is the size of borders and tools. */
o.window_handle = b->open_window_request.window_handle;
ChkError(wimp_get_window_outline(&o));
w.xmin = (o.outline.xmax - o.outline.xmin) - (s.visible_area.xmax - s.visible_area.xmin);
w.ymin = (o.outline.ymax - o.outline.ymin) - (s.visible_area.ymax - s.visible_area.ymin);
/* Now have the information on the window dimensions to occupy the */
/* whole screen. */
if (!handle->full_size)
{
int h1, h2;
/* Toggle up to full size. First, remember the current (small) size. */
handle->small_size.visible_area = s.visible_area;
handle->small_size.xscroll = s.xscroll;
handle->small_size.yscroll = s.yscroll;
handle->small_size.behind = find_behind(b->open_window_request.window_handle);
/* Set the poll block contents to open the window in the right place. */
/* Notice if Shift is held down and don't cover icon bar, and if Ctrl */
/* is held down we leave the X positions alone. */
if (!ctrl)
{
b->open_window_request.visible_area.xmin = 2;
b->open_window_request.visible_area.xmax = w.xmax - w.xmin + 2;
}
else
{
b->open_window_request.visible_area.xmin = s.visible_area.xmin;
b->open_window_request.visible_area.xmax = s.visible_area.xmax;
w.xmin = s.visible_area.xmin;
w.xmax = s.visible_area.xmax;
}
b->open_window_request.visible_area.ymin = s.visible_area.ymin - o.outline.ymin + (shift ? 128 : 0);
b->open_window_request.visible_area.ymax = w.ymax - w.ymin + (s.visible_area.ymin - o.outline.ymin);
/* Is adjust being pressed? If so, want to open at the same place */
/* in the window stack as at present. NB, the Wimp seems to take */
/* Select as higher priority than Adjust, so if both are pressed */
/* the window is brought to the front. This is why the code looks */
/* at the state of both buttons. */
{
WimpGetPointerInfoBlock i;
ChkError(wimp_get_pointer_info(&i));
if (
(i.button_state & Wimp_MouseButtonAdjust) != 0 &&
(i.button_state & Wimp_MouseButtonSelect) == 0
)
b->open_window_request.behind = s.behind;
else b->open_window_request.behind = -1;
}
/* Ensure horizontal and vertical extent isn't too small, and don't ever */
/* shrink them - only reformat_set_extent is allowed to do that, in */
/* Reformat.c. The exception case is if the parent window has child */
/* frames, in which case we want the extent to track the visible area */
/* exactly, at all times. */
if (!handle->nchildren)
{
BBox extent;
if (w.xmax - w.xmin < handle->display_extent) w.xmin = 0, w.xmax = handle->display_extent;
window_get_extent(0,idb->self_id,&extent);
if (w.ymax - w.ymin < extent.ymax - extent.ymin) w.ymax = w.ymin + extent.ymax - extent.ymin;
if (w.ymax - w.ymin < MinimumHeight) w.ymax = w.ymin + MinimumHeight;
}
ChkError(set_corrected_extent(0, idb->self_id, &w));
/* Show the object */
ChkError(toolbox_show_object(0,
idb->self_id,
1,
&(b->open_window_request.visible_area),
idb->parent_id,
-1));
/* Flag that the window is full size */
handle->full_size = 1;
/* Make sure the toolbars, if present, are up to date */
if (choices.move_gadgets != Choices_MoveGadgets_Never) toolbars_move_gadgets(handle);
/* Update the visible area width and height fields */
handle->display_width = b->open_window_request.visible_area.xmax -
b->open_window_request.visible_area.xmin;
h1 = toolbars_button_height(handle) + toolbars_url_height(handle);
h2 = toolbars_status_height(handle);
if (h1) h1 += wimpt_dy();
if (h2) h2 += wimpt_dy();
handle->display_height = b->open_window_request.visible_area.ymax -
b->open_window_request.visible_area.ymin -
h1 -
h2;
/* Resize any child frames and reformat if necessary */
ChkError(frames_resize_frameset(handle, &b->open_window_request.visible_area));
windows_check_reformat(handle, &b->open_window_request.visible_area, old_display_width);
}
else
{
int h1, h2;
w = handle->small_size.visible_area;
/* An irritating feature of the Wimp - if you call Wimp_SetExtent, */
/* then the next Wimp_OpenWindow call is forced on-screen. This */
/* means that if toggle size is used when the window is partially */
/* dragged off-screen, then the shrinking horizontal extent when */
/* it is toggled back would ensure that the window was brought */
/* back fully on screen. Sometimes this is annoying. */
/* */
/* It turns out though, that if the window is *already* partially */
/* off-screen when the SetExtent call is made, the Wimp brings the */
/* window (internally) back on screen, and doesn't bother to do */
/* this on the next OpenWindow call. So to allow the window to be */
/* toggled back to a small size which may be partially off-screen, */
/* we open the window miles off screen somewhere before setting */
/* the extent. */
/* */
/* This is not pretty but it is relatively solid; the worst that */
/* can happen is the Wimp *does* decide to force the window back */
/* on screen at the next OpenWindow call, in which case the */
/* behaviour is as it would be without the extra code here. */
b->open_window_request.visible_area.xmin = w.xmin + 16384;
b->open_window_request.visible_area.ymin = w.ymin - 16384;
b->open_window_request.visible_area.xmax = w.xmax + 16384;
b->open_window_request.visible_area.ymax = w.ymax - 16384;
b->open_window_request.behind = handle->small_size.behind;
toolbox_show_object(0,
idb->self_id,
1,
&(b->open_window_request.visible_area),
idb->parent_id,
-1);
/* Store the new details in b for later use in the show_object call */
b->open_window_request.visible_area = w;
b->open_window_request.xscroll = handle->small_size.xscroll;
b->open_window_request.yscroll = handle->small_size.yscroll;
b->open_window_request.behind = handle->small_size.behind;
/* Set the extent, with usual restrictions on when not to shrink it (see */
/* elsewhere for more information, around similar pieces of code) */
if (!handle->nchildren)
{
BBox extent;
if (w.xmax - w.xmin < handle->display_extent) w.xmin = 0, w.xmax = handle->display_extent;
window_get_extent(0,idb->self_id,&extent);
if (w.ymax - w.ymin < extent.ymax - extent.ymin) w.ymax = w.ymin + extent.ymax - extent.ymin;
if (w.ymax - w.ymin < MinimumHeight) w.ymax = w.ymin + MinimumHeight;
}
ChkError(set_corrected_extent(0, idb->self_id, &w));
ChkError(toolbox_show_object(0,
idb->self_id,
1,
&(b->open_window_request.visible_area),
idb->parent_id,
-1));
handle->full_size = 0;
/* Make sure the toolbars, if present, are up to date */
if (choices.move_gadgets != Choices_MoveGadgets_Never) toolbars_move_gadgets(handle);
/* Update the visible area width and height fields */
handle->display_width = b->open_window_request.visible_area.xmax -
b->open_window_request.visible_area.xmin;
h1 = toolbars_button_height(handle) + toolbars_url_height(handle);
h2 = toolbars_status_height(handle);
if (h1) h1 += wimpt_dy();
if (h2) h2 += wimpt_dy();
handle->display_height = b->open_window_request.visible_area.ymax -
b->open_window_request.visible_area.ymin -
h1 -
h2;
/* Resize any child frames and reformat if needed */
ChkError(frames_resize_frameset(handle, &b->open_window_request.visible_area));
windows_check_reformat(handle, &b->open_window_request.visible_area, old_display_width);
}
}
/* This isn't a Toggle Size event; so move or resize. Whilst the */
/* Toggle Size code above remembers the small size of a window if */
/* toggling up to full screen, this isn't enough as the user can */
/* drag the window to full size, particularly if the machine has */
/* been configured to allow windows off screen to the bottom and */
/* right of the screen. In this case, dragging the resize icon of */
/* a window off screen shuffles the window up and/or left, so it */
/* becomes easy to drag out to full screen. In this case, we don't */
/* know what the small size of the window was before the drag */
/* began, and so we can't return to it when the toggle size icon */
/* is used - you end up with the *previously stored* small size. */
/* */
/* To get round this, we need to install a null event handler when */
/* a window drag is detected. As soon as a null event is received */
/* without a mouse button being pressed, the drag must have ended. */
/* We can then check the size of the window, and if it isn't full */
/* screen, remember that size for toggle size later on. It's very */
/* long winded but that's what you get for taking over the window */
/* handling to such an extent...! */
else
{
/* For child frames (i.e. browser_data structs with a filled in ancestor field), */
/* this function will only be called from frames_resize_frames itself. This in */
/* turn is originally only called if the ancestor window resizes in some way. */
/* It's not possible to apply the 'has the visible area changed' check as */
/* rounding errors can lead to some frames just shuffling a bit, not resizing, */
/* and any children they had would then not be resized (or rather, moved) to fit */
/* the parent. */
/* */
/* We would in theory want to resize (and implicitly move) any frames even if */
/* the parent window moves, but doesn't resize. In the case of the nested Wimp */
/* though, the children are moved for you and moving them again produces some */
/* very odd effects! Consequently there are checks for the nested_wimp flag in */
/* the code. */
if (handle->ancestor || !nested_wimp)
{
ChkError(frames_resize_frameset(handle, &b->open_window_request.visible_area));
}
/* Claim null events, if they aren't already being claimed */
if (!handle->watching_resize)
{
register_null_claimant(Wimp_ENull,(WimpEventHandler *) windows_remember_size,(void *) idb->self_id);
handle->watching_resize = 1;
}
/* If the current and Wimp requested visible areas are the same in */
/* terms of horizontal and vertical size, the window is being */
/* moved; so don't do any extent setting stuff. However, if the */
/* Force On Screen bit is set, the then window has been shrunk or */
/* moved due to a mode change, so make sure the extent is right */
/* and the toolbars are set up correctly. Because the Wimp won't */
/* actually set the window size up for us until the next call to */
/* WimpOpenWindow, we need a separate handler for this case. */
if (
b->open_window_request.visible_area.xmax - b->open_window_request.visible_area.xmin != s.visible_area.xmax - s.visible_area.xmin ||
b->open_window_request.visible_area.ymax - b->open_window_request.visible_area.ymin != s.visible_area.ymax - s.visible_area.ymin ||
modechanged
)
{
/* See comments on the previous line that called frames_resize_frameset; */
/* for the ancestor, want to only resize frames if the ancestor resized, */
/* unless in a non-nested Wimp variant. */
if (nested_wimp && !handle->ancestor)
{
ChkError(frames_resize_frameset(handle, &b->open_window_request.visible_area));
}
if (modechanged)
{
/* If there's been a mode change, call Wimp_OpenWindow to get the window's */
/* correct visible area and then sort out the correct extent. */
toolbox_show_object(0,
idb->self_id,
1,
&(b->open_window_request.visible_area),
idb->parent_id,
-1);
wimp_get_window_state(&s);
w = s.visible_area;
}
else
{
/* The requested visible area is different, so consider this to be a window */
/* resize event. In this case, set the horizontal extent to the visible */
/* area, provided this means the extent has grown. */
w = b->open_window_request.visible_area;
}
/* Set the extent, with usual restrictions on when not to shrink it (see */
/* elsewhere for more information, around similar pieces of code) */
if (!handle->nchildren)
{
BBox extent;
//Printf("woo, resizing\n");
if (w.xmax - w.xmin < handle->display_extent) w.xmin = 0, w.xmax = handle->display_extent;
window_get_extent(0,idb->self_id,&extent);
if (w.ymax - w.ymin < extent.ymax - extent.ymin) w.ymax = w.ymin + extent.ymax - extent.ymin;
if (w.ymax - w.ymin < MinimumHeight) w.ymax = w.ymin + MinimumHeight;
}
ChkError(set_corrected_extent(0, idb->self_id, &w));
if (modechanged) modechanged = 0;
/* Show the object */
toolbox_show_object(0,
idb->self_id,
1,
&(b->open_window_request.visible_area),
idb->parent_id,
-1);
/* Ensure toolbar gadgets are up to date */
if (choices.move_gadgets == Choices_MoveGadgets_During) toolbars_move_gadgets(handle);
/* If an ancestor is highlighted, remove the highlight */
if (!handle->ancestor && handle == highlight_frame) frames_remove_highlight();
}
else
{
/* Nothing has altered size; just move the window */
toolbox_show_object(0,
idb->self_id,
1,
&(b->open_window_request.visible_area),
idb->parent_id,
-1);
}
}
}
return 1;
}
/*************************************************/
/* windows_remember_size() */
/* */
/* This event handler is registered when an Open */
/* Window request is received by the event */
/* handler windows_open_browser, which should be */
/* referred to for more information. This */
/* handler is called on null polls, and when no */
/* mouse buttons are being pressed, deregisters */
/* itself and looks at the browser window it is */
/* associated with. If the window is not open */
/* full size, the size is remembered so that the */
/* toggle size code in windows_open_browser can */
/* operate correctly. */
/*************************************************/
int windows_remember_size(int eventcode, WimpPollBlock * b, IdBlock * idb, void * handle)
{
WimpGetPointerInfoBlock p;
browser_data * d;
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_remember_size: Called\n");
#endif
/* First thing - move the gadgets, if the choices indicate that */
/* we should, to fit the current window size. */
ChkError(toolbox_get_client_handle(0, (ObjectId) handle, (void *) &d));
/* Is this a valid pointer? If not, exit */
if (!is_known_browser(d)) return 0;
/* Otherwise, proceed */
if (choices.move_gadgets == Choices_MoveGadgets_AtEnd) toolbars_move_gadgets(d);
/* Are buttons being pressed? */
ChkError(wimp_get_pointer_info(&p));
/* If not... */
if (!p.button_state)
{
WimpGetWindowOutlineBlock o;
WimpGetWindowStateBlock s;
BBox w;
/* Deregister the null event handler and flag that we */
/* are not watching resize events anymore. */
deregister_null_claimant(Wimp_ENull,(WimpEventHandler *) windows_remember_size,handle);
d->watching_resize = 0;
/* Get the window state (of interest is the visible area) */
/* and it's outline. This is so we can later work out the */
/* size of the window's tools. */
s.window_handle = d->window_handle;
o.window_handle = s.window_handle;
ChkError(wimp_get_window_state(&s));
ChkError(wimp_get_window_outline(&o));
/* Read the screen size in OS units */
w.xmin = bbc_modevar(-1, BBC_XEigFactor);
w.ymin = bbc_modevar(-1, BBC_YEigFactor);
w.xmax = bbc_modevar(-1, BBC_XWindLimit);
w.ymax = bbc_modevar(-1, BBC_YWindLimit);
w.xmax = (w.xmax + 1) << w.xmin;
w.ymax = (w.ymax + 1) << w.ymin;
/* Take account of window tools using Wimp_GetWindowOutline info from above */
w.xmin = (o.outline.xmax - o.outline.xmin) - (s.visible_area.xmax - s.visible_area.xmin);
w.ymin = (o.outline.ymax - o.outline.ymin) - (s.visible_area.ymax - s.visible_area.ymin);
/* Now know what the extent would be for a full screen window, so */
/* compare that to the current visible size. */
if (((s.visible_area.xmax - s.visible_area.xmin) < (w.xmax - w.xmin))
| ((s.visible_area.ymax - s.visible_area.ymin) < (w.ymax - w.ymin)))
{
/* Window isn't full screen, so remember the size */
d->small_size.visible_area = s.visible_area;
d->small_size.behind = find_behind(s.window_handle);
d->full_size = 0;
}
else d->full_size = 1;
/* Update the visible area width field */
{
int width;
width = s.visible_area.xmax - s.visible_area.xmin;
if (width < MinimumWidth) width = MinimumWidth;
/* Tolerance is defined in Windows.h. We leave the display_width */
/* field alone until the change since it was last updated has */
/* exceeded the tolerance value, at which point it is set to the */
/* visible width (along with display_extent) and the page gets */
/* reformatted from the top. */
if (width != d->display_width)
{
if (
width - d->display_width > Tolerance ||
width - d->display_width < -Tolerance
)
{
if (!d->page_is_text)
{
int h1, h2;
d->display_extent = d->display_width = width;
h1 = toolbars_button_height(d) + toolbars_url_height(d);
h2 = toolbars_status_height(d);
if (h1) h1 += wimpt_dy();
if (h2) h2 += wimpt_dy();
d->display_height = s.visible_area.ymax - s.visible_area.ymin - h1 - h2;
if (d->ancestor) windows_set_tools(d, &s.visible_area, 0, 0, 0, 0);
reformat_format_from(d, -1, 1, -1);
}
}
/* Leaving display_width alone has the side effect that centred */
/* objects stay centred relative to that value, not the slightly */
/* altered visible width, so no redraw problems occur if we */
/* don't bother forcing a redraw if the reformat isn't done. */
/* */
/* Hence, no 'else' case here. */
}
}
/* In any case remember the scroll position, or it could jump */
/* around when the small window size is later restored. */
d->small_size.xscroll = s.xscroll;
d->small_size.yscroll = s.yscroll;
}
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_remember_size: Successful\n");
#endif
return 0;
}
/*************************************************/
/* windows_close_browser() */
/* */
/* Closes a Browser window, freeing up memory */
/* claimed for it. */
/* */
/* This DOES NOT CLOSE FRAMESETS, and memory */
/* claimed for that isn't freed. You should use */
/* the frames collapsing functions in Frames.c */
/* to do this. If there's any doubt, always */
/* close through the general handler in */
/* c.Handlers as this takes care of frames. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the window. */
/*************************************************/
void windows_close_browser(browser_data * handle)
{
browser_data * ancestor = handle->ancestor; /* Not utils_ancestor() as we want to know if 'ancestor' is NULL later */
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_close_browser: Called\n");
#endif
/* This may take a while if there's lots of flex freeing to do... */
_swix(Hourglass_Start, _IN(0), 10);
/* Cancel any fetches */
ChkError(fetch_cancel(handle));
/* Stop the later code trying to destroy source / close the stream twice */
if (handle->fetch_handle == handle->display_handle) handle->display_handle = 0;
/* If this frame is highlighted, this will clear that highlight */
ChkError(frames_remove_highlight_if_present(handle));
/* If the Open URL dialogue was opened from the window, this will close it */
ChkError(openurl_close(handle->self_id, 0));
/* If a main menu is open for the window, this closes it */
menus_close_document_if_mine(handle);
/* If the Print dialogue was opened from the window, this will close */
/* it and the Print Style window (again, if open). */
ChkError(print_close(handle->self_id, 0));
/* If there is an ancestor and it has a selected token, */
/* is that token in this window? If so, want to clear */
/* that selection. At the same time, deal with status */
/* bar issues. */
if (ancestor)
{
if (ancestor->selected_owner == handle)
{
ancestor->selected = NULL;
ancestor->selected_owner = NULL;
}
if (ancestor->selected_frame == handle) ancestor->selected_frame = NULL;
/* Ensure that this window is removed from the array of */
/* status_contents structures associated with the */
/* ancestor's status bar. */
ChkError(toolbars_remove_status_item(handle, ancestor));
}
/* Get rid of any attached event handlers on the window and its */
/* toolbars (if any). */
/* */
/* Because null events need to be claimed/released through the */
/* pollword, need to still use the internal routine to get rid */
/* of null event handlers, before calling the general eventlib */
/* routine to remove anything else. Otherwise the internal */
/* counter checking if nulls should be released won't be */
/* decremented correctly (Bad Things May Then Happen...). */
if (handle->watching_resize) deregister_null_claimant(Wimp_ENull,(WimpEventHandler *) windows_remember_size,(void *) handle->self_id);
handle->watching_resize = 0;
if (handle->fetch_handler) fetchpage_release_nulls(handle);
if (handle->anim_drift)
{
deregister_null_claimant(Wimp_ENull,(WimpEventHandler *) toolbars_animation_drift, handle);
handle->anim_drift = 0;
}
if (handle->plugin_active)
{
deregister_null_claimant(Wimp_ENull,(WimpEventHandler *) toolbars_animation, handle);
handle->plugin_active = 0;
}
if (handle->status_handler) deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) toolbars_timeout_status, handle);
handle->status_handler = 0;
reformat_stop_pending(handle); /* Deregisters stuff as required */
if (handle->meta_refresh_at) deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) meta_check_refresh, handle);
handle->meta_refresh_at = 0;
if (handle->dragging) deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) handle_drags, handle);
handle->dragging = 0;
drag_in_progress = 0;
/* If watching the dialler's status changed service call, */
/* or displaying online time, remove the relevant handlers. */
if (handle->dialler_status) event_deregister_message_handler(Message_Service, handle_dialler_service, handle);
if (handle->dialler_last) deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) handle_dialler_display, handle);
handle->dialler_status = 0;
handle->dialler_last = 0;
/* Remove any pointer-related handlers */
browser_pointer_over_deleted(handle);
/* Now release everything else */
{
ObjectId tupper, tlower;
/* Handlers for the main window */
ChkError(event_deregister_wimp_handlers_for_object(handle->self_id));
ChkError(event_deregister_toolbox_handlers_for_object(handle->self_id));
tupper = toolbars_get_upper(handle);
if (tupper)
{
/* Handlers for the upper toolbar */
ChkError(event_deregister_wimp_handlers_for_object(tupper));
ChkError(event_deregister_toolbox_handlers_for_object(tupper));
}
tlower = toolbars_get_lower(handle);
if (tlower && tlower != tupper)
{
/* Handlers for the lower toolbar */
ChkError(event_deregister_wimp_handlers_for_object(tlower));
ChkError(event_deregister_toolbox_handlers_for_object(tlower));
}
}
/* Delete any related run-time created objects */
if (handle->save_dbox)
{
ChkError(toolbox_delete_object(0, handle->save_dbox));
handle->save_dbox = 0;
}
/* Get rid of the fetched source / stream */
browser_destroy_source(handle);
if (handle->fetch_handle)
{
ChkError(html_close(handle->fetch_handle));
}
if (handle->display_handle)
{
ChkError(html_close(handle->display_handle));
}
/* Close any saving files */
if (handle->save_file)
{
fclose(handle->save_file);
handle->save_file = NULL;
}
/* Get rid of any pending message blocks */
if (handle->pending_data_load)
{
free(handle->pending_data_load);
#ifdef TRACE
malloccount -= sizeof(WimpMessage);
if (tl & (1u<<13)) Printf("** malloccount (windows_close_browser): \0211%d\0217\n",malloccount);
#endif
}
/* If we were streaming data for a Plug-In, close the */
/* stream. */
if (handle->pstream) plugin_abort_stream(handle);
/* Get rid of forms related data */
ChkError(form_discard(handle));
/* Get rid of any extra forms data */
#ifdef TRACE
if (handle->post_data)
{
if (tl & (1u<<12)) Printf("windows_close_browser: flex_free block %p\n",&handle->post_data);
flexcount -= flex_size((flex_ptr) &handle->post_data);
if (tl & (1u<<13)) Printf("** flexcount: %d\n",flexcount);
}
#endif
if (handle->post_data) flex_free((flex_ptr) &handle->post_data);
/* Remove any Plug-In status message */
free(handle->plugin_status);
handle->plugin_status = NULL;
/* Remove any History references */
history_remove(handle, NULL);
/* Get rid of images and Objects */
ChkError(image_discard(handle));
ChkError(object_discard(handle));
#ifdef TRACE
if ((tl & (1u<<3)) && handle->ancestor)
{
Printf("\nwindows_close_browser: Structure %p is a child structure, ancestor %p\n",handle,handle->ancestor);
if (handle->nchildren) Printf(" and has children.\n");
else Printf(" and has no children.\n");
}
#endif
/* Delete the window object. */
ChkError(toolbox_delete_object(0,handle->self_id));
#ifdef TRACE
if (tl & (1u<<3)) Printf("\nDeleted object ID %p\n",(void *) handle->self_id);
#endif
/* Ensure any line list data relating to tables is freed */
#ifdef TRACE
if (tl & (1u<<12)) Printf("windows_close_browser: Freeing table chunks\n");
#endif
tables_free_memory(1, handle, handle->cell, 0);
/* Ensure all memory chunks are freed */
#ifdef TRACE
if (tl & (1u<<12)) Printf("windows_close_browser: Chunk CK_FURL\n"
" CK_DURL\n"
" CK_CHIL\n"
" CK_NAME\n"
" CK_FWID\n"
" CK_FHEI\n"
" CK_LINE\n"
" CK_LDAT\n"
" CK_STAT set to 0\n");
#endif
ChkError(memory_set_chunk_size(handle, NULL, CK_FURL, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_DURL, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_CHIL, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_NAME, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_FWID, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_FHEI, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_LINE, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_LDAT, 0));
ChkError(memory_set_chunk_size(handle, NULL, CK_STAT, 0));
/* Lose any claimed fonts */
fm_lose_fonts(handle);
/* Sort out the linked list next and previous pointers in */
/* the previous and next entries to this one (if they are */
/* present) */
if (handle->previous) (handle->previous)->next = handle->next;
if (handle->next) (handle->next)->previous = handle->previous;
else last_browser = handle->previous;
#ifdef TRACE
if (tl & (1u<<3))
{
if (handle->previous) Printf("Previous structure %p: Next field pointed at %p.\n",(void *) handle->previous, (void *) handle->next);
else Printf("No Previous structure\n");
if (handle->next) Printf("Next structure %p: Previous field pointed at %p.\n",(void *) handle->next, (void *) handle->previous);
else Printf("No Next structure, last_browser set to previous\n");
}
#endif
/* Finally, free the browser_data and associated reformat_cell structures */
#ifdef TRACE
if (tl & (1u<<12)) Printf("windows_close_browser: free block %p, which held 'reformat_cell' structure\n",handle->cell);
malloccount -= sizeof(reformat_cell);
if (tl & (1u<<13)) Printf("** malloccount (windows_close_browser): \0212%d\0217\n",malloccount);
#endif
free(handle->cell);
#ifdef TRACE
if (tl & (1u<<12)) Printf("windows_close_browser: free block %p, which held 'browser_data' structure\n",handle);
malloccount -= sizeof(browser_data);
if (tl & (1u<<13)) Printf("** malloccount (windows_close_browser): \0212%d\0217\n",malloccount);
#endif
free(handle);
#ifdef TRACE
if (tl & (1u<<3)) Printf("Structure memory freed\n");
#endif
_swix(Hourglass_Off, 0);
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_close_browser: Successful\n");
#endif
return;
}
/*************************************************/
/* windows_redraw_browser() */
/* */
/* Called on receiving a redraw request from the */
/* Wimp. Calls the browser redraw routines. */
/* */
/* Parameters are as for a standard Wimp event */
/* handler. */
/*************************************************/
int windows_redraw_browser(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
WimpRedrawWindowBlock * redraw = (WimpRedrawWindowBlock *) b;
int more;
ChkError(wimp_redraw_window(redraw, &more));
if (more)
{
ChkError(redraw_draw(handle,
redraw,
0,
0));
}
return 1;
}
/*************************************************/
/* windows_show_browser() */
/* */
/* Shows a browser window, initially centred on */
/* the screen but futher windows are opened at */
/* successive sensible offsets to avoid them */
/* exactly overlapping one another. */
/* */
/* This default show position can be overridden */
/* in two ways; though the Choices specifying an */
/* absolute position to open at, or through the */
/* small_size.visible_area field of the */
/* browser_data struct holding an xmin and ymin */
/* that are not -1 on entry. */
/* */
/* Small fetch windows will be shown near the */
/* pointer. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the window, with the */
/* small_size.visible_area BBox */
/* filled in with -1 or a valid */
/* visible area as described above. */
/*************************************************/
void windows_show_browser(browser_data * b)
{
WimpOpenWindowBlock w;
static int offset;
ObjectId p, o;
int fixed_size = 0;
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_show_browser: Called\n");
#endif
o = b->self_id;
if (!b->small_fetch)
{
/* Is there a valid small_size.visible_area block? */
if (b->small_size.visible_area.xmin != -1 && b->small_size.visible_area.ymin != -1)
{
w.visible_area = b->small_size.visible_area;
fixed_size = 1;
}
else
{
fixed_size = 0;
/* Find the screen x and y size in pixels and scale them */
/* to OS units using OS_ReadModeVariable calls via. the */
/* bbc_modevar function; also work out the top left */
/* coordinates at the same time. */
if (!choices.override_x)
{
w.visible_area.xmax = choices.width;
w.xscroll = bbc_modevar(-1, BBC_XWindLimit);
w.yscroll = bbc_modevar(-1, BBC_XEigFactor);
w.visible_area.xmin = (((w.xscroll + 1) << w.yscroll) - w.visible_area.xmax) / 2;
w.visible_area.xmax += w.visible_area.xmin;
}
else
{
w.visible_area.xmin = choices.override_x;
w.visible_area.xmax = choices.width + choices.override_x;
}
if (!choices.override_y)
{
w.visible_area.ymin = choices.height;
w.xscroll = bbc_modevar(-1, BBC_YWindLimit);
w.yscroll = bbc_modevar(-1, BBC_YEigFactor);
w.visible_area.ymax = (((w.xscroll + 1) << w.yscroll) + w.visible_area.ymin) / 2;
w.visible_area.ymin = w.visible_area.ymax - w.visible_area.ymin;
}
else
{
w.visible_area.ymin = choices.override_y;
w.visible_area.ymax = choices.height + choices.override_y;
}
/* Handle offset for successive windows, but don't cover */
/* up the icon bar */
if ((w.visible_area.ymin - offset) >= 132)
{
w.visible_area.ymin -= offset;
w.visible_area.ymax -= offset;
offset += 48;
}
else offset = 48;
}
w.xscroll = 0;
w.yscroll = 0;
w.behind = -1;
ChkError(set_corrected_extent(0, o, &w.visible_area));
}
ChkError(toolbox_get_parent(0,o,&p,NULL));
if (!b->ancestor || !nested_wimp)
{
/* For an ancestor window (i.e. a window which does not have */
/* an ancestor itself) or no nested Wimp, open it as normal. */
if (!b->small_fetch)
{
ChkError(toolbox_show_object(0,
o,
Toolbox_ShowObject_FullSpec,
&w.visible_area,
p,
-1));
}
else
{
ChkError(toolbox_show_object(0,
o,
Toolbox_ShowObject_AtPointer,
NULL,
p,
-1));
}
}
else
{
/* Otherwise, take advantage of the nested Wimp for child windows */
WindowShowObjectBlock show;
WimpGetWindowStateBlock state;
state.window_handle = b->ancestor->window_handle;
ChkError(wimp_get_window_state(&state));
show.visible_area = w.visible_area;
show.xscroll = w.xscroll;
show.yscroll = w.yscroll;
show.behind = w.behind;
show.parent_window_handle = (b->ancestor)->window_handle;
show.alignment_flags = Alignment_LeftEdge_WorkArea | Alignment_RightEdge_WorkArea |
Alignment_TopEdge_WorkArea | Alignment_BottomEdge_WorkArea |
Alignment_XScroll_WorkArea | Alignment_YScroll_WorkArea;
ChkError(toolbox_show_object(Toolbox_ShowObject_AsSubWindow,
o,
Toolbox_ShowObject_FullSpec,
&show,
p,
-1));
}
if (!fixed_size && !b->small_fetch)
{
/* Fill in the small_size information for the window in its */
/* browser_data structure */
b->small_size.visible_area = w.visible_area;
/* Now that the window is open, can get it's outline etc.; */
/* so can go up to full screen if required. */
if (b->full_screen) windows_open_full_screen(b,
1,
0,
choices.v_scroll,
choices.h_scroll);
}
/* If the requested size was larger than the available screen, */
/* (most often seen on A5000s where 640x480x256 is in use and */
/* a new browser window is opened - the Choices want to make */
/* it larger than the space that's availale) */
//
//
//
// /* Opening width considerations... */
//
// b->display_width = b->display_extent = width;
//
// if (b->display_extent < MinimumWidth) b->display_extent = MinimumWidth, b->display_width = MinimumWidth;
//
// /* ...and opening height */
//
// b->display_height = height;
//
//
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_show_browser: Successful\n");
#endif
}
/*************************************************/
/* windows_open_full_screen() */
/* */
/* Opens a browser window Full Screen or small, */
/* optionally recording its previous size in the */
/* small_size fields when going to Full Screen. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the window; */
/* */
/* 1 for Full Screen, else 0; */
/* */
/* 1 to record the size, else 0; */
/* */
/* 1 to leave a vertical scroll bar */
/* visible, else 0; */
/* */
/* 1 to leave a horizontal scroll */
/* bar visible, else 0. */
/*************************************************/
_kernel_oserror * windows_open_full_screen(browser_data * b, int full_screen, int record, int vertsc, int horisc)
{
BBox w;
WimpOpenWindowBlock o;
WimpGetWindowStateBlock s;
WimpGetWindowOutlineBlock outline;
ObjectId parent;
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_open_full_screen: Called\n");
#endif
/* Get the window state (for flags, scroll etc.) and its outline. */
s.window_handle = o.window_handle = outline.window_handle = b->window_handle;
RetError(wimp_get_window_state(&s));
RetError(wimp_get_window_outline(&outline));
/* If being asked to open to Full Screen, set up the BBox 'w' to */
/* hold a visible area appropriate to a full screen window. */
if (full_screen)
{
/* Get the screen size in OS units */
w.xmin = bbc_modevar(-1, BBC_XEigFactor);
w.ymin = bbc_modevar(-1, BBC_YEigFactor);
w.xmax = bbc_modevar(-1, BBC_XWindLimit);
w.ymax = bbc_modevar(-1, BBC_YWindLimit);
w.xmax = (w.xmax + 1) << w.xmin;
w.ymax = (w.ymax + 1) << w.ymin;
w.xmax -= ((s.flags & WimpWindow_VScroll) && (choices.v_scroll)) ? (outline.outline.xmax - s.visible_area.xmax) : 2;
w.xmin = 2;
w.ymax -= 2;
w.ymin = ((s.flags & WimpWindow_HScroll) && (choices.h_scroll)) ? (s.visible_area.ymin - outline.outline.ymin) : 2;
if (record)
{
/* Remember the current (small) size */
b->small_size.visible_area = s.visible_area;
b->small_size.xscroll = s.xscroll;
b->small_size.yscroll = s.yscroll;
b->small_size.behind = -1;
}
}
/* Otherwise, go back to the visible area stored in the window's */
/* small_size.visible_area BBox. */
else
{
/* Revert to a previously stored small size */
w = b->small_size.visible_area;
}
/* An irritating feature of the Wimp - if you call Wimp_SetExtent, */
/* then the next Wimp_OpenWindow call is forced on-screen. This */
/* means that if toggle size is used when the window is partially */
/* dragged off-screen, then the shrinking horizontal extent when */
/* it is toggled back would ensure that the window was brought */
/* back fully on screen. Sometimes this is annoying. */
/* */
/* It turns out though, that if the window is *already* partially */
/* off-screen when the SetExtent call is made, the Wimp brings the */
/* window (internally) back on screen, and doesn't bother to do */
/* this on the next OpenWindow call. So to allow the window to be */
/* toggled back to a small size which may be partially off-screen, */
/* we open the window miles off screen somewhere before setting */
/* the extent. */
/* */
/* This is not pretty but it is relatively solid; the worst that */
/* can happen is the Wimp *does* decide to force the window back */
/* on screen at the next OpenWindow call, in which case the */
/* behaviour is as it would be without the extra code here. */
o.visible_area.xmin = w.xmin + 16384;
o.visible_area.ymin = w.ymin - 16384;
o.visible_area.xmax = w.xmax + 16384;
o.visible_area.ymax = w.ymax - 16384;
o.behind = -1;
/* Show the object off-screen, making sure we don't trash the parent object ID information */
RetError(toolbox_get_parent (0, b->self_id, &parent, NULL));
RetError(toolbox_show_object(0, b->self_id, 1, &o.visible_area,parent, -1));
/* Set up the OpenWindow block */
o.window_handle = b->window_handle;
o.visible_area = w;
o.xscroll = s.xscroll;
o.yscroll = s.yscroll;
o.behind = -1;
/* w holds the extent we require. If the horizontal extent is smaller */
/* than the horizontal minimum defined for this window, make sure it */
/* is increased to that minimum. Ensure also that the vertical */
/* extent isn't too small, and never shrink it either. Note that the */
/* exception case is for when the parent has child frames - in that */
/* case, leave w alone, so the extent will track the visible area */
/* exactly (which is the desired effect). */
if (!b->nchildren)
{
BBox extent;
if (w.xmax - w.xmin < MinimumWidth) w.xmax = w.xmin + MinimumWidth;
window_get_extent(0,b->self_id,&extent);
if (w.ymax - w.ymin < extent.ymax - extent.ymin) w.ymax = w.ymin + extent.ymax - extent.ymin;
if (w.ymax - w.ymin < MinimumHeight) w.ymax = w.ymin + MinimumHeight;
}
RetError(set_corrected_extent(0, b->self_id, &w));
/* If the Wimp supports changing window flags, set the */
/* Back and No Bounds bits for a full screen show, */
/* else clear them. */
if (nested_wimp)
{
unsigned int clear, eor;
clear = (
(choices.full_screen && controls.back_window)
?
WimpWindow_Back
:
0
)
| WimpWindow_NoBounds;
if (full_screen) eor = clear;
else eor = 0;
RetError(set_window_flags(b->window_handle, clear, eor));
}
/* Show the object in the correct on-screen position */
RetError(toolbox_show_object(0,
b->self_id,
1,
&o.visible_area,
parent,
-1));
/* Make sure the toolbars, if present, are up to date */
if (choices.move_gadgets != Choices_MoveGadgets_Never) toolbars_move_gadgets(b);
/* Update the visible area width and height fields */
b->display_width = b->display_extent = o.visible_area.xmax - o.visible_area.xmin;
if (b->display_extent < MinimumWidth) b->display_width = b->display_extent = MinimumWidth;
{
int h1, h2;
h1 = toolbars_button_height(b) + toolbars_url_height(b);
h2 = toolbars_status_height(b);
if (h1) h1 += wimpt_dy();
if (h2) h2 += wimpt_dy();
b->display_height = o.visible_area.ymax - o.visible_area.ymin - h1 - h2;
}
/* Ensure any child frames are resized to fit */
#ifdef TRACE
if (tl & (1u<<3)) Printf("windows_open_full_screen: Exitting through frames_resize_frameset\n");
#endif
return frames_resize_frameset(b, &o.visible_area);
}
/*************************************************/
/* windows_process_icon_text() */
/* */
/* Takes a Wimp icon handle and looks at a given */
/* text string, which can contain a special */
/* string of characters instructing the function */
/* to perform various changes to the icon. */
/* */
/* The string must start with '@!' to indicate */
/* it isn't some ordinary preinitialised string, */
/* and can contain these comma separated values: */
/* */
/* N Ensure the icon has (N)o border. */
/* H Ensure the icon (H)as a border. */
/* Bn Set background to colour n (n=hex). */
/* Fn Set foreground to colour n (n=hex). */
/* */
/* Parameters: Pointer to WimpGetIconStateBlock */
/* holding the window handle the */
/* icon is in and the icon's handle */
/* (the full icon state will be */
/* read in by this function, it does */
/* not need to be done externally); */
/* */
/* Pointer to the special text; */
/* */
/* 1 to set the first character of */
/* the text to a null byte (i.e. get */
/* rid of the string) if it is a */
/* special string (otherwise it is */
/* left untouched), else 0. */
/*************************************************/
void windows_process_icon_text(WimpGetIconStateBlock * icon, char * text, int remove)
{
/* Check this is special text */
if (!text || strlen(text) < 3) return;
if (text[0] != '@' || text[1] != '!') return;
/* It is, so process it */
if (wimp_get_icon_state(icon)) return;
else
{
WimpSetIconStateBlock state;
int array, value;
unsigned int flags;
array = 2;
flags = icon->icon.flags;
/* Parse the text */
while (text[array])
{
switch (text[array])
{
case 'N': flags &= ~WimpIcon_Border, array++; break;
case 'H': flags |= WimpIcon_Border, array++; break;
case 'B':
case 'F':
case 'C':
{
unsigned int mask, shift;
if (text[array] == 'B') shift = WimpIcon_BGColour;
else if (text[array] == 'C') shift = WimpIcon_ButtonType;
else shift = WimpIcon_FGColour;
array ++;
value = (int) strtoul(text + array, NULL, 16);
array ++;
if (value < 0) value = 0;
if (value > 15) value = 15;
mask = 15 * shift;
flags &= ~mask;
flags |= (value * shift);
}
break;
default: array++; break;
}
while (text[array] == ',') array++;
}
/* Set the new flags, if they've changed */
if (flags != icon->icon.flags)
{
state.window_handle = icon->window_handle;
state.icon_handle = icon->icon_handle;
state.clear_word = 0xffffffff;
state.EOR_word = flags;
wimp_set_icon_state(&state);
}
}
/* Remove the text, if asked to do so */
if (remove) text[0] = 0;
return;
}
/*************************************************/
/* windows_process_component_text() */
/* */
/* Calls windows_process_icon_text for a given */
/* component of a given Toolbox object. */
/* */
/* Parameters: Object ID the component lies in; */
/* */
/* The component ID; */
/* */
/* Pointer to a buffer to hold the */
/* icon's text; */
/* */
/* Size of the buffer; */
/* */
/* Out of the icons that make up the */
/* component, the number of the one */
/* to alter (starting from 0); */
/* */
/* 1 to set the first character of */
/* the text to a null byte (i.e. get */
/* rid of the string) if it is a */
/* special string (otherwise it is */
/* left untouched), else 0. */
/*************************************************/
_kernel_oserror * windows_process_component_text(ObjectId o, ComponentId c, char * buffer,
int buffsize, int iconnum, int remove)
{
_kernel_oserror * e;
WimpGetIconStateBlock icon;
int iconlist[10];
if (buffsize < 2) return NULL;
/* Get the object's window handle and the icon handle for the given component */
e = window_get_wimp_handle(0, o, &icon.window_handle);
#ifdef TRACE
if (e) return e;
#else
if (e) return NULL;
#endif
e = gadget_get_icon_list(0, o, c, iconlist, sizeof(iconlist), NULL);
if (e) return NULL; /* Don't throw errors as may not want this component for some builds */
icon.icon_handle = iconlist[iconnum];
/* Read, process, and set the text */
e = wimp_get_icon_state(&icon);
if (e) return NULL;
strncpy(buffer, icon.icon.data.it.buffer, buffsize - 1);
buffer[buffsize - 1] = 0;
windows_process_icon_text(&icon, buffer, remove);
if (icon.icon.data.it.buffer_size > 1) strncpy(icon.icon.data.it.buffer, buffer, icon.icon.data.it.buffer_size - 1);
return NULL;
}
/*************************************************/
/* windows_initialise_tool_sizes() */
/* */
/* Sets up local copies of the current window */
/* tool sizes through find_tool_sizes. */
/*************************************************/
_kernel_oserror * windows_initialise_tool_sizes(void)
{
return find_tool_sizes(&title_height, &hscroll_height, &vscroll_width);
}
/*************************************************/
/* windows_return_tool_sizes() */
/* */
/* Returns the title bar and scroll bar widths */
/* in OS units, including their outlines (some */
/* of which will form part of the visible area */
/* border). */
/* */
/* This will only work correctly if a call to */
/* windows_initialise_tool_sizes has been made */
/* at least once before. */
/* */
/* Parameters: Pointer to an int, in which the */
/* title bar height is placed; */
/* */
/* Pointer to an int, in which the */
/* horizontal scroll bar bar height */
/* is placed; */
/* */
/* Pointer to an int, in which the */
/* vertical scroll bar width is */
/* placed. */
/* */
/* Assumes: Any of the pointers may be NULL. */
/*************************************************/
void windows_return_tool_sizes(int * theight, int * hheight, int * vwidth)
{
if (theight) *theight = title_height;
if (hheight) *hheight = hscroll_height;
if (vwidth) *vwidth = vscroll_width;
return;
}
/*************************************************/
/* windows_set_tools() */
/* */
/* If using the nested Wimp, turns on/off */
/* selected tools around a window. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the window; */
/* */
/* Pointer to a BBox, in which the */
/* proposed visible area of the */
/* window may be placed. If NULL, */
/* it will be read from a call to */
/* Wimp_GetWindowState - however, */
/* scrollbars that you're trying to */
/* remove may have forced the area */
/* up somewhat, hence the ability to */
/* give a desired pre-removal BBox; */
/* */
/* 1 for a title bar, else 0; */
/* */
/* 1 for a vertical scroll bar, else */
/* 0; */
/* */
/* 1 for a horizontal scroll bar, */
/* else 0; */
/* */
/* 1 for a resize icon, else 0. */
/* */
/* Assumes: The BBox pointer may be NULL. */
/*************************************************/
_kernel_oserror * windows_set_tools(browser_data * b, BBox * box, int title, int vscroll, int hscroll, int resize)
{
if (!nested_wimp) return NULL;
else
{
_kernel_oserror * e;
WimpGetWindowStateBlock s;
BBox extent;
unsigned int parent, align;
unsigned int old_flags;
int th, hh, vw, must_redraw = 0, must_reformat = 0;
/* If there's a highlight on this frame, remove it to avoid */
/* complications with it getting left in the wrong place. */
if (b == highlight_frame) frames_remove_highlight();
/* Get the window state and extent */
s.window_handle = b->window_handle;
RetError(_swix(Wimp_GetWindowState,
_INR(1, 2) | _OUTR(3, 4),
&s,
Magic_Word_TASK, /* See MiscDefs.h */
&parent,
&align));
RetError(window_get_extent(0, b->self_id, &extent));
/* Without the following line, the resize routines (such as windows_remember_size) can */
/* set up display_extent and display_width to appropriate values and call the */
/* reformatter, waiting for it to set the actual extent to match these values. However */
/* if this function gets in first - and it usually will - it will read the extent and */
/* then (re)set the values to the old settings; unless, that is, the following line is */
/* included to spot that the actual extent and display_extent settings differ. */
/* */
/* Of course, it's never *that* easy, so what we have to do is only set it if the */
/* extent we would have used is smaller. This is because during resizes of frames, */
/* documents can continue to reformat or reload (client pull) in the background, since */
/* null events are coming in (compare to a parent window resize, where event 1, */
/* Wimp_EOpenWindow, is being generated). This can mean that display_extent is out of */
/* date, and forcing the extent to it shrinks the window. The right hand edge of the */
/* frame thus suddenly gets pulled along with the left (or vice versa) and the visual */
/* effect is that the frameset tears itself apart. Not nice. */
/* */
/* And yes, I know this is *another* overlong comment, but necessary nonetheless. */
if (extent.xmax - extent.xmin < b->display_extent) extent.xmax = extent.xmin + b->display_extent;
/* Flags will only be set if they've changed */
old_flags = s.flags;
/* Need to know the window tool sizes */
windows_return_tool_sizes(&th, &hh, &vw);
/* The Wimp won't try to keep the visible footprint of the window */
/* the same as border icons appear and disappear. This is pretty */
/* useless from the browser's point of view; need to manually */
/* play around with the visible area to cope. */
if ((s.flags & WimpWindow_TitleIcon) && !title) s.visible_area.ymax += th, extent.ymax += th;
if (!(s.flags & WimpWindow_TitleIcon) && title) s.visible_area.ymax -= th, extent.ymax -= th;
if ((s.flags & WimpWindow_VScroll) && !vscroll) s.visible_area.xmax += vw, extent.xmax += vw, must_redraw = 1;
if (!(s.flags & WimpWindow_VScroll) && vscroll) s.visible_area.xmax -= vw, extent.xmax -= vw, must_redraw = 1, must_reformat = 1;
if ((s.flags & WimpWindow_HScroll) && !hscroll) s.visible_area.ymin -= hh, extent.ymin -= hh;
if (!(s.flags & WimpWindow_HScroll) && hscroll) s.visible_area.ymin += hh, extent.ymin += hh;
/* Modify them */
if (title) s.flags = s.flags | WimpWindow_TitleIcon;
else s.flags = s.flags &~ WimpWindow_TitleIcon;
if (vscroll) s.flags = s.flags | WimpWindow_VScroll;
else s.flags = s.flags &~ WimpWindow_VScroll;
if (hscroll) s.flags = s.flags | WimpWindow_HScroll;
else s.flags = s.flags &~ WimpWindow_HScroll;
if (resize) s.flags = s.flags | WimpWindow_SizeIcon;
else s.flags = s.flags &~ WimpWindow_SizeIcon;
/* If the flags have changed... */
if (s.flags != old_flags)
{
WindowShowObjectBlock show;
ObjectId tparent;
/* If there's a highlight on this frame, remove it to avoid */
/* complications with it getting left in the wrong place. */
if (b == highlight_frame) frames_remove_highlight();
/* Ensure the extent is corrected for the addition or removal of tools */
RetError(window_set_extent(0, b->self_id, &extent));
/* Alter the flags */
show.visible_area = s.visible_area;
show.xscroll = s.xscroll;
show.yscroll = s.yscroll;
show.behind = s.behind;
show.window_flags = s.flags;
show.parent_window_handle = parent;
show.alignment_flags = align | Alignment_NewFlagsGiven;
RetError(toolbox_get_parent(0, b->self_id, &tparent, NULL));
if (nested_wimp)
{
/* For the nested Wimp, simple - just reopen with the new-style call */
e = toolbox_show_object(Toolbox_ShowObject_AsSubWindow,
b->self_id,
Toolbox_ShowObject_FullSpec,
&show,
tparent,
-1);
}
else
{
// This code not done yet (not urgent enough for now).
// *If* eventually implemented, the 'if' wrapper around
// the whole of this function's code obviously needs to
// be removed first.
e = NULL;
}
if (e) return e;
/* If must_redraw is set, redraw errors could occur unless the window is redrawn now. */
if (must_redraw)
{
BBox workarea = s.visible_area;
coords_box_toworkarea(&workarea, (WimpRedrawWindowBlock *) &s);
RetError(wimp_force_redraw(s.window_handle,
workarea.xmin,
workarea.ymin,
workarea.xmax,
workarea.ymax));
/* May well need to move the toolbar gadgets, too */
if (choices.move_gadgets != Choices_MoveGadgets_Never) toolbars_move_gadgets(b);
}
/* If must_reformat is set, for childless windows, reformat the page */
if (must_reformat && !b->nchildren) reformat_format_from(b, -1, 1, -1);
}
/* Update the various browser width records in light of any */
/* changes in the window, and similarly update the height */
b->display_extent = extent.xmax - extent.xmin;
b->display_width = s.visible_area.xmax - s.visible_area.xmin;
if (b->display_width < MinimumWidth) b->display_width = MinimumWidth;
{
int h1, h2;
h1 = toolbars_button_height(b) + toolbars_url_height(b);
h2 = toolbars_status_height(b);
if (h1) h1 += wimpt_dy();
if (h2) h2 += wimpt_dy();
b->display_height = s.visible_area.ymax - s.visible_area.ymin - h1 - h2;
}
/* If there are children and this is an ancestor window, resize the children */
if (!b->ancestor && b->nchildren) frames_resize_frameset(b, &s.visible_area);
return NULL;
}
}
/*************************************************/
/* windows_check_tools() */
/* */
/* Looks at a window, and if in a certain */
/* direction the visible area and extent are */
/* the same, turns off scroll bars (they aren't */
/* needed). */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the window; */
/* */
/* Pointer to a BBox, passed on to */
/* windows_set_tools (see that */
/* function for details). */
/*************************************************/
_kernel_oserror * windows_check_tools(browser_data * b, BBox * box)
{
WimpGetWindowStateBlock s;
BBox extent;
int hscroll = 0, vscroll = 0;
/* For small fetch windows, don't want to touch the tools */
if (b->small_fetch) return NULL;
/* Otherwise, proceed */
s.window_handle = b->window_handle;
RetError(wimp_get_window_state(&s));
RetError(window_get_extent(0, b->self_id, &extent));
/* Turn on scroll bars if the visible area is less than the */
/* extent in the appropriate direction. */
if (s.visible_area.xmax - s.visible_area.xmin < extent.xmax - extent.xmin) hscroll = 1;
if (s.visible_area.ymax - s.visible_area.ymin < extent.ymax - extent.ymin) vscroll = 1;
if (!b->ancestor && !b->full_screen)
{
/* Ancestor windows should always have both scroll bars, unless */
/* running full screen. */
hscroll = vscroll = 1;
}
else
{
/* Otherwise, read the scroll bar flags */
if (!b->nchildren)
{
/* Frames or full screen windows with no children themselves*/
if (b->frame_hscroll == 0) hscroll = 0; /* No */
else if (b->frame_hscroll == 2) hscroll = 1; /* Yes, else use values found above (i.e. auto) */
/* If there is a vertical scroll bar present already, and this window */
/* has no children, don't want to remove that bar. This is so that */
/* frames can start with no scroll bar, then later the reformatter */
/* may decide to add one. Since the page width changes the */
/* windows_set_tools call will call the reformatter again. However, */
/* the new reformat could turn off the vertical scroll bar - so the */
/* reformatter locks into a recursive loop. Hence, can only ever */
/* remove a vscroll for a childless window by an explicit call to */
/* windows_set_tools; otherwise, once it's added, it stays. */
/* */
/* The exception, of course, is for frames with scrolling explicitly */
/* set to 'no'. */
if (!b->frame_vscroll) vscroll = 0;
else if (b->frame_vscroll == 2 || (s.flags & WimpWindow_VScroll)) vscroll = 1;
// if (b->frame_vscroll == 0) vscroll = 0;
// else if (b->frame_vscroll == 2) vscroll = 1;
}
else
{
/* Frames with children *must* have no scroll bars, or resize routines */
/* later on, which read visible areas, will fail, and the bars will be */
/* visible in gaps between frames. */
hscroll = vscroll = 0;
}
}
RetError(windows_set_tools(b, box, !b->ancestor, vscroll, hscroll, !b->full_screen && !b->ancestor));
return NULL;
}