/* 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 : Frames.c */
/* */
/* Purpose: Frame handling functions for the */
/* browser. */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 19-Mar-97: Created. */
/***************************************************/
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "swis.h"
#include "flex.h"
#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */
#include "wimp.h"
#include "wimplib.h"
#include "event.h"
#include "toolbox.h"
#include "window.h"
#include "NestWimp.h"
#include "svcprint.h"
#include "Global.h"
#include "FromROSLib.h"
#include "Utils.h"
#include "Browser.h"
#include "Fetch.h" /* (Which itself includes URLstat.h) */
#include "FetchPage.h"
#include "Images.h"
#include "Memory.h"
#include "Mouse.h"
#include "Redraw.h"
#include "Reformat.h"
#include "Toolbars.h"
#include "URLutils.h"
#include "Windows.h"
#include "Frames.h"
/* Locals */
static int highlight_timer = 0;
static int highlight_for = 0;
static ObjectId highlight_top = 0;
static ObjectId highlight_bottom = 0;
static ObjectId highlight_left = 0;
static ObjectId highlight_right = 0;
/* Static function prototypes */
static _kernel_oserror * frames_find_widths (browser_data * b, int available);
static _kernel_oserror * frames_find_heights (browser_data * b, int available);
static int frames_check_recursion (browser_data * parent, browser_data * child, HStream * token);
static _kernel_oserror * frames_reopen_frame (browser_data * cb, browser_data * parent, BBox * frame_box);
static void frames_collapse_child_tree (browser_data * base, browser_data * real_parent, browser_data * close);
static browser_data * frames_find_next_frame (browser_data * check, browser_data * current, int * found);
static browser_data * frames_find_previous_frame (browser_data * check, browser_data * current, int * found);
static int frames_remove_highlight_timer (int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle);
/*************************************************/
/* frames_find_widths() */
/* */
/* Constructs an array pointed to by the */
/* frame_widths field of a browser_data struct, */
/* containing the widths of frames described by */
/* the token pointed to in the frameset field of */
/* the browser_data structure. */
/* */
/* These frame widths are set to occupy the */
/* entire space given to the function; any */
/* border and scroll bar size considerations */
/* must therefore be done externally. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the frameset; */
/* */
/* The available width the frameset */
/* must fit inside, in OS units. */
/*************************************************/
static _kernel_oserror * frames_find_widths(browser_data * b, int available)
{
_kernel_oserror * e;
int tw, units;
int col, cols, left, stars;
cols = b->frameset->cols;
if (!cols) cols = 1;
/* Allocate memory for the array */
e = memory_set_chunk_size(b, NULL, CK_FWID, cols * sizeof(int));
if (e) return e;
/* Ensure 'available' is a whole number of pixels */
available &= ~(wimpt_dx() - 1);
/* Fast simple case - only one column */
if (cols == 1)
{
b->frame_widths[0] = available;
return NULL;
}
/* Initial conditions */
left = available;
stars = 0;
/* First pass; subtract from the overall width, */
/* the width of percentage specified frames */
/* and absolute pixel size specified frames. */
for (col = 0; col < cols; col ++)
{
tw = ((int *) (b->frameset->value))[col];
units = tw & ~ROWCOL_VALUE;
tw &= ROWCOL_VALUE;
if (units & ROWCOL_PERCENT)
{
tw = ((available * tw) / 100) & ~(wimpt_dx() - 1);
left -= tw;
b->frame_widths[col] = tw;
}
else if (units & ROWCOL_STAR)
{
stars += tw;
}
else
{
tw = (tw * 2) & ~(wimpt_dx() - 1);
left -= tw;
b->frame_widths[col] = tw;
}
}
/* Second pass; allocate a fraction of the */
/* remaining space to star specified frames. */
if (stars)
{
int remaining;
int rem_stars = stars;
remaining = left;
for (col = 0; col < cols; col ++)
{
tw = ((int *) (b->frameset->value))[col];
units = tw & ~ROWCOL_VALUE;
tw &= ROWCOL_VALUE;
if (units & ROWCOL_STAR)
{
rem_stars -= tw;
if (rem_stars) tw = (remaining * tw / stars) & ~(wimpt_dx() - 1);
else tw = left;
if (tw < controls.minimum_frame_width) tw = controls.minimum_frame_width;
left -= tw;
b->frame_widths[col] = tw;
}
}
}
/* Third pass; simple scale to fit all the frames in the */
/* available space (scaling up or down). 'left' holds, */
/* in OS units, the amount left / overshot in the */
/* available width. */
if (left != 0)
{
int basic, remainder, left2 = available;
if (available == left) left = available + 1;
for (col = 0; col < cols; col ++)
{
left2 -=
b->frame_widths[col] =
(b->frame_widths[col] * available / (available - left)) & ~(wimpt_dx() - 1);
}
/* 'left2' is in OS units, but represents a whole number of */
/* pixels due to careful use of wimpt_dx above. To cope */
/* with rounding correctly during rescaling the widths */
/* (see below), want this now in pixel values. */
left = left2 / wimpt_dx();
basic = left / cols;
remainder = left - (basic * cols);
basic *= wimpt_dx();
for (col = 0; col < cols; col ++)
{
if (remainder < 0)
{
b->frame_widths[col] += basic - wimpt_dx();
remainder ++;
}
else if (remainder > 0)
{
b->frame_widths[col] += basic + wimpt_dx();
remainder --;
}
else b->frame_widths[col] += basic;
}
}
return NULL;
}
/*************************************************/
/* frames_find_heights() */
/* */
/* Constructs an array pointed to by the */
/* frame_heights field of a browser_data struct, */
/* containing the heights of frames described by */
/* the token pointed to in the frameset field of */
/* the browser_data structure. */
/* */
/* These frame heights are set to occupy the */
/* entire space given to the function; any */
/* border and scroll bar size considerations */
/* must therefore be done externally. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the frameset; */
/* */
/* The available height the frameset */
/* must fit inside, in OS units. */
/*************************************************/
static _kernel_oserror * frames_find_heights(browser_data * b, int available)
{
_kernel_oserror * e;
int th, units;
int row, rows, left, stars;
rows = b->frameset->rows;
if (!rows) rows = 1;
/* Allocate memory for the array */
e = memory_set_chunk_size(b, NULL, CK_FHEI, rows * sizeof(int));
if (e) return e;
/* Ensure 'available' is a whole number of pixels */
available &= ~(wimpt_dy() - 1);
/* Fast simple case - only one row */
if (rows == 1)
{
b->frame_heights[0] = available;
return NULL;
}
/* Initial conditions */
left = available;
stars = 0;
/* First pass; subtract from the overall height, */
/* the height of percentage specified frames */
/* and absolute pixel size specified frames. */
for (row = 0; row < rows; row ++)
{
th = ((int *) (b->frameset->name))[row];
units = th & ~ROWCOL_VALUE;
th &= ROWCOL_VALUE;
if (units & ROWCOL_PERCENT)
{
th = ((available * th) / 100) & ~(wimpt_dy() - 1);
left -= th;
b->frame_heights[row] = th;
}
else if (units & ROWCOL_STAR)
{
stars += th;
}
else
{
th = (th * 2) & ~(wimpt_dy() - 1);
left -= th;
b->frame_heights[row] = th;
}
}
/* Second pass; allocate a fraction of the */
/* remaining space to star specified frames. */
if (stars)
{
int remaining;
int rem_stars = stars;
remaining = left;
for (row = 0; row < rows; row ++)
{
th = ((int *) (b->frameset->name))[row];
units = th & ~ROWCOL_VALUE;
th &= ROWCOL_VALUE;
if (units & ROWCOL_STAR)
{
rem_stars -= th;
if (rem_stars) th = (remaining * th / stars) & ~(wimpt_dy() - 1);
else th = left;
if (th < controls.minimum_frame_height) th = controls.minimum_frame_height;
left -= th;
b->frame_heights[row] = th;
}
}
}
/* Third pass; simple scale to fit all the frames in the */
/* available space (scaling up or down). 'left' holds, */
/* in OS units, the amount left / overshot in the */
/* available height. */
if (left != 0)
{
int basic, remainder, left2 = available;
if (available == left) left = available + 1;
for (row = 0; row < rows; row ++)
{
left2 -=
b->frame_heights[row] =
(b->frame_heights[row] * available / (available - left)) & ~(wimpt_dy() - 1);
}
/* 'left2' is in OS units, but represents a whole number of */
/* pixels due to careful use of wimpt_dy above. To cope */
/* with rounding correctly during rescaling the heights */
/* (see below), want this now in pixel values. */
left = left2 / wimpt_dy();
basic = left / rows;
remainder = left - (basic * rows);
basic *= wimpt_dy();
for (row = 0; row < rows; row ++)
{
if (remainder < 0)
{
b->frame_heights[row] += basic - wimpt_dy();
remainder ++;
}
else if (remainder > 0)
{
b->frame_heights[row] += basic + wimpt_dy();
remainder --;
}
else b->frame_heights[row] += basic;
}
}
return NULL;
}
/*************************************************/
/* frames_get_rc_info() */
/* */
/* Returns the number of rows and columns in a */
/* frameset, and the row and column that a */
/* specific child lies in. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of the set of */
/* frames in question; */
/* */
/* The child number, or -1 if not */
/* interested in this info; */
/* */
/* Pointer to an int, into which the */
/* number of rows is placed; */
/* */
/* Pointer to an int, into which the */
/* number of columns is placed; */
/* */
/* Pointer to an int, into which the */
/* row the child lies in is placed; */
/* */
/* Pointer to an int, into which the */
/* column the child lies in is */
/* placed. */
/* */
/* Assumes: Any of the four int pointers may */
/* be NULL. */
/*************************************************/
void frames_get_rc_info(browser_data * parent, int child,
int * retrows, int * retcols, int * retrow, int * retcol)
{
int rows = 0, row = 0, cols = 0, col = 0;
if (parent->nchildren)
{
rows = parent->frameset->rows;
cols = parent->frameset->cols;
if (!rows) rows = 1;
if (!cols) cols = 1;
if (child >= 0)
{
row = child / rows;
col = child % cols;
if (row < 0) row = 0;
if (row >= rows) row = rows - 1;
if (col < 0) col = 0;
if (col >= cols) col = cols - 1;
}
}
if (retrows) *retrows = rows;
if (retcols) *retcols = cols;
if (retrow) *retrow = row;
if (retcol) *retcol = col;
}
/*************************************************/
/* frames_find_pointer_in_frameset() */
/* */
/* Works out where in a frameset a given screen */
/* coordinate is. The returned row and column */
/* values are -1 if the coordinate lies within */
/* a row or column, or are the row below, or */
/* column to the right of the coordinate if it */
/* lies in the border between two rows or */
/* columns. So the value 0 would never be */
/* returned for either. */
/* */
/* In the event that the pointer lies between a */
/* row or column but that row or column edge */
/* cannot be resized due to specifiers in the */
/* HTML source for the frameset, -2 will be */
/* returned. */
/* */
/* Given that this is likely to be called by */
/* routines handling border-driven resizing of */
/* frames, the routine can constrain the pointer */
/* to a bounding box appropriate to the frames */
/* surrounding it if required. This may be done */
/* via. a mouse_rectangle or Wimp_DragBox. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the parent frame; */
/* */
/* X screen coordinate to check; */
/* */
/* Y screen coordinate to check; */
/* */
/* Pointer to an int, into which the */
/* row number (see above) will be */
/* written; */
/* */
/* Pointer to an int, into which the */
/* column number (see above) will be */
/* written; */
/* */
/* Pointer to an int, into which the */
/* pointer's x offset from the left */
/* edge of the frame left of it, if */
/* applicable, is returned; */
/* */
/* Pointer to an int, into which the */
/* pointer's y offset from the top */
/* edge of the frame below it, if */
/* applicable, is returned; */
/* */
/* 1 to constrain the pointer (again */
/* see above for more details) with */
/* Wimp_DragBox, 2 to constrain with */
/* mouse_rectangle, 0 to not do any */
/* pointer constraint. */
/* */
/* Assumes: Either of the four int pointers */
/* may be NULL. */
/*************************************************/
_kernel_oserror * frames_find_pointer_in_frameset(browser_data * handle, int x, int y, int * retrow, int * retcol,
int * offset_left, int * offset_top, int constrain)
{
_kernel_oserror * e;
browser_data * child;
WimpGetWindowOutlineBlock co;
int oft, ofl;
int rows, cols;
int row, col;
int i, c;
BBox span;
if (offset_left) *offset_left = 0;
if (offset_top) *offset_top = 0;
oft = ofl = 0;
/* Find the number of rows and columns */
rows = handle->frameset->rows;
cols = handle->frameset->cols;
if (!rows) rows = 1;
if (!cols) cols = 1;
/* First find the row that the pointer lies between */
row = -1, col = -1;
for (i = 0; i < rows; i++)
{
/* What child number are we on? */
c = i * cols;
if (c < handle->nchildren)
{
/* Get this child frame's outline coordinates */
child = handle->children[c];
co.window_handle = child->window_handle;
e = wimp_get_window_outline(&co);
if (e) return e;
/* First case - pointer y coord lies within the bounding y */
/* coords of the window, so it lies in this row. In this */
/* case, we've a column-only drag, so don't care about the */
/* row. We can just exit, leaving row at -1. */
if (co.outline.ymax > y && co.outline.ymin < y) break;
/* Second case - pointer y coord lies above the top of the */
/* frame. So we've gone past it; in that case, the pointer */
/* must lie between this row and the previous one. */
if (co.outline.ymax <= y)
{
row = i; /* So row points to the row below the pointer */
oft = y - co.outline.ymax;
if (offset_top) *offset_top = oft;
break;
}
}
}
/* Right, next find the column the pointer lies between */
for (i = 0; i < cols; i++)
{
if (i < handle->nchildren)
{
/* Get this child frame's outline coordinates */
child = handle->children[i];
co.window_handle = child->window_handle;
e = wimp_get_window_outline(&co);
if (e) return e;
/* As for rows, first case is the x coord lying within the */
/* bounding x coords of the window. */
if (co.outline.xmin < x && co.outline.xmax > x) break;
/* Second case, the pointer x coord lies left of the left */
/* hand side of the frame, so we've gone past it. */
if (co.outline.xmin >= x)
{
col = i;
ofl = co.outline.xmin - x;
if (offset_left) *offset_left = ofl;
break;
}
}
}
/* At this point, row holds -1 if the pointer lies within a */
/* particular row, or holds the row number below the pointer */
/* if it lies between two rows. Similarly, col holds -1 if */
/* the pointer lies within a particular column, or holds the */
/* column number to the right of the pointer if it lies */
/* between two columns. */
if (
row == 0 ||
col == 0 ||
row >= rows ||
col >= cols
)
{
if (retrow) *retrow = -1;
if (retcol) *retcol = -1;
return NULL;
}
/* Are we allowed to resize this edge? */
if (row > 0 && !frames_can_resize_top(handle, row * cols)) row = -2;
if (col > 0 && !frames_can_resize_left(handle, col)) col = -2;
/* Set the return values */
if (retrow) *retrow = row;
if (retcol) *retcol = col;
/* If required, constrain the pointer */
if (constrain)
{
int th, hh, vw;
/* Find the tool sizes; we reduce the size of the bounding box */
/* for the pointer by the relevant tool size times two to make */
/* sure the frames don't get squashed too small, as well as */
/* considering the border width and original drag position. */
windows_return_tool_sizes(&th, &hh, &vw);
span.xmin = span.xmax = x;
span.ymin = span.ymax = y;
/* Finding the outlines again for four frames */
/* may duplicate some, or even all of the work */
/* done above but this keeps the code clear */
/* and easy to understand. This is a very */
/* infrequent operation (only at the start of */
/* a drag, for example) so it doesn't need to */
/* be that fast. */
if (row > 0)
{
/* Get the top frame outline coordinates */
c = (row - 1) * cols;
if (c < handle->nchildren)
{
child = handle->children[c];
co.window_handle = child->window_handle;
e = wimp_get_window_outline(&co);
if (e) return e;
span.ymax = y + co.outline.ymax - co.outline.ymin - hh * 2;
}
/* Get the bottom frame outline coordinates */
c = row * cols;
if (c < handle->nchildren)
{
child = handle->children[c];
co.window_handle = child->window_handle;
e = wimp_get_window_outline(&co);
if (e) return e;
span.ymin = y - (co.outline.ymax - co.outline.ymin - hh * 2);
}
if (span.ymax < span.ymin) span.ymax = span.ymin = y;
}
if (col > 0)
{
/* Get the left frame outline coordinates */
c = col - 1;
if (c < handle->nchildren)
{
child = handle->children[c];
co.window_handle = child->window_handle;
e = wimp_get_window_outline(&co);
if (e) return e;
span.xmin = x - (co.outline.xmax - co.outline.xmin - vw * 2);
}
/* Get the right hand frame outline coordinates */
c = col;
if (c < handle->nchildren)
{
child = handle->children[c];
co.window_handle = child->window_handle;
e = wimp_get_window_outline(&co);
if (e) return e;
span.xmax = x + co.outline.xmax - co.outline.xmin - vw * 2;
}
if (span.xmax < span.xmin) span.xmax = span.xmin = x;
}
/* Set the bounding box */
if (constrain == 1)
{
WimpDragBox drag;
drag.wimp_window = handle->window_handle;
drag.drag_type = Wimp_DragBox_DragPoint;
drag.dragging_box.xmin = 0;
drag.dragging_box.ymin = 0;
drag.dragging_box.xmax = 0;
drag.dragging_box.ymax = 0;
drag.parent_box = span;
drag.workspace = NULL;
drag.draw = NULL;
drag.remove = NULL;
drag.move = NULL;
wimp_drag_box(&drag);
}
else if (constrain == 2) mouse_rectangle(&span, 1);
}
/* Finished */
return NULL;
}
/*************************************************/
/* frames_can_resize_top() */
/* */
/* Returns 1 if the top edge of a given frame */
/* may be dragged to resize the frame. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of the set of */
/* frames in question; */
/* */
/* Number of the child to check. */
/* */
/* Returns: 1 if the frame's top edge can be */
/* dragged to resize it, else 0 (due */
/* to NORESIZE specified on that */
/* frame or frames surrounding it). */
/*************************************************/
int frames_can_resize_top(browser_data * parent, int child)
{
int row, rows, col, cols;
int checkcol, checkchild;
browser_data * checkc;
int canresize = 1;
HStream * frametoken;
if (!parent->nchildren) return 0;
frametoken = parent->children[child]->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE)) return 0;
/* Find out the number of rows and columns, and the */
/* row and column number the given child falls in. */
frames_get_rc_info(parent, child, &rows, &cols, &row, &col);
for (checkcol = 0; checkcol < cols; checkcol ++)
{
/* Check all columns in the row the child is in for NORESIZE frames */
checkchild = row * cols + checkcol;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
/* If not already on row 0, check the row above for NORESIZE frames */
if (row)
{
checkchild = (row - 1) * cols + checkcol;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
}
}
return canresize;
}
/*************************************************/
/* frames_can_resize_bottom() */
/* */
/* Returns 1 if the bottom edge of a given frame */
/* may be dragged to resize the frame. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of the set of */
/* frames in question; */
/* */
/* Number of the child to check. */
/* */
/* Returns: 1 if the frame's bottom edge can */
/* be dragged to resize it, else 0 */
/* (due to NORESIZE specified on */
/* that frame or frames surrounding */
/* it). */
/*************************************************/
int frames_can_resize_bottom(browser_data * parent, int child)
{
int row, rows, col, cols;
int checkcol, checkchild;
browser_data * checkc;
int canresize = 1;
HStream * frametoken;
if (!parent->nchildren) return 0;
frametoken = parent->children[child]->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE)) return 0;
/* Find out the number of rows and columns, and the */
/* row and column number the given child falls in. */
frames_get_rc_info(parent, child, &rows, &cols, &row, &col);
for (checkcol = 0; checkcol < cols; checkcol ++)
{
/* Check all columns in the row the child is in for NORESIZE frames */
checkchild = row * cols + checkcol;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
/* If not already on the last row, check the row below for NORESIZE frames */
if (row < rows - 1)
{
checkchild = (row + 1) * cols + checkcol;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
}
}
return canresize;
}
/*************************************************/
/* frames_can_resize_left() */
/* */
/* Returns 1 if the left edge of a given frame */
/* may be dragged to resize the frame. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of the set of */
/* frames in question; */
/* */
/* Number of the child to check. */
/* */
/* Returns: 1 if the frame's left edge can be */
/* dragged to resize it, else 0 (due */
/* to NORESIZE specified on that */
/* frame or frames surrounding it). */
/*************************************************/
int frames_can_resize_left(browser_data * parent, int child)
{
int row, rows, col, cols;
int checkrow, checkchild;
browser_data * checkc;
int canresize = 1;
HStream * frametoken;
if (!parent->nchildren) return 0;
frametoken = parent->children[child]->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE)) return 0;
/* Find out the number of rows and columns, and the */
/* row and column number the given child falls in. */
frames_get_rc_info(parent, child, &rows, &cols, &row, &col);
for (checkrow = 0; checkrow < rows; checkrow ++)
{
/* Check all rows in the column the child is in for NORESIZE frames */
checkchild = col + checkrow * cols;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
/* If not already on column 0, check the column to the left for NORESIZE frames */
if (col)
{
checkchild = col - 1 + checkrow * cols;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
}
}
return canresize;
}
/*************************************************/
/* frames_can_resize_right() */
/* */
/* Returns 1 if the right edge of a given frame */
/* may be dragged to resize the frame. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of the set of */
/* frames in question; */
/* */
/* Number of the child to check. */
/* */
/* Returns: 1 if the frame's right edge can */
/* be dragged to resize it, else 0 */
/* (due to NORESIZE specified on */
/* that frame or frames surrounding */
/* it). */
/*************************************************/
int frames_can_resize_right(browser_data * parent, int child)
{
int row, rows, col, cols;
int checkrow, checkchild;
browser_data * checkc;
int canresize = 1;
HStream * frametoken;
if (!parent->nchildren) return 0;
frametoken = parent->children[child]->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE)) return 0;
/* Find out the number of rows and columns, and the */
/* row and column number the given child falls in. */
frames_get_rc_info(parent, child, &rows, &cols, &row, &col);
for (checkrow = 0; checkrow < rows; checkrow ++)
{
/* Check all rows in the column the child is in for NORESIZE frames */
checkchild = col + checkrow * cols;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
/* If not already on the last column, check the column to the right for NORESIZE frames */
if (col < cols - 1)
{
checkchild = col + 1 + checkrow * cols;
checkc = parent->children[checkchild];
frametoken = checkc->frame;
if (frametoken && (frametoken->type & TYPE_NORESIZE))
{
canresize = 0;
break;
}
}
}
return canresize;
}
/*************************************************/
/* frames_redraw_borders() */
/* */
/* Redraws plinth borders and a resize sprite */
/* indicator around frames in a given parent. */
/* */
/* Parameters: Pointer to a parent browser_data */
/* struct; */
/* */
/* A WimpRedrawWindow block */
/* describing the redraw region. */
/*************************************************/
void frames_redraw_borders(browser_data * b, WimpRedrawWindowBlock * r)
{
int child;
unsigned int colour;
BBox sbox;
browser_data * c;
WimpGetWindowOutlineBlock co;
sbox = r->redraw_area;
/* The bottom bit of the colour field is set to indicate */
/* that a colour is present, as opposed to having no */
/* colour set. In the latter case default to background */
/* grey, in the former strip off the set bit. Then set */
/* that colour. Remember, we try to find a colour in the */
/* FRAME tags, then failing that look in the FRAMESET */
/* (as in NN or MSIE 4). */
colour = 0;
for (child = 0; child < b->nchildren && !(colour & 1); child ++)
{
c = b->children[child];
if (c->frame) colour = c->frame->maxlen;
}
if (!(colour & 1)) colour = b->frameset->maxlen;
if (!(colour & 1)) colour = Redraw_Colour_WNGrey;
else colour &= ~1;
redraw_set_colour(colour);
bbc_rectanglefill(sbox.xmin,
sbox.ymin,
sbox.xmax - sbox.xmin + 4,
sbox.ymax - sbox.ymin + 4);
#ifdef TRACE
if (tl & (1u<<23))
{
redraw_set_colour(0xff884400);
bbc_rectangle(sbox.xmin,
sbox.ymin,
sbox.xmax - sbox.xmin - 1,
sbox.ymax - sbox.ymin - 1);
redraw_set_colour(0xffaa6600);
bbc_rectangle(sbox.xmin + 2,
sbox.ymin + 2,
sbox.xmax - sbox.xmin - 5,
sbox.ymax - sbox.ymin - 5);
redraw_set_colour(0xffcc8800);
bbc_rectangle(sbox.xmin + 4,
sbox.ymin + 4,
sbox.xmax - sbox.xmin - 9,
sbox.ymax - sbox.ymin - 9);
}
#endif
/* Now loop round the children, drawing a 3D border around them */
/* for border spacings >= 2, a black line for spacing 1, or */
/* nothing for spacing 0 (shouldn't then get redraw events for */
/* the parent, but you never know - e.g. user could have got a */
/* patch that allowed the frames to be moved by dragging on */
/* their work area). */
if (b->frameset->indent) /* Holds frame spacing (equiv. to border width) */
{
for (child = 0; child < b->nchildren; child ++)
{
c = b->children[child];
co.window_handle = c->window_handle;
if (!wimp_get_window_outline(&co))
{
if (b->frameset->indent >= 2) redraw_set_colour(Redraw_Colour_AlmostWhite);
else redraw_set_colour(0);
/* Bottom edge */
bbc_rectanglefill(co.outline.xmin,
co.outline.ymin - 2,
co.outline.xmax - co.outline.xmin + 1,
1);
bbc_rectanglefill(co.outline.xmax,
co.outline.ymin,
1,
co.outline.ymax - co.outline.ymin - 1);
/* Right hand edge */
if (b->frameset->indent >= 2) redraw_set_colour(Redraw_Colour_PlinthGrey);
/* Top edge */
bbc_rectanglefill(co.outline.xmin - 2,
co.outline.ymax,
co.outline.xmax - co.outline.xmin + 3,
1);
/* Left hand edge */
bbc_rectanglefill(co.outline.xmin - 2,
co.outline.ymin - 2,
1,
co.outline.ymax - co.outline.ymin + 1);
/* If the edges are draggable - for frame resizing - plot icons */
/* indicate this. */
{
int width, height;
BBox icon;
/* Get the sprite size, work out a bounding box and plot */
/* this as a virtual icon. */
read_sprite_size("resizeframe", &width, &height);
/* Can only plot sprites if there's room... The additions to width and */
/* height account for the border plotted above. */
if (
width + 4 <= b->frameset->indent * wimpt_dx() &&
height + 4 <= b->frameset->indent * wimpt_dy()
)
{
WimpPlotIconBlock block;
block.flags = 0x1700311B;
block.data.ist.buffer = "";
block.data.ist.validation = "Sresizeframe";
block.data.ist.buffer_size = 4;
if (frames_can_resize_right(b, child) && !printing)
{
/* Plot to right of frame */
icon.xmin = co.outline.xmax + b->frameset->indent - width / 2;
icon.ymin = co.outline.ymin + (co.outline.ymax - co.outline.ymin - height) / 2;
icon.xmax = icon.xmin + width;
icon.ymax = icon.ymin + height;
coords_box_toworkarea(&icon, r);
block.bbox = icon;
_swix(Wimp_PlotIcon,
_IN(1) | _INR(4,5),
&block,
0,
0);
}
if (frames_can_resize_bottom(b, child) && !printing)
{
/* Plot below the frame */
icon.xmin = co.outline.xmin + (co.outline.xmax - co.outline.xmin - width) / 2;
icon.ymin = co.outline.ymin - height / 2 - b->frameset->indent;
icon.xmax = icon.xmin + width;
icon.ymax = icon.ymin + height;
coords_box_toworkarea(&icon, r);
block.bbox = icon;
_swix(Wimp_PlotIcon,
_IN(1) | _INR(4,5),
&block,
0,
0);
}
/* Closure of long 'if' checking that there is room to plot */
/* a resize handle for this frame, given that the frame */
/* itself doesn't have noresize specified. The code above */
/* executes if noresize is not specified and there's room */
/* to do the plot. */
}
/* Closure of code block dealing with resize handle plotting */
}
/* Closure of long 'if' ensuring a wimp_get_window_outline */
/* call didn't return an error - the code above executes */
/* if there was no error. */
}
/* Closure of 'for' looping round all children */
}
/* Closure of long 'if' checking that the frameset has spacing */
/* between frames. The code above executes if so. */
}
}
/*************************************************/
/* frames_define_frameset() */
/* */
/* For a given parent browser_data structure, */
/* sets up a frameset within it. Frame details */
/* for each of the children thus generated are */
/* filled in later, when getting each frame */
/* token from the HTML library. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the parent; */
/* */
/* Pointer to a token defining the */
/* frameset. */
/* */
/* Assumes: If the window already has a */
/* frameset defined, this set and */
/* all nested sets above it will be */
/* destroyed before the new one is */
/* created. */
/*************************************************/
_kernel_oserror * frames_define_frameset(browser_data * b, HStream * token)
{
_kernel_oserror * e;
WimpGetWindowStateBlock s;
BBox frame_box;
int rows, cols;
int num_rows, num_cols;
int width, height;
int htop, hbot;
int available_w, available_h;
int start_x, start_y, accum_x, accum_y;
int th, hh, vw;
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frameset: Called with browser_data %p\n",b);
#endif
/* For ancestor windows, need to get the whole window */
/* state and use the visible area, thus taking */
/* account of scrollbar presence etc. */
if (!b->ancestor || !nested_wimp)
{
s.window_handle = b->window_handle;
e = wimp_get_window_state(&s);
if (e) return e;
}
/* However, for frames with frames about to be defined */
/* inside them, we know that the scrollbars in this */
/* frame will disappear (if the nested wimp is in use) */
/* and so need to use the window outline, not the */
/* visible area, as the latter may not be up to date. */
else
{
WimpGetWindowOutlineBlock o;
o.window_handle = b->window_handle;
e = wimp_get_window_outline(&o);
if (e) return e;
s.window_handle = o.window_handle;
s.visible_area = o.outline;
}
windows_return_tool_sizes(&th, &hh, &vw);
/* Destroy any existing frameset */
frames_collapse_set(b);
/* Set up the basic starting parameters */
b->nchildren = 0;
b->filling_frame = 0;
b->frameset = token;
/* Work out the amount of visible area that toolbars are consuming */
if (!controls.swap_bars)
{
htop = toolbars_url_height(b) + toolbars_button_height(b); /* Physically, the button bar and URL bar are just one real toolbar */
hbot = toolbars_status_height(b);
}
else
{
htop = toolbars_status_height(b);
hbot = toolbars_url_height(b) + toolbars_button_height(b);
}
if (htop) htop += wimpt_dy(); /* Account for lower border of upper toolbar, if present */
if (hbot) hbot += wimpt_dy(); /* Account for upper border of lower toolbar, if present */
/* Work out the available frame space width and height */
available_w = s.visible_area.xmax - s.visible_area.xmin;
available_h = s.visible_area.ymax - s.visible_area.ymin - htop - hbot;
/* Start defining frames from the top left hand side of the visible area */
start_x = s.visible_area.xmin;
start_y = s.visible_area.ymax - htop;
/* Work out the number of rows / columns */
num_rows = token->rows;
if (!num_rows) num_rows = 1;
num_cols = token->cols;
if (!num_cols) num_cols = 1;
/* Account for frame spacing */
available_w -= token->indent * 2 * (num_cols - 1); /* Scale to 2 OS units/pixel */
available_h -= token->indent * 2 * (num_rows - 1);
#ifdef TRACE
if (tl & (1u<<17))
{
Printf("frames_define_frameset: avail_w %d\n"
" avail_h %d\n"
" start_x %d\n"
" start_y %d\n"
" rows %d\n"
" cols %d\n\n",
available_w,
available_h,
start_x,
start_y,
num_rows,
num_cols);
{
int i;
Printf("frames_define_frameset: Size enumeration:\n\n");
for (i = 0; i < num_rows; i++)
{
if (token->name) Printf("Row %d = %p\n",i,((int *) token->name)[i]);
else Printf("Row %d = undefined\n",i);
}
Printf("\n");
for (i = 0; i < num_cols; i++)
{
if (token->value) Printf("Col %d = %p\n",i,((int *) token->value)[i]);
else Printf("Col %d = undefined\n",i);
}
Printf("\nframes_define_frameset: Proceeding\n");
}
}
#endif
/* Get all the sizes */
frames_find_widths (b, available_w);
frames_find_heights(b, available_h);
/* Loop round defining each child */
frame_box.ymax = start_y;
accum_y = 0;
for (rows = 0; rows < num_rows; rows ++)
{
frame_box.xmin = start_x;
accum_x = 0;
height = b->frame_heights[rows];
accum_y += height;
if (rows == num_rows - 1)
{
/* For the last row, ensure it fills up the height - rounding errors in scaling */
/* for the find_height calls often make this necessary. */
if (accum_y != available_h) height -= accum_y - available_h, accum_y = available_h;
}
for (cols = 0; cols < num_cols; cols ++)
{
width = b->frame_widths[cols];
accum_x += width;
if (cols == num_cols - 1)
{
/* For the last column, ensure it fills up the width - rounding errors in scaling */
/* for the find_width calls often make this necessary. */
if (accum_x != available_w) width -= accum_x - available_w, accum_x = available_w;
}
/* Adjust the open coordinates to account for the scroll bars */
/* present in the Res file. If these are not present, the */
/* reformatter will try to use the horizontal space a */
/* vertical bar normally occupies and things will get worse */
/* from there... */
frame_box.xmax = frame_box.xmin + width - vw;
frame_box.ymin = frame_box.ymax - height + hh;
windows_create_browser("", b, &frame_box, NULL, Windows_CreateBrowser_Normal);
windows_set_tools(last_browser, &frame_box, 0, 0, 0, 0);
/* Make the child inherit some of the parent's characteristics */
last_browser->underline_links = b->underline_links;
last_browser->use_source_cols = b->use_source_cols;
last_browser->show_foreground = b->show_foreground;
last_browser->show_background = b->show_background;
/* If this is the first frame for the ancestor, make it selected */
if (last_browser->ancestor->nchildren == 1) last_browser->frame_selected = 1;
/* Increment the position counters and loop round again */
frame_box.xmin += width + token->indent * 2; /* Scale to 2 OS units/pixel */
}
frame_box.ymax -= height + token->indent * 2;
}
/* Finally, do a redraw of the parent to ensure borders are */
/* up to date. */
coords_box_toworkarea(&s.visible_area, (WimpRedrawWindowBlock *) &s);
e = wimp_force_redraw(b->window_handle,
s.visible_area.xmin,
s.visible_area.ymin,
s.visible_area.xmax,
s.visible_area.ymax);
if (e) return e;
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frameset: Successful\n");
#endif
return NULL;
}
/*************************************************/
/* frames_check_recursion() */
/* */
/* Checks to see if a frameset is defining */
/* itself recursively. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of the frame */
/* being checked; */
/* */
/* Pointer to a browser_data struct */
/* which represents the frame being */
/* checked; */
/* */
/* Pointer to an HStream struct that */
/* represents the <FRAME...> tag */
/* which is filling in the frame */
/* being checked. */
/* */
/* Returns: 1 if the definition is recursive, */
/* else 0. */
/*************************************************/
static int frames_check_recursion(browser_data * parent, browser_data * child, HStream * token)
{
while (parent)
{
if (browser_fetch_url(parent) && !strcmp(browser_fetch_url(parent), token->src)) return 1;
if (browser_current_url(parent) && !strcmp(browser_current_url(parent), token->src)) return 1;
parent = parent->real_parent;
}
return 0;
}
/*************************************************/
/* frames_define_frame() */
/* */
/* For a given parent browser_data structure, */
/* fills in the next unfilled frame. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the parent; */
/* */
/* Pointer to the token that is to */
/* define the child characteristics. */
/* */
/* Assumes: If the parent has no children, */
/* the routine silently fails; */
/* If the parent's children are all */
/* defined (i.e. there appear to be */
/* more <frame> tags than defined by */
/* the initial <frameset> the */
/* routine, again, silently fails. */
/*************************************************/
_kernel_oserror * frames_define_frame(browser_data * b, HStream * token)
{
browser_data * child;
_kernel_oserror * e;
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frame: Called with browser_data %p\n",b);
#endif
if (b->nchildren <= b->filling_frame)
{
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frame: nchildren %d, filling_frame %d - exitting!",b->nchildren,b->filling_frame);
#endif
return NULL;
}
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frame: Have not defined all children, so proceeding\n",b);
#endif
child = (browser_data *) b->children[b->filling_frame++];
child->frame = token;
if (token->name && *token->name)
{
e = memory_set_chunk_size(child, NULL, CK_NAME, strlen(token->name) + 1);
if (e) return e;
strcpy(child->window_name, token->name);
}
/* Set scrolling details */
{
int scroll;
scroll = token->type & TYPE_SCROLLING_MASK;
if (scroll == TYPE_SCROLLING_NO) child->frame_hscroll = 0;
else if (scroll == TYPE_SCROLLING_AUTO) child->frame_hscroll = 1;
else if (scroll == TYPE_SCROLLING_YES) child->frame_hscroll = 2;
child->frame_vscroll = child->frame_hscroll;
}
/* About to try and fetch the URL defined for the frame, */
/* but need to first check it's not recursive. */
if (frames_check_recursion(b, child, token))
{
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frame: Exitting with no fetch (recursive frameset)\n");
#endif
#ifdef STRICT_PARSER
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("FramRcrs:Frames definition references itself recursively; could not proceed with the frames layout.",
0,0));
show_error_ret(&erb);
#endif
return NULL;
}
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_define_frame: Exitting through fetchpage_new()\n",b);
#endif
return fetchpage_new(child, token->src, 1, 0);
}
/*************************************************/
/* frames_reopen_frame() */
/* */
/* Reopens a given frame to a given outline */
/* size. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the frame; */
/* */
/* Pointer to a browser_data struct */
/* representing the parent, or NULL */
/* if not known; */
/* */
/* Pointer to a BBox describing the */
/* new outline (screen coordinates) */
/* for the frame. */
/*************************************************/
static _kernel_oserror * frames_reopen_frame(browser_data * cb, browser_data * parent, BBox * frame_box)
{
_kernel_oserror * e = NULL;
WimpGetWindowStateBlock frame_state;
IdBlock idb;
WimpPollBlock block;
int title_height, hscroll_height, vscroll_width;
if (!cb) return NULL;
if (!parent) parent = cb->parent;
if (!parent) parent = cb->real_parent;
if (!parent) parent = cb->ancestor;
if (!parent) return NULL;
/* Get the tool sizes */
windows_return_tool_sizes(&title_height, &hscroll_height, &vscroll_width);
/* Get the frame's window details */
frame_state.window_handle = cb->window_handle;
e = wimp_get_window_state(&frame_state);
if (e) return e;
/* Fill in the open window request block with the new size */
/* details, etc. */
block.open_window_request.window_handle = frame_state.window_handle;
if (frame_state.flags & WimpWindow_VScroll) frame_box->xmax -= vscroll_width;
if (frame_state.flags & WimpWindow_HScroll) frame_box->ymin += hscroll_height;
block.open_window_request.visible_area = *frame_box;
block.open_window_request.xscroll = frame_state.xscroll;
block.open_window_request.yscroll = frame_state.yscroll;
/* Sort out the window to open behind. */
block.open_window_request.behind = find_behind(block.open_window_request.window_handle);
/* Fill in the ID block and call the open window function */
idb.self_id = cb->self_id;
idb.parent_id = parent->self_id;
windows_open_browser(0, &block, &idb, cb);
/* If the frame was highlighted, move the highlight too */
if (cb == highlight_frame)
{
e = frames_highlight_frame(cb);
if (e) return e;
}
return NULL;
}
/*************************************************/
/* frames_resize_frameset() */
/* */
/* For a given parent browser_data structure, */
/* resize a frameset within its window. Compare */
/* with frames_resize_frame(), which also */
/* resizes the parent (which is useful when the */
/* natural progression of a calling function */
/* would not include this itself). */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the parent; */
/* */
/* Pointer to a BBox describing the */
/* required new window outline (in */
/* screen coordinates) of the parent */
/* frame. */
/*************************************************/
_kernel_oserror * frames_resize_frameset(browser_data * b, BBox * new_outline)
{
_kernel_oserror * e;
WimpGetWindowStateBlock s;
BBox frame_box;
HStream * token;
int rows, cols;
int num_rows, num_cols;
int width, height;
int htop, hbot;
int available_w, available_h;
int start_x, start_y, accum_x, accum_y;
int th, hh, vw;
int child;
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_resize_frameset: Called with browser_data %p\n",b);
#endif
/* Nothing to resize if there are no children */
if (!b->nchildren) return NULL;
/* Get the frame window details and tool sizes */
s.window_handle = b->window_handle;
e = wimp_get_window_state(&s);
if (e) return e;
s.visible_area = *new_outline;
windows_return_tool_sizes(&th, &hh, &vw);
/* Work out the amount of visible area that toolbars are consuming */
if (!controls.swap_bars)
{
htop = toolbars_url_height(b) + toolbars_button_height(b); /* Physically, the button bar and URL bar are just one real toolbar */
hbot = toolbars_status_height(b);
}
else
{
htop = toolbars_status_height(b);
hbot = toolbars_url_height(b) + toolbars_button_height(b);
}
if (htop) htop += wimpt_dy(); /* Account for lower border of upper toolbar, if present */
if (hbot) hbot += wimpt_dy(); /* Account for upper border of lower toolbar, if present */
/* Work out the available frame space width and height */
available_w = s.visible_area.xmax - s.visible_area.xmin;
available_h = s.visible_area.ymax - s.visible_area.ymin
- htop
- hbot;
/* Start resizing frames from the top left hand side of the visible area */
start_x = s.visible_area.xmin;
start_y = s.visible_area.ymax - htop;
/* Work out the number of rows / columns */
token = b->frameset;
num_rows = token->rows;
num_cols = token->cols;
if (!num_rows) num_rows = 1;
if (!num_cols) num_cols = 1;
/* Account for frame spacing */
available_w -= token->indent * 2 * (num_cols - 1); /* Scale to 2 OS units/pixel */
available_h -= token->indent * 2 * (num_rows - 1);
#ifdef TRACE
if (tl & (1u<<17))
{
Printf("frames_resize_frameset: avail_w %d\n"
" avail_h %d\n"
" start_x %d\n"
" start_y %d\n"
" rows %d\n"
" cols %d\n\n",
available_w,
available_h,
start_x,
start_y,
num_rows,
num_cols);
{
int i;
Printf("frames_resize_frameset: Size enumeration:\n\n");
for (i = 0; i < num_rows; i++)
{
if (token->name) Printf("Row %d = %p\n",i,((int *) token->name)[i]);
else Printf("Row %d = undefined\n",i);
}
Printf("\n");
for (i = 0; i < num_cols; i++)
{
if (token->value) Printf("Col %d = %p\n",i,((int *) token->value)[i]);
else Printf("Col %d = undefined\n",i);
}
Printf("\nframes_resize_frameset: Proceeding\n");
}
}
#endif
/* Get all the sizes */
frames_find_widths (b, available_w);
frames_find_heights(b, available_h);
/* Loop round resizing each child */
frame_box.ymax = start_y;
accum_y = 0;
child = 0;
for (rows = 0; rows < num_rows; rows ++)
{
frame_box.xmin = start_x;
accum_x = 0;
height = b->frame_heights[rows];
accum_y += height;
if (rows == num_rows - 1)
{
/* For the last row, ensure it fills up the height - rounding errors in scaling */
/* for the find_height calls often make this necessary. */
if (accum_y != available_h) height -= accum_y - available_h, accum_y = available_h;
}
for (cols = 0; cols < num_cols; cols ++)
{
width = b->frame_widths[cols];
accum_x += width;
if (cols == num_cols - 1)
{
/* For the last column, ensure it fills up the width - rounding errors in scaling */
/* for the find_width calls often make this necessary. */
if (accum_x != available_w) width -= accum_x - available_w, accum_x = available_w;
}
frame_box.xmax = frame_box.xmin + width;
frame_box.ymin = frame_box.ymax - height;
/* Handle reopening the frame */
e = frames_reopen_frame(b->children[child], b, &frame_box);
if (e) return e;
/* Prepare for the next frame */
frame_box.xmin += width + token->indent * 2; /* Scale to 2 OS units/pixel */
child++;
}
frame_box.ymax -= height + token->indent * 2;
}
/* Now do a redraw of the parent, to ensure that borders are up to date */
coords_box_toworkarea(&s.visible_area, (WimpRedrawWindowBlock *) &s);
e = wimp_force_redraw(b->window_handle,
s.visible_area.xmin,
s.visible_area.ymin,
s.visible_area.xmax,
s.visible_area.ymax);
if (e) return e;
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_resize_frameset: Successful\n");
#endif
return NULL;
}
/*************************************************/
/* frames_resize_frame() */
/* */
/* Resizes a given frame and its contents (e.g. */
/* any nested frames). Compare with */
/* frames_resize_frameset(), which doesn't */
/* resize the parent - just the contents (which */
/* is useful when the natural progression of a */
/* calling function would resize the parent */
/* anyway). */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the frame; */
/* */
/* Pointer to a BBox describing the */
/* required new frame outline (in */
/* screen coordinates). */
/*************************************************/
_kernel_oserror * frames_resize_frame(browser_data * b, BBox * new_outline)
{
_kernel_oserror * e;
/* Update any child frames first, if needed */
if (b->nchildren)
{
e = frames_resize_frameset(b, new_outline);
if (e) return e;
}
/* Now resize the given frame */
return frames_reopen_frame(b, NULL, new_outline);
}
/*************************************************/
/* frames_lock_frameset() */
/* */
/* Examines the window sizes of a collection of */
/* frames in a frameset, and rewrites the size */
/* descriptions in the frameset representing */
/* HStream structures. This, then, would mean */
/* that for example, subsequent resizes of the */
/* ancestor window would maintain that new */
/* relative layout, rather than 'snapping back' */
/* to values specified in the HStream structure. */
/* */
/* Where possible, the nature of the value is */
/* maintained - e.g. a pixel value will stay */
/* as such, as will a percentage value (they */
/* don't all become pixel sizes). At present, */
/* all units are preserved though note that */
/* significant rounding errors can occur with */
/* percentage values. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the parent for the */
/* frameset to lock. */
/*************************************************/
void frames_lock_frameset(browser_data * b)
{
browser_data * child;
WimpGetWindowOutlineBlock co;
int units;
int av_w, av_h;
int wid, hei;
int col, cols;
int row, rows;
int tw, th;
if (!b->nchildren) return;
rows = b->frameset->rows;
cols = b->frameset->cols;
/* Get the parent width/height to find available space. */
co.window_handle = b->window_handle;
if (wimp_get_window_outline(&co)) return;
av_w = co.outline.xmax - co.outline.xmin;
av_h = co.outline.ymax - co.outline.ymin;
/* Now go through the columns. */
for (col = 0; col < cols; col++)
{
tw = ((int *) (b->frameset->value))[col];
units = tw & ~ROWCOL_VALUE;
/* Find the child and get information on it */
child = b->children[col];
co.window_handle = child->window_handle;
if (!wimp_get_window_outline(&co))
{
wid = co.outline.xmax - co.outline.xmin;
/* Work out what the widths should be in the */
/* given units. */
if (units & ROWCOL_PERCENT)
{
tw = (100 * wid) / av_w;
}
else if (units & ROWCOL_STAR)
{
/* This works as 2*,* is the same as 422*,211*; */
/* it's just fractions. So we can maintain the */
/* units but keep full accuracy here. */
tw = wid;
}
else
{
tw = wid / wimpt_dx();
}
/* Put the units field back in */
tw |= units;
/* Write the value to the token */
((int *) (b->frameset->value))[col] = tw;
}
}
/* Now do rows - code is directly analogous to the */
/* columns stuff above, hence the lack of comments. */
for (row = 0; row < rows; row++)
{
th = ((int *) (b->frameset->name))[row];
units = th & ~ROWCOL_VALUE;
child = b->children[row * (cols ? cols : 1)];
co.window_handle = child->window_handle;
if (!wimp_get_window_outline(&co))
{
hei = co.outline.ymax - co.outline.ymin;
if (units & ROWCOL_PERCENT)
{
th = (100 * hei) / av_h;
}
else if (units & ROWCOL_STAR)
{
th = hei;
}
else
{
th = hei / wimpt_dy();
}
th |= units;
((int *) (b->frameset->name))[row] = th;
}
}
/* ...and that's it. */
}
/*************************************************/
/* frames_fetching() */
/* */
/* Equivalent to fetch_fetching() in Fetch.c, */
/* but returns 1 if any of the frames in a */
/* frameset are fetching, else 0. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the parent of any frames */
/* to check (so for an entire */
/* frameset, pass the ancestor in). */
/* */
/* Returns: 1 if any of the frames are */
/* fetching, else 0. */
/*************************************************/
int frames_fetching(browser_data * b)
{
int i;
/* Recurse for child frames */
if (b->nchildren)
{
for (i = 0; i < b->nchildren; i++)
{
if (frames_fetching(b->children[i])) return 1;
}
}
if (fetch_fetching(b)) return 1;
return 0;
}
/*************************************************/
/* frames_abort_fetching() */
/* */
/* Stops any page or image fetching, and stops */
/* any current reformatting, in the given frame */
/* and all of its children (if it has any). For */
/* ancestor browser_data structures, if the */
/* relevant Choices and Messages file options */
/* have been set, WebServe will be instructed to */
/* stop all fetching and ditch any objects that */
/* are half fetched. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the fetches to abort; */
/* */
/* 1 to also stop image fetching, */
/* else 0 to let image fetches */
/* continue; */
/* */
/* 1 to also stop file spooling */
/* (i.e. the save_link flag is set), */
/* else 0 to allow it to continue. */
/*************************************************/
void frames_abort_fetching(browser_data * b, int stop_images, int stop_spools)
{
int i;
/* Recurse for child frames */
if (b->nchildren)
{
for (i = 0; i < b->nchildren; i++)
{
frames_abort_fetching(b->children[i], stop_images, stop_spools);
}
}
/* May not want to stop file saves */
if (!stop_spools && b->save_link) return;
/* Stop the main fetch, stop any reformatting, and */
/* stop image fetching. */
fetch_cancel(b);
reformat_stop(b);
if (stop_images) image_abort_fetches(b);
/* If this is the ancestor, tell WebServe to stop all activity */
/* as well (if we're running full screen). Can't do this if */
/* targetting a frame as we may still want the other frames */
/* to keep fetching (e.g. the images in a navigation panel */
/* may still be coming in whilst that panel is used to open a */
/* link in some other frame). */
if (controls.stop_proxy && choices.full_screen && !b->ancestor) utils_stop_proxy();
}
/*************************************************/
/* frames_collapse_child_tree() */
/* */
/* Used during traversal of the child tree to */
/* close down unwanted frames. See the parameter */
/* list for the three browser_data structs */
/* required. */
/* */
/* If the third browser has children the */
/* function will call itself with the given base */
/* browser until the browser to close has no */
/* children. It then closes it (unless it's the */
/* same as the base browser, in which case the */
/* final exit condition is reached) and */
/* decrements the parent's child counter. */
/* Recursion then collapses a level. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* for the base browser - that is, */
/* the one that won't be closed; */
/* */
/* Pointer to a browser_data struct */
/* that has the entry in its array */
/* of children for the browser given */
/* in the next parameter, i.e. the */
/* parent browser; */
/* */
/* Pointer to a browser_data struct */
/* that may have children, which */
/* is one of those that will be */
/* closed (unless it's the same as */
/* the base structure, which will */
/* tend to be the case on first */
/* call of the function). */
/*************************************************/
static void frames_collapse_child_tree(browser_data * base, browser_data * real_parent, browser_data * close)
{
if (!base || !close) return;
while (close->nchildren) frames_collapse_child_tree(base, close, (browser_data *) close->children[close->nchildren - 1]);
/* At this stage, might have called ourselves many times or */
/* not at all. In any event, we've reached a browser with */
/* no children - it's at the end of the tree. So if this */
/* isn't the base browser - at which point the tree must be */
/* closed down - close this browser. */
if (close != base)
{
windows_close_browser(close);
if (real_parent)
{
real_parent->nchildren --;
if (!real_parent->nchildren) memory_set_chunk_size(real_parent, NULL, CK_CHIL, 0);
}
}
close->frameset = NULL;
return;
}
/*************************************************/
/* frames_collapse_set() */
/* */
/* Given a parent browser, close all children. */
/* */
/* Parameters: Pointer to parent browser_data */
/* struct. */
/*************************************************/
void frames_collapse_set(browser_data * b)
{
_swix(Hourglass_Start, _IN(0), 10);
frames_collapse_child_tree(b, NULL, b);
_swix(Hourglass_Off, 0);
}
/*************************************************/
/* frames_find_named() */
/* */
/* If a given name is found attached to the */
/* given window or one of its children, return */
/* the browser_data struct for that window (else */
/* NULL). The check is case insensitive. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* representing the parent (it and */
/* all its children are searched for */
/* the name); */
/* */
/* Pointer to the name. */
/* */
/* Returns: Pointer to the browser_data */
/* struct of that name, or NULL if */
/* not found. */
/*************************************************/
browser_data * frames_find_named(browser_data * parent, char * name)
{
int child = 0;
if (!parent || !name || (name && !*name)) return NULL;
/* If the parent matches the given name, return it */
if (parent->window_name && *parent->window_name && !utils_strcasecmp(parent->window_name, name)) return parent;
/* Otherwise, go through the list of children */
if (parent->nchildren)
{
for (child = 0; child < parent->nchildren; child ++)
{
browser_data * found;
found = frames_find_named((browser_data *) parent->children[child], name);
if (found) return found;
}
}
return NULL;
}
/*************************************************/
/* frames_find_target() */
/* */
/* Given a base browser and a frame target name, */
/* returns the browser to which the target */
/* refers. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* that the tag lies in; */
/* */
/* Pointer to the target string. */
/* */
/* Returns: Pointer to the targetted browser, */
/* or NULL to create a new window. */
/* Note that if a new window is not */
/* to be opened, NULL will *never* */
/* be passed, even if the target */
/* field of the given token is (say) */
/* NULL itself. I.e., the caller */
/* doesn't need to worry about such */
/* cases. */
/* */
/* Assumes: In the case of named target */
/* windows where the name cannot be */
/* found, NULL is returned - the */
/* caller is expected to then open a */
/* new window named after the target */
/* given to this function. */
/*************************************************/
browser_data * frames_find_target(browser_data * b, const char * target)
{
browser_data * ancestor;
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_find_target: Called for %p, target %p\n",b,target);
#endif
/* Only proceed if there's a browser, a token, and that */
/* token has a target which isn't a null string. */
if (b && target && *target)
{
#ifdef TRACE
if (tl & (1u<<17)) Printf("frames_find_target: Target = '%s'\n",target);
#endif
if (!utils_strcasecmp(target, "_top")) /* Open in the top level window */
{
ancestor = b->ancestor;
if (!ancestor) ancestor = b->real_parent;
if (!ancestor) ancestor = b;
return ancestor;
}
else if (!utils_strcasecmp(target, "_self")) /* Open within the frame */
{
return b;
}
else if (!utils_strcasecmp(target, "_blank")) /* Open in a new, blank window */
{
return NULL;
}
else if (!utils_strcasecmp(target, "_parent")) /* Open in the frame's parent */
{
browser_data * parent = b->real_parent;
/* _parent is taken by most page authors to mean the complete parent document, */
/* not the parent frame. That is, if one document defines within itself a */
/* nested frameset, then _parent does not refer to any of those nested frames; */
/* it refers to the frame holding the orignal document. */
/* */
/* Consequently, we need to follow real_parent pointers until we reach a child */
/* frame which has a non-NULL display URL field, i.e. a frame which has frames */
/* but has got them by fetching a document. */
while (parent->real_parent && !parent->urlddata) parent = parent->real_parent;
if (!parent) parent = b->parent;
if (!parent) parent = b->ancestor;
if (!parent) parent = b;
return parent;
}
else
{
/* According to the frame spec at the time of writing, */
/* names must start with an alphanumeric character. */
if (isalnum(*target)) /* Named window */
{
browser_data * named;
ancestor = utils_ancestor(b);
named = frames_find_named(ancestor, (char *) target);
/* If the name isn't found, try all windows, rather */
/* than just children of the specified one. */
if (!named)
{
browser_data * found = NULL;
named = last_browser;
while (named && !found)
{
if (
named->window_name &&
*named->window_name &&
!utils_strcasecmp(named->window_name, target)
)
found = named;
else named = named->previous;
}
/* If the name still isn't there, supposed to open a */
/* new window with this name. Flag this by returning */
/* NULL. */
if (!found) return NULL;
else return found;
}
return named;
}
}
}
/* For null/unspecified targets, use the same frame */
if (!target || !*target) return b;
/* If all else fails, we don't recognise the name or it is */
/* illegal. Safest to open in a new window, leaving the */
/* original document intact. */
return NULL;
}
/*************************************************/
/* frames_find_another_frame() */
/* */
/* Given a browser_data structure which is a */
/* child frame, finds the next structure in the */
/* frame layout - intended for keyboard */
/* navigation through frames. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* which is the current child frame; */
/* */
/* Direction - 0 to find the logical */
/* next frame in the set, 1 to find */
/* the logical previous. */
/* */
/* Returns: Pointer to a browser_data struct */
/* which is the next child frame. */
/*************************************************/
browser_data * frames_find_another_frame(browser_data * current, int dir)
{
browser_data * ancestor;
int found = 0;
if (!current) return NULL;
ancestor = utils_ancestor(current);
/* Finding the logical next frame */
if (!dir)
{
browser_data * next;
next = frames_find_next_frame(ancestor, current, &found);
/* If 'next' is NULL, it could be because the current frame is */
/* the last one in the group. So try searching again from the */
/* ancestor (the routine will have updated 'found' so that it */
/* knows not to wait until it's got the current frame anymore). */
if (!next) return frames_find_next_frame(ancestor, current, &found);
return next;
}
else
{
browser_data * previous;
previous = frames_find_previous_frame(ancestor, current, &found);
if (!previous) return frames_find_previous_frame(ancestor, current, &found);
return previous;
}
return NULL;
}
/*************************************************/
/* frames_find_next_frame() */
/* */
/* Recursive back-end to */
/* frames_find_another_frame, for finding the */
/* logical next frame. */
/* */
/* Parameters: Pointer to the browser_data */
/* struct to compare with the */
/* current one; */
/* */
/* Pointer to the browser_data */
/* struct which is the current one; */
/* */
/* Pointer to an int which should */
/* contain 0 on entry and will be */
/* written to by the function. */
/* */
/* Returns: As frames_find_next_frame. */
/*************************************************/
static browser_data * frames_find_next_frame(browser_data * check, browser_data * current, int * found)
{
browser_data * b = NULL;
int c = 0;
while (!b && c < check->nchildren)
{
if (check->children[c]->nchildren)
{
/* Recursive call, if the child has children */
b = frames_find_next_frame(check->children[c], current, found);
}
else
{
/* 'found' is set to 1 if the 'current' browser_data struct */
/* has been found. If so, we can use the next struct that */
/* has no children. If not, and the struct being examined */
/* is the same as 'current', set 'found'. */
if (*found)
{
if (check->children[c] != current) return check->children[c];
}
else
{
if (check->children[c] == current) *found = 1;
}
}
c++;
}
return b;
}
/*************************************************/
/* frames_find_previous_frame() */
/* */
/* Recursive back-end to */
/* frames_find_another_frame, for finding the */
/* logical previous frame. */
/* */
/* Parameters: Pointer to the browser_data */
/* struct to compare with the */
/* current one; */
/* */
/* Pointer to the browser_data */
/* struct which is the current one; */
/* */
/* Pointer to an int which should */
/* contain 0 on entry and will be */
/* written to by the function. */
/* */
/* Returns: As frames_find_next_frame. */
/*************************************************/
static browser_data * frames_find_previous_frame(browser_data * check, browser_data * current, int * found)
{
browser_data * b = NULL;
int c = check->nchildren - 1;
while (!b && c >= 0)
{
if (check->children[c]->nchildren)
{
/* Recursive call, if the child has children */
b = frames_find_previous_frame(check->children[c], current, found);
}
else
{
/* 'found' is set to 1 if the 'current' browser_data struct */
/* has been found. If so, we can use the next struct that */
/* has no children. If not, and the struct being examined */
/* is the same as 'current', set 'found'. */
if (*found)
{
if (check->children[c] != current) return check->children[c];
}
else
{
if (check->children[c] == current) *found = 1;
}
}
c--;
}
return b;
}
/*************************************************/
/* frames_highlight_frame() */
/* */
/* Highlights a frame by showing a border around */
/* it, made of 'Highlight' borderless window */
/* objects in the Res file. The highlight is */
/* removed by a NULL poll timer. */
/* */
/* Won't highlight ancestor windows, and only */
/* highlights if keyboard control is enabled. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the frame to be */
/* highlighted. */
/*************************************************/
_kernel_oserror * frames_highlight_frame(browser_data * b)
{
browser_data * ancestor;
WimpGetWindowStateBlock s;
WindowShowObjectBlock show;
_kernel_oserror * e;
BBox top, bottom, left, right;
/* Don't do anything if not using keyboard control */
if (!choices.keyboard_ctrl) return NULL;
/* Don't do anything if an ancestor */
if (!b->ancestor) return NULL;
/* Otherwise, proceed */
ancestor = utils_ancestor(b);
s.window_handle = b->window_handle;
e = wimp_get_window_state(&s);
if (e) return e;
/* If not already present, create the highlight window objects */
if (!highlight_top)
{
e = toolbox_create_object(0, "Highlight", &highlight_top);
if (e) return e;
e = toolbox_create_object(0, "Highlight", &highlight_bottom);
if (e) return e;
e = toolbox_create_object(0, "Highlight", &highlight_left);
if (e) return e;
e = toolbox_create_object(0, "Highlight", &highlight_right);
if (e) return e;
/* Work out how long to leave the highlight visible */
highlight_for = atoi(lookup_control("ShowFHighFor:30",0,0));
if (highlight_for < 5) highlight_for = 5;
if (highlight_for > 1000) highlight_for = 3000;
/* Register a null claimant to get rid of the objects shortly */
register_null_claimant(Wimp_ENull, (WimpEventHandler *) frames_remove_highlight_timer, b);
}
/* Reset the highlight removal timer */
e = _swix(OS_ReadMonotonicTime,
_OUT(0),
&highlight_timer);
if (e) return e;
/* Adjust the visible area coordinates for toolbars */
{
int htop, hbot;
if (!controls.swap_bars)
{
htop = toolbars_url_height(b) + toolbars_button_height(b); /* Physically, the button bar and URL bar are just one real toolbar */
hbot = toolbars_status_height(b);
}
else
{
htop = toolbars_status_height(b);
hbot = toolbars_url_height(b) + toolbars_button_height(b);
}
if (htop) htop += wimpt_dy();
if (hbot) hbot += wimpt_dy();
s.visible_area.ymax -= htop;
s.visible_area.ymin += hbot;
}
/* Work out the visible areas that the highlight windows should take */
top.xmin = s.visible_area.xmin + 2; /**************************************/
top.ymin = s.visible_area.ymax - 6; /* If a lower case letter shows where */
top.xmax = s.visible_area.xmax - 2; /* the appropriate box covers pixels, */
top.ymax = s.visible_area.ymax - 2; /* and the upper case letters show */
/* the actual pixels referenced by */
bottom.xmin = s.visible_area.xmin + 6; /* (xmin, ymin) and (xmax, ymax), */
bottom.ymin = s.visible_area.ymin + 2; /* then we are calculating: */
bottom.xmax = s.visible_area.xmax - 2; /* S */
bottom.ymax = s.visible_area.ymin + 6; /* ssssssssssssss */
/* s T Rs */
left.xmin = s.visible_area.xmin + 2; /* s ttttttttrr s */
left.ymin = s.visible_area.ymin + 2; /* s TtLtttttrr s */
left.xmax = s.visible_area.xmin + 6; /* s ll RrBs */
left.ymax = s.visible_area.ymax - 6; /* s llbbbbbbbb s */
/* s LlBbbbbbbb s */
right.xmin = s.visible_area.xmax - 6; /* s s */
right.ymin = s.visible_area.ymin + 6; /* Ssssssssssssss */
right.xmax = s.visible_area.xmax - 2; /* */
right.ymax = s.visible_area.ymax - 2; /**************************************/
/* Show the objects */
show.xscroll = 0;
show.yscroll = 0;
show.behind = -1;
show.visible_area = top;
show.parent_window_handle = ancestor->window_handle;
show.alignment_flags = 0;
e = toolbox_show_object(Toolbox_ShowObject_AsSubWindow, highlight_top, Toolbox_ShowObject_FullSpec, &show, ancestor->self_id, -1);
if (e) return e;
/* The show call above can modify the contents of the 'show' */
/* block passed to it, so need to fill in the values again */
/* for each call. */
show.xscroll = 0;
show.yscroll = 0;
show.behind = -1;
show.visible_area = bottom;
show.parent_window_handle = ancestor->window_handle;
show.alignment_flags = 0;
e = toolbox_show_object(Toolbox_ShowObject_AsSubWindow, highlight_bottom, Toolbox_ShowObject_FullSpec, &show, ancestor->self_id, -1);
if (e) return e;
/* Show them */
show.xscroll = 0;
show.yscroll = 0;
show.behind = -1;
show.visible_area = left;
show.parent_window_handle = ancestor->window_handle;
show.alignment_flags = 0;
e = toolbox_show_object(Toolbox_ShowObject_AsSubWindow, highlight_left, Toolbox_ShowObject_FullSpec, &show, ancestor->self_id, -1);
if (e) return e;
show.xscroll = 0;
show.yscroll = 0;
show.behind = -1;
show.visible_area = right;
show.parent_window_handle = ancestor->window_handle;
show.alignment_flags = 0;
e = toolbox_show_object(Toolbox_ShowObject_AsSubWindow, highlight_right, Toolbox_ShowObject_FullSpec, &show, ancestor->self_id, -1);
if (e) return e;
/* Remember the highlighted frame, for functions other than */
/* the null handler that removes the highlight (which gets */
/* passed the value directly). */
highlight_frame = b;
/* Finished */
return NULL;
}
/*************************************************/
/* frames_remove_highlight_timer() */
/* */
/* A NULL event handler which times how long the */
/* frame highlight objects have been visible */
/* and removes them after a time defined by the */
/* Choices file 'ShowFHighFor' entry. */
/* */
/* Registered by frames_highlight_frame. */
/* */
/* Parameters as standard for a Wimp event */
/* handler. */
/*************************************************/
static int frames_remove_highlight_timer(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
int time;
if (_swix(OS_ReadMonotonicTime,
_OUT(0),
&time)) return 0;
if (time - highlight_timer > highlight_for)
{
/* Delete the objects (so removing the highlight) */
if (highlight_top) toolbox_delete_object(0, highlight_top);
if (highlight_bottom) toolbox_delete_object(0, highlight_bottom);
if (highlight_left) toolbox_delete_object(0, highlight_left);
if (highlight_right) toolbox_delete_object(0, highlight_right);
/* Reset the Object IDs, so that the highlight routine knows it needs */
/* to recreate the objects and reinstall this handler */
highlight_top = highlight_bottom = highlight_left = highlight_right = 0;
/* Clear the internal record of the highlighted frame */
highlight_frame = NULL;
/* Remove the handler */
deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) frames_remove_highlight_timer, handle);
}
return 0;
}
/*************************************************/
/* frames_remove_highlight() */
/* */
/* Removes the highlight objects from around a */
/* frame, regardless of which frame is */
/* highlighted. */
/*************************************************/
_kernel_oserror * frames_remove_highlight(void)
{
_kernel_oserror * e;
/* Delete the objects (so removing the highlight) */
if (highlight_top)
{
e = toolbox_delete_object(0, highlight_top);
if (e) return e;
}
if (highlight_bottom)
{
e = toolbox_delete_object(0, highlight_bottom);
if (e) return e;
}
if (highlight_left)
{
e = toolbox_delete_object(0, highlight_left);
if (e) return e;
}
if (highlight_right)
{
e = toolbox_delete_object(0, highlight_right);
if (e) return e;
}
/* Reset the Object IDs, so that the highlight routine knows it needs */
/* to recreate the objects and reinstall this handler */
highlight_top = highlight_bottom = highlight_left = highlight_right = 0;
/* Clear the internal record of the highlighted frame */
highlight_frame = NULL;
return NULL;
}
/*************************************************/
/* frames_remove_highlight_if_present() */
/* */
/* Removes the highlight objects from around a */
/* given frame, if that frame is highlighted. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the highlight. */
/*************************************************/
_kernel_oserror * frames_remove_highlight_if_present(browser_data * b)
{
if (b && b == highlight_frame) return frames_remove_highlight();
return NULL;
}