Toolbars

/* 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   : Toolbars.c                             */
/*                                                 */
/* Purpose: Toolbar-related functions for the      */
/*          browser.                               */
/*                                                 */
/* Author : A.D.Hodgkinson                         */
/*                                                 */
/* History: 21-Nov-96: Created.                    */
/***************************************************/

#include <stdlib.h>
#include <stdio.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 "gadgets.h"

#include "Dialler.h"

#include "svcprint.h"
#include "Global.h"
#include "Utils.h"

#include "Browser.h"
#include "ChoiceDefs.h"
#include "CSIM.h"
#include "CtrlDefs.h"
#include "Fetch.h" /* (Which itself includes URLstat.h) */
#include "Handlers.h"
#include "History.h"
#include "Images.h"
#include "Memory.h"
#include "Mouse.h"
#include "Reformat.h"
#include "URLutils.h"
#include "URLveneer.h"

#include "Toolbars.h"

/* Locals */

static int bar_overlap = -1;

/* Local types */

/* Used to record the requirement of a particular browser to */
/* display a certain message in the status bar. For a given  */
/* page which may include frames, an array of these is built */
/* as the frameset is defined and starts to fetch pages.     */
/* The actual status message is derived from examining the   */
/* priorities of all of the messages.                        */

typedef struct status_content
{
  browser_data * b;
  status_type    type;
  unsigned int   start;
  unsigned int   end;
}
status_content;

/* Static function prototypes */

static ObjectId          toolbars_get_upper_backend      (browser_data * b);
static ObjectId          toolbars_get_lower_backend      (browser_data * b);

static void              toolbars_set_size               (ObjectId o, int height, int yscroll, int flags);
static int               toolbars_find_overlap           (ObjectId o);
static int               toolbars_bar_overlap            (ObjectId o);

static _kernel_oserror * toolbars_animation_set_sprite   (browser_data * b);
static _kernel_oserror * toolbars_update_specific_status (browser_data * b, browser_data * ancestor, int entry, status_type type);
static int               toolbars_write_status           (browser_data * ancestor);
static status_type       toolbars_return_inferred        (browser_data * b);
static _kernel_oserror * toolbars_infer_status           (browser_data * b, browser_data * ancestor, int entry);
static _kernel_oserror * toolbars_add_status_item        (browser_data * ancestor);
static status_type       toolbars_return_act_status      (browser_data * b);

static int               toolbars_count_file_saves       (browser_data * b);
static int               toolbars_count_file_saves_r     (browser_data * b);
static int               toolbars_calculate_progress     (browser_data * b);
static int               toolbars_calculate_progress_r   (browser_data * b, int saves);
static int               toolbars_create_progress        (browser_data * b, char * buffer, int buffer_size);

/*************************************************/
/* toolbars_get_upper()                          */
/*                                               */
/* Returns the object ID of the upper toolbar.   */
/* This may well not be the internal top left    */
/* toolbar of the window due to the swap_bars    */
/* flag or merged toolbars.                      */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the toolbar.          */
/*                                               */
/* Returns:    Object ID of the toolbar, or NULL */
/*             for an error / no upper toolbar.  */
/*************************************************/

ObjectId toolbars_get_upper(browser_data * b)
{
  if (controls.swap_bars) return toolbars_get_lower_backend(b);
  else                    return toolbars_get_upper_backend(b);
}

/*************************************************/
/* toolbars_get_upper_backend()                  */
/*                                               */
/* Returns the object ID of the upper toolbar.   */
/* This may well not be the internal top left    */
/* toolbar of the window due to merged toolbars. */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the toolbar.          */
/*                                               */
/* Returns:    Object ID of the toolbar, or NULL */
/*             for an error / no upper toolbar.  */
/*************************************************/

static ObjectId toolbars_get_upper_backend(browser_data * b)
{
  ObjectId t;

  if (b->all_in_bottom)
  {
    if (
         window_get_tool_bars(InternalBottomLeft,
                              b->self_id,
                              &t,
                              NULL,
                              NULL,
                              NULL)
       )
       return NULL;

    else return t;
  }

  if (
       window_get_tool_bars(InternalTopLeft,
                            b->self_id,
                            NULL,
                            &t,
                            NULL,
                            NULL)
     )
     return NULL;

  else return t;
}

/*************************************************/
/* toolbars_get_lower()                          */
/*                                               */
/* Returns the object ID of the lower toolbar.   */
/* This may well not be the internal bottom      */
/* left toolbar of the window due to the         */
/* swap_bars flag or merged toolbars.            */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the toolbar.          */
/*                                               */
/* Returns:    Object ID of the toolbar, or NULL */
/*             for an error / no lower toolbar.  */
/*************************************************/

ObjectId toolbars_get_lower(browser_data * b)
{
  if (controls.swap_bars) return toolbars_get_upper_backend(b);
  else                    return toolbars_get_lower_backend(b);
}

/*************************************************/
/* toolbars_get_lower_backend()                  */
/*                                               */
/* Returns the object ID of the lower toolbar.   */
/* This may well not be the internal bottom      */
/* left toolbar of the window due to merged      */
/* toolbars.                                     */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the toolbar.          */
/*                                               */
/* Returns:    Object ID of the toolbar, or NULL */
/*             for an error / no lower toolbar.  */
/*************************************************/

static ObjectId toolbars_get_lower_backend(browser_data * b)
{
  ObjectId t;

  if (b->all_in_top)
  {
    if (
         window_get_tool_bars(InternalTopLeft,
                              b->self_id,
                              NULL,
                              &t,
                              NULL,
                              NULL)
       )
       return NULL;

    else return t;
  }

  if (
       window_get_tool_bars(InternalBottomLeft,
                            b->self_id,
                            &t,
                            NULL,
                            NULL,
                            NULL)
     )
     return NULL;

  else return t;
}

/*************************************************/
/* toolbars_set_size()                           */
/*                                               */
/* Sets the vertical visible height and scroll   */
/* position of a given toolbar.                  */
/*                                               */
/* Parameters: The object ID of the toolbar;     */
/*                                               */
/*             The visible height to set it to;  */
/*                                               */
/*             The y scroll offset to give it;   */
/*                                               */
/*             Flags - alter InternalTopLeft, or */
/*             InternalBottomLeft toolbar.       */
/*************************************************/

static void toolbars_set_size(ObjectId o, int height, int yscroll, int flags)
{
  WimpGetWindowStateBlock s;
  ObjectId                p;

  /* Get the toolbar's parent object (the window) */

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("\ntoolbars_set_size: Called with object ID %p\n",(void *) o);
  #endif

  toolbox_get_parent(0, o, &p, NULL);

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_set_size: Parent ID is %p\n",(void *) p);
  #endif

  /* This has to be here, or the toolbar can drop out of */
  /* the parent window (?!)...                           */

  ChkError(toolbox_show_object(0, o, 0, 0, p, -1));

  /* Get the toolbar's wimp handle and size through Wimp_GetWindowState */

  ChkError(window_get_wimp_handle(0, o, &s.window_handle));
  ChkError(wimp_get_window_state(&s));

  /* Set the vertical size. */

  if (!controls.swap_bars)
  {
    s.visible_area.ymin = s.visible_area.ymax - height;
    ChkError(toolbox_show_object(0, o, 1, &s.visible_area, p, -1));
  }
  else
  {
    s.visible_area.ymax = s.visible_area.ymin + height;
    ChkError(toolbox_show_object(0, o, 1, &s.visible_area, p, -1));
  }

  /* This call is needed for the toolbox to recognise the new size */

  ChkError(window_set_tool_bars(flags, p, o, o, 0, 0));

  /* Set the scroll position - the set_tool_bars call will */
  /* trounce the scroll position (sigh) if this call is    */
  /* done beforehand, as part of the first show_object     */
  /* call.                                                 */

  s.yscroll = yscroll;
  ChkError(toolbox_show_object(0, o, 1, &s.visible_area, p, -1));

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_set_size: Successful\n");
  #endif
}

/*************************************************/
/* toolbars_find_overlap()                       */
/*                                               */
/* Finds the overlap of the height gadgets 0xd   */
/* and 0xe in the upper toolbar, recording this  */
/* in the local bar_overlap int to make future   */
/* references faster.                            */
/*                                               */
/* Parameters: The object ID of the toolbar.     */
/*************************************************/

static int toolbars_find_overlap(ObjectId o)
{
  BBox url, but;
  int  overlap;

  if (gadget_get_bbox(0, o, URLBarSpacer,    &url)) return 0;
  if (gadget_get_bbox(0, o, ButtonBarSpacer, &but)) return 0;

  overlap = but.ymax - url.ymin;
  if (overlap >= 0) return overlap;

  return 0;
}

/*************************************************/
/* toolbars_bar_overlap()                        */
/*                                               */
/* Returns the overlap of the height gadgets 0xd */
/* and 0xe in the upper toolbar, using a local   */
/* cached value for speed.                       */
/*                                               */
/* Parameters: The object ID of the toolbar.     */
/*************************************************/

static int toolbars_bar_overlap(ObjectId o)
{
  if (bar_overlap < 0) bar_overlap = toolbars_find_overlap(o);

  return bar_overlap;
}

/*************************************************/
/* toolbars_set_presence()                       */
/*                                               */
/* Reads the browser_data structure associated   */
/* with a given browser window object ID, and    */
/* ensures the toolbars associated with that     */
/* window match the flags set inside the data    */
/* structure.                                    */
/*                                               */
/* Parameters: A browser_data struct relevant to */
/*             the window holding the toolbars;  */
/*                                               */
/*             A flags word holding the toolbars */
/*             to alter - InternalTopLeft, or    */
/*             InternalBottomLeft.               */
/*************************************************/

void toolbars_set_presence(browser_data * b, unsigned int flags)
{
  ObjectId o;
  ObjectId t;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("\ntoolbars_set_presence: Called with %p\n", b);
  #endif

  /* If not a valid browser_data structure, exit */

  if (!is_known_browser(b)) return;

  /* Toolbars can only exist on ancestor browser windows, not */
  /* in any child frames.                                     */

  b = utils_ancestor(b);
  o = b->self_id;

  /* Deal with merged toolbars separately - they're a simple case */

  if (b->all_in_top || b->all_in_bottom)
  {
    /* The URL bar flag is looked at to see if the toolbar is on or off */
    /* as well as the status bar flag, as the former is used for upper  */
    /* toolbars (as it prompts the vertical shift of page objects), and */
    /* the latter for bottom merged toolbars.                           */

    if (b->all_in_top)
    {
      t = toolbars_get_upper(b);

      if (t)
      {
        #ifdef TRACE
          if (tl & (1u<<1)) Printf("toolbars_set_presence: Top left toolbar ID is %p\n",(void *) t);
        #endif

        if (b->url_bar && b->status_bar) ChkError(toolbox_show_object(0, t, 0, NULL, o, -1));
        else ChkError(toolbox_hide_object(0, t));
      }
    }
    else
    {
      t = toolbars_get_lower(b);

      if (t)
      {
        #ifdef TRACE
          if (tl & (1u<<1)) Printf("toolbars_set_presence: Bottom left toolbar ID is %p\n",(void *) t);
        #endif

        if (b->url_bar && b->status_bar) ChkError(toolbox_show_object(0, t, 0, NULL, o, -1));
        else ChkError(toolbox_hide_object(0, t));
      }
    }

    return;
  }

  /* Proceed with 'normal' toolbars */

  if (flags & InternalTopLeft)
  {
    t = toolbars_get_upper(b);

    if (t)
    {
      #ifdef TRACE
        if (tl & (1u<<1)) Printf("toolbars_set_presence: Top left toolbar ID is %p\n",(void *) t);
      #endif

      /* URL and button bars both present */

      if ((b->url_bar) && (b->button_bar)) toolbars_set_size(t,
                                                             toolbars_button_height(b) + toolbars_url_height(b),
                                                             0,
                                                             controls.swap_bars ? InternalBottomLeft : InternalTopLeft);
      /* URL bar only present */

      else if ((b->url_bar) && !(b->button_bar)) toolbars_set_size(t,
                                                                   toolbars_url_height(b),
                                                                   0,
                                                                   controls.swap_bars ? InternalBottomLeft : InternalTopLeft);
      /* Button bar only present */

      else if (!(b->url_bar) && (b->button_bar))
      {
        /* Find what would be the URL bar height if it was present on its own */

        BBox w;

        gadget_get_bbox(0, t, URLBarSpacer, &w);

        /* Now set the toolbar size and Y scroll offset to show only the buttons */

        toolbars_set_size(t,
                          toolbars_button_height(b),
                          - (w.ymax - w.ymin) + toolbars_bar_overlap(t),
                          controls.swap_bars ? InternalBottomLeft : InternalTopLeft);
      }

      /* URL bar and button bar both absent */

      else toolbox_hide_object(0, t);
    }
  }

  if (flags & InternalBottomLeft)
  {
    t = toolbars_get_lower(b);

    if (t)
    {
      #ifdef TRACE
        if (tl & (1u<<1)) Printf("toolbars_set_presence: Bottom left toolbar ID is %p\n",(void *) t);
      #endif

      /* Status bar present */

      if (b->status_bar) ChkError(toolbox_show_object(0, t, 0, NULL, o, -1));

      /* Status bar absent */

      else ChkError(toolbox_hide_object(0, t));
    }
  }

  /* Make sure that the toolbars have the correct gadget positions */

  if (choices.move_gadgets != Choices_MoveGadgets_Never) toolbars_move_gadgets(b);

//  /* Make sure that the window is completely redrawn */
//
//  {
//    WimpGetWindowStateBlock s;
//    s.window_handle = b->window_handle;
//    ChkError(wimp_get_window_state(&s));
//    coords_box_toworkarea(&s.visible_area, (WimpRedrawWindowBlock *) &s);
//    ChkError(wimp_force_redraw(b->window_handle,
//                               s.visible_area.xmin,
//                               s.visible_area.ymin,
//                               s.visible_area.xmax,
//                               s.visible_area.ymax));
//  }

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("\ntoolbars_set_presence: Successful\n");
  #endif
}

/*************************************************/
/* toolbars_move_gadgets()                       */
/*                                               */
/* Generally called as part of some window       */
/* resize event, this function moves and/or      */
/* resizes various gadgets in various toolbars,  */
/* if the toolbars are present in the window.    */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the toolbars.         */
/*************************************************/

void toolbars_move_gadgets(browser_data * p)
{
  BBox                      b, g1, g2;
  int                       right, gap, width;
  ObjectId                  t;
  WimpGetWindowStateBlock   s;
  _kernel_oserror         * e;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("\ntoolbars_move_gadgets: Called\n");
  #endif

  /* Small fetch windows can't move their status line contents */

  if (p->small_fetch) return;

  /* Otherwise, continue as normal */

  s.window_handle = p->window_handle;
  ChkError(wimp_get_window_state(&s));

  b = s.visible_area;
  if ((b.xmax - b.xmin) < controls.minimum_convergence) b.xmax = b.xmin + controls.minimum_convergence;

  /* If the URL bar is present... */

  if (p->url_bar)
  {
    t = toolbars_get_upper(p);

    if (t)
    {
      /* If the pop-up menu gadget for the History list needs to move, move it */
      /* and resize the URL writable to maintain a fixed distance between the  */
      /* two gadgets.                                                          */

      e      = gadget_get_bbox(0, t, URLBarHistoryMenuR, &g1);  /* Get the popup's bounding box    */
      ChkError(gadget_get_bbox(0, t, URLBarWrit,  &g2)); /* Get the writable's bounding box */

      /* Where should the right hand edge of the popup be? */

      right = b.xmax - b.xmin - 4;

      /* If the popup doesn't exist, want to set up a BBox as if a zero */
      /* width popup was present.                                       */

      if (e) g1.xmin = g2.xmax, g1.ymin = 0, g1.xmax = !right, g1.ymax = 0;

      /* Gap is the distance between the right hand edge of the URL writable */
      /* and the left hand edge of the popup.                                */

      gap = g1.xmin - g2.xmax;

      /* Is this the same as it is already? If not, move / resize the gadgets. */

      if (right != g1.xmax)
      {
        if (!e)
        {
          /* Move the popup */

          width = g1.xmax - g1.xmin;

          g1.xmax = right;
          g1.xmin = right - width;

          ChkError(gadget_move_gadget(0, t, URLBarHistoryMenuR, &g1));
        }

        /* Resize the URL writable */

        g2.xmax = g1.xmin - gap;

        ChkError(gadget_move_gadget(0, t, URLBarWrit,  &g2));
      }
    }
  }

  /* If the status bar is present... */

  if (p->status_bar)
  {
    t = toolbars_get_lower(p);

    if (t)
    {
      /* As above, move the byte counter display field if need be, */
      /* and if it does move, resize the status display field.     */

      ChkError(gadget_get_bbox(0, t, StatusBarProgress, &g1));
      ChkError(gadget_get_bbox(0, t, StatusBarStatus, &g2));

      gap = g1.xmin - g2.xmax;

      right = b.xmax - b.xmin - 20;

      if (right != g1.xmax)
      {
        width = g1.xmax - g1.xmin;

        g1.xmax = right;
        g1.xmin = right - width;

        ChkError(gadget_move_gadget(0, t, StatusBarProgress, &g1));

        g2.xmax = g1.xmin - gap;

        ChkError(gadget_move_gadget(0, t, StatusBarStatus, &g2));
      }
    }
  }

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_move_gadgets: Successful\n");
  #endif
}

/*************************************************/
/* toolbars_animation_set_sprite()               */
/*                                               */
/* Sets the sprite in the button gadget used for */
/* the status bar animation.                     */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the animation.        */
/*************************************************/

static _kernel_oserror * toolbars_animation_set_sprite(browser_data * b)
{
  ObjectId t;
  char     v[32];
  int      time_now;

  /* Update the current frame time */

  if (
       _swix(OS_ReadMonotonicTime,
             _OUT(0),

             &time_now)
     )
     b->current_time = 0;

  else b->current_time = time_now;

  /* Find the status bar object Id */

  t = toolbars_get_lower(b);
  if (!t) return 0;

  /* Advance the frame counter and put a validation string  */
  /* that would give a button gadget the relevant animation */
  /* sprite into v.                                         */

  b->current_frame ++;
  if (b->current_frame >= animation_frames) b->current_frame = 0;

  sprintf(v, "sa%d\0", b->current_frame);

  /* Set the validation string on the status bar animation */
  /* button icon to v, so that the new sprite is shown.    */

  return button_set_validation(0, t, StatusBarAnimAnim, v);
}

/*************************************************/
/* toolbars_animation()                          */
/*                                               */
/* Advances the browser animation in the status  */
/* bar by one frame.                             */
/*                                               */
/* Parameters are as for a standard Wimp event   */
/* handler (this is called on null events).      */
/*************************************************/

int toolbars_animation(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
  int time_now;

  /* What is the time now? */

  if (
       _swix(OS_ReadMonotonicTime,
             _OUT(0),

             &time_now)
     )
     return 0;

  /* If we have animation frames, a displayed status bar, and */
  /* enough time has passed, advance the animation.           */

  if (
       handle->status_bar   &&
       animation_frames > 0 &&
       time_now         > (handle->current_time + controls.anim_delay)
     )
     ChkError(toolbars_animation_set_sprite(handle));

  return 0;
}

/*************************************************/
/* toolbars_animation_drift()                    */
/*                                               */
/* Advances the browser animation in the status  */
/* bar by one frame, until it reaches the first  */
/* frame, when it deregisters itself.            */
/*                                               */
/* Parameters are as for a standard Wimp event   */
/* handler (this is called on null events).      */
/*************************************************/

int toolbars_animation_drift(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
  int time_now;

  /* What is the time now? */

  if (
       _swix(OS_ReadMonotonicTime,
             _OUT(0),

             &time_now)
     )
     return 0;

  if (
       handle->status_bar   &&
       animation_frames > 0 &&
       time_now         > (handle->current_time + controls.anim_delay)
     )
  {
    ChkError(toolbars_animation_set_sprite(handle));

    /* Deregister the handler if at frame 0. */

    if (handle->current_frame == 0)
    {
      deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) toolbars_animation_drift, handle);
      handle->anim_drift = 0;
    }
  }

  return 0;
}

/*************************************************/
/* toolbars_animate_slow()                       */
/*                                               */
/* Advances an animation in component            */
/* StatusBarAnimAnim (see Toolbars.h) in an      */
/* object of ID given in void * handle (must be  */
/* cast to this to fit as a Wimp event handler)  */
/* by one frame for each complete cycle of the   */
/* main status animation (whether that is        */
/* actually animating or not).                   */
/*                                               */
/* So that more than one dialogue could be up    */
/* and animating at once, the object's client    */
/* handle is used to store the current animation */
/* frame. Consequently this routine is of no use */
/* to dialogues that need the client handle for  */
/* other reasons.                                */
/*                                               */
/* Parameters are as for a standard Wimp event   */
/* handler (this is called on null events).      */
/*************************************************/

int toolbars_animate_slow(int eventcode, WimpPollBlock * b, IdBlock * idb, void * handle)
{
  ObjectId o = (ObjectId) handle;
  char     v[32];
  int      slow_animation_frame;

  /* Because client handles can only store one thing, in this case */
  /* the animation frame, we have no easy way of storing the time  */
  /* that the animation was last advanced by a frame. So, make the */
  /* assumption of a 1cs poll time, and use a strategy of integer  */
  /* division of frame count to get the actual frame number. The   */
  /* timing is thus not at all independent of machine load, but    */
  /* the dialogue box animations are a very low priority issue.    */

  if (toolbox_get_client_handle(0, o, (void **) &slow_animation_frame)) return 0;

  /* Advance the frame counter and put a validation string  */
  /* that would give a button gadget the relevant animation */
  /* sprite into v.                                         */

  slow_animation_frame ++;
  if (slow_animation_frame >= animation_frames * animation_frames * controls.anim_delay) slow_animation_frame = 0;

  sprintf(v, "sa%d\0", slow_animation_frame / (animation_frames * controls.anim_delay));

  /* Set the validation string on the status bar animation */
  /* button icon to v, so that the new sprite is shown.    */

  button_set_validation(0, o, StatusBarAnimAnim, v);
  toolbox_set_client_handle(0, o, (void *) slow_animation_frame);

  return 0;
}

/*************************************************/
/* toolbars_hide_cgi()                           */
/*                                               */
/* This routine will look through a URL for a    */
/* ? and turn it into a terminator. This can be  */
/* used to hide CGI information from the user.   */
/*                                               */
/* Parameters: Pointer to the URL, which must be */
/*             writable in memory, as the first  */
/*             '?' it contains (if any) will be  */
/*             turned into a zero byte.          */
/*************************************************/

void toolbars_hide_cgi(char * url)
{
  char * search = url;

  while (*search)
  {
    if (*search == '?')
    {
      *search = '\0';
      break;
    }

    search++;
  }
}

/*************************************************/
/* toolbars_hide_internal()                      */
/*                                               */
/* When passed a pointer to an internal URL,     */
/* this routine finds the separator between the  */
/* internal specifier plus message token and the */
/* extra information in the URL, and copies this */
/* extra data down to the start of the URL.      */
/*                                               */
/* Parameters: Pointer to the URL, which may be  */
/*             altered quite significantly; so   */
/*             this should be a local copy held  */
/*             by the caller to avoid corrupting */
/*             any important full version of the */
/*             URL.                              */
/*************************************************/

void toolbars_hide_internal(char * iurl)
{
  char * extra;
  int    exoff;

  exoff = urlutils_internal_extra(iurl);
  if (!exoff) return;

  extra = iurl + exoff;

  memmove(iurl, extra, strlen(extra) + 1);
}

/*************************************************/
/* toolbars_update_status()                      */
/*                                               */
/* The standard external way of updating a       */
/* browser window's status bar. The given        */
/* requests that a given message type (see the   */
/* definition of status_type in Toolbars.h)      */
/* be used for the status bar.                   */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which wants the message putting   */
/*             in its (or its ancestor's)        */
/*             status bar;                       */
/*                                               */
/*             Type of message to display.       */
/*************************************************/

_kernel_oserror * toolbars_update_status(browser_data * b, status_type type)
{
  _kernel_oserror * e;
  browser_data    * ancestor = utils_ancestor(b);
  status_content  * contents;
  int               i, found;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_update_status: Called for %p, type %d\n",b,type);
  #endif

  /* Refer to the array through 'contents' - slightly more   */
  /* convenient than 'ancestor->status_contents' every time! */

  contents = ancestor->status_contents;

  /* See if the given browser has already got a message */
  /* registered with the base browser...                */

  if (contents)
  {
    #ifdef TRACE
      if (tl & (1u<<1))
      {
        Printf("\ntoolbars_update_status:");
        Printf("\nUpdating for browser %p; old contents:\n",b);

        Printf("\nEntry | b        | Message    | Decay");
        Printf("\n------+----------+------------+------\n");

        for (i = 0; i < ancestor->nstatus; i++)
        {
          switch (contents[i].type)
          {
            default: Printf("%d     | %08x | %02d UNKNOWN | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;

            case 0:  Printf("%d     | %08x | %02d Ready   | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;
            case 1:  Printf("%d     | %08x | %02d Viewing | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;

            case 2:  Printf("%d     | %08x | %02d Format  | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;
            case 3:  Printf("%d     | %08x | %02d Process | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;
            case 4:  Printf("%d     | %08x | %02d GetPics | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;
            case 5:  Printf("%d     | %08x | %02d Fetch   | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;

            case 6:  Printf("%d     | %08x | %02d LinkTo  | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;
            case 7:  Printf("%d     | %08x | %02d Help    | %d\n",i, contents[i].b, contents[i].type, contents[i].end - contents[i].start); break;
          }
        }

        Printf("\n");
      }
    #endif

    /* Loop round all the status entries, looking for */
    /* one which matches the given browser_data.      */
    /* If found, set 'found' to the array index of    */
    /* that entry.                                    */

    found = -1;

    for (i = 0; i < ancestor->nstatus; i++)
    {
      if (contents[i].b == b)
      {
        found = i;
        break;
      }
    }
  }
  else
  {
    found = -1;

    #ifdef TRACE
      if (tl & (1u<<1))
      {
        Printf("\ntoolbars_update_status:");
        Printf("\nUpdating for browser %p; this has no contents array.\n\n",b);
      }
    #endif
  }

  /* If not found, add an entry for this browser */

  if (found < 0)
  {
    #ifdef TRACE
      if (tl & (1u<<1)) Printf("toolbars_update_status: Adding item\n");
    #endif

    e = toolbars_add_status_item(ancestor);
    if (e) return e;

    found    = ancestor->nstatus - 1;
    contents = ancestor->status_contents;

    if (contents && found >= 0)
    {
      contents[found].b     = b;
      contents[found].start = 0;
      contents[found].end   = 0;
      contents[found].type  = Toolbars_Status_NoType;
    }
  }

  /* Proceed if there's definitely an entry to proceed with... */

  if (contents && found >= 0)
  {
    #ifdef TRACE
      if (tl & (1u<<1)) Printf("toolbars_update_status: Exitting through toolbars_update_specific_status\n");
    #endif

    return toolbars_update_specific_status(b, ancestor, found, type);
  }
  else
  {
    #ifdef TRACE
      if (tl & (1u<<1)) Printf("toolbars_update_status: Failed, exitting quietly\n");
    #endif

    return NULL;
  }
}

/*************************************************/
/* toolbars_update_specific_status()             */
/*                                               */
/* Updates the given browser's given entry in    */
/* the given ancestor's status_content array the */
/* given message type... Messages will only be   */
/* allowed to rise in priority, with the         */
/* timeouts on all messages dealing with letting */
/* things fall back again.                       */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which owns the entry to be        */
/*             updated;                          */
/*                                               */
/*             Pointer to the ancestor           */
/*             browser_data struct holding the   */
/*             status_content array;             */
/*                                               */
/*             Index of the entry to update;     */
/*                                               */
/*             Message type to update it with.   */
/*************************************************/

static _kernel_oserror * toolbars_update_specific_status(browser_data * b, browser_data * ancestor, int entry, status_type type)
{
  _kernel_oserror * e;
  status_content  * contents = ancestor->status_contents;
  int               timeout  = 0;
  int               highest;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_update_specific_status: Called for %p (ancestor %p)\n", b, ancestor);
  #endif

  /* This should never happen, but be defensive anyway... Fail */
  /* if the ancestor seems to have no status_content array.    */

  if (!contents || !ancestor->nstatus)
  {
    #ifdef TRACE
      erb.errnum = Utils_Error_Custom_Normal;

      StrNCpy0(erb.errmess,
               "No status_content array in toolbars_update_specific_status")

      show_error_ret(&erb);
    #endif

    return NULL;
  }

  /* If the message type requested is lower priority */
  /* than that already in use by this browser, don't */
  /* do anything - let the timeouts handle it.       */

  if (type < contents[entry].type) return NULL;

  /* Otherwise, update the message type */

  contents[entry].type = type;

  /* Reset the timeout counter */

  e = _swix(OS_ReadMonotonicTime,
            _OUT(0),

            &contents[entry].start);

  switch (contents[entry].type)
  {
    case Toolbars_Status_NoType:
    case Toolbars_Status_Ready:
    case Toolbars_Status_Viewing:
    {
      /* For the idle cases, set all timers to zero */

      contents[entry].start = timeout = 0;
    }
    break;

    default:
    case Toolbars_Status_Formatting:
    case Toolbars_Status_Processing:
    case Toolbars_Status_GetPics:
    case Toolbars_Status_Fetching:
    case Toolbars_Status_Connected:
    case Toolbars_Status_SentReq:
    case Toolbars_Status_Responded:
    case Toolbars_Status_Redirected:
    case Toolbars_Status_Connecting:
    {
      /* For some messages, a general timeout */

      timeout = atoi(lookup_control("ShowMiscFor:50",0,0));
    }
    break;

    case Toolbars_Status_PlugIn:
    {
      /* For Plug-In messages, use the Plug-in status timeout */

      timeout = atoi(lookup_control("ShowPlugInFor:150",0,0));
    }
    break;

    case Toolbars_Status_LinkTo:
    {
      /* Specific timeout for LinkTo messages */

      timeout = atoi(lookup_control("ShowLinksFor:200",0,0));
    }
    break;

    case Toolbars_Status_Help:
    {
      /* Specific timeout for Help messages */

      timeout = atoi(lookup_control("ShowHelpFor:600",0,0));
    }
    break;
  }

  contents[entry].end = contents[entry].start + timeout;

  /* Now reflect the highest priority message of the array */

  highest = toolbars_write_status(ancestor);

  /* Work out if the timeout handler needs to be registered */
  /* or deregistered.                                       */

  switch (highest)
  {
    case Toolbars_Status_NoType:
    case Toolbars_Status_Ready:
    case Toolbars_Status_Viewing:
    {
      /* If the highest priority is an idle case and the handler is */
      /* registered, deregister it.                                 */

      if (ancestor->status_handler)
      {
        ancestor->status_handler = 0;

        deregister_null_claimant(Wimp_ENull,
                                 (WimpEventHandler *) toolbars_timeout_status,
                                 ancestor);
      }
    }
    break;

    default:
    {
      /* Otherwise, for non-idle cases, register the handler if it */
      /* isn't already present.                                    */

      if (!ancestor->status_handler)
      {
        ancestor->status_handler = 1;

        register_null_claimant(Wimp_ENull,
                               (WimpEventHandler *) toolbars_timeout_status,
                               ancestor);
      }

    }
    break;
  }

  /* Finished */

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_update_specific_status: Successful\n");
  #endif

  return NULL;
}

/*************************************************/
/* toolbars_write_status()                       */
/*                                               */
/* Reflects the highest priority message in a    */
/* status_content array in the status bar of     */
/* the array's owner.                            */
/*                                               */
/* Called by toolbars_update_status as part of   */
/* its normal operation.                         */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which is an ancestor holding a    */
/*             status_content array.             */
/*                                               */
/* Returns:    The message type that was chosen  */
/*             as the highest priority.          */
/*                                               */
/* Assumes:    That the ancestor browser_data    */
/*             pointer is not NULL.              */
/*************************************************/

static int toolbars_write_status(browser_data * ancestor)
{
  char             new_status [Limits_StatusBarStatus];
  char             url        [Limits_StatusBarStatus];
  char           * use_status = new_status;
  int              dontappend = 0;
  int              found      = -1;
  int              i, count;
  status_type      highest;
  ObjectId         t;
  browser_data   * priority;
  status_content * contents = ancestor->status_contents;

  /* Fail if there's no status_content array */

  if (!contents || !ancestor->nstatus)
  {
    #ifdef TRACE
      erb.errnum = Utils_Error_Custom_Normal;

      StrNCpy0(erb.errmess,
               "No status_content array in toolbars_write_status")

      show_error_ret(&erb);
    #endif

    return 0;
  }

  /* Get the ID of the toolbar in which the status bar resides */

  t = toolbars_get_lower(ancestor);
  if (!t) return 0;

  /* Examine all entries for the highest priority message */

  highest = Toolbars_Status_NoType;
  count   = 0;

  for (i = 0; i < ancestor->nstatus; i++)
  {
    /* If the message for this entry is higher than the highest recorded */
    /* so far, then record this message as the highest. Reset the count  */
    /* of the number of times this message has been encountered to zero  */
    /* and remember the index into the array in 'found'.                 */

    if (contents[i].type > highest) highest = contents[i].type, count = 1, found = i;

    /* If the message for this entry is the same as the highest recorded */
    /* so far, then increment the count of the number of times the       */
    /* message has been encountered.                                     */

    else if (contents[i].type == highest) count++;
  }

  /* Now have the highest priority message in 'highest', the number of  */
  /* times it has been requested in 'count', and the index of the first */
  /* occurrence of this message in 'found'.                             */

  priority = contents[found].b;

  /* According to the highest priority message, write the new status into 'new_status' */

  switch (highest)
  {
    default:                     /* (Drop through */
    case Toolbars_Status_Ready:  /* to Viewing)   */
    case Toolbars_Status_Viewing:
    {
      char title[Limits_Title];

      *title = 0;

      /* Try to get the window's title. If this generates an error or   */
      /* is equal to the 'blank page' case, use 'Ready' for the status. */

      if (
           window_get_title(0, ancestor->self_id, title, sizeof(title), NULL) ||
           !strcmp(title, lookup_token("BlankPage:Blank page",0,0))
         )
         StrNCpy0(new_status, lookup_token("Ready:Ready",0,0))

      else
      {
        char format[Limits_StatusFormat];

        title[sizeof(title) - 1] = 0;

        StrNCpy0(format, lookup_token("Page:Viewing '%s'",0,0))
        StrNCpy0(url, title)

        url[sizeof(new_status) - strlen(format) - 1] = 0;
        sprintf(new_status, format, url);
      }

      /* Append an 'active' suffix if needed */

      if (priority->anim_handler || priority->plugin_active)
      {
        char * active = lookup_token("Actv: (active)",0,0);

        if (strlen(active) + strlen(new_status) + 1 < sizeof(new_status)) strcat(new_status, active);
      }

      /* If preceeded by a '-' don't ever append a progress counter */

      if (new_status[0] == '-') use_status++, dontappend = 1;
    }
    break;

    case Toolbars_Status_GetPics:
    {
      int images = image_count_pending(ancestor);

      if (images == 1) StrNCpy0(new_status, lookup_token("GetPic:Fetching 1 image...", 0, 0))
      else if (images)  sprintf(new_status, lookup_token("GetPics:Fetching %d images...", 0, 0), images);
      else             StrNCpy0(new_status, lookup_token("GetPic0:All current images fetched...", 0, 0));

      if (new_status[0] == '-') use_status++, dontappend = 1;
    }
    break;

    case Toolbars_Status_Fetching:   /* (Drop through  */
    case Toolbars_Status_Processing: /* to Formatting) */
    case Toolbars_Status_Connected:
    case Toolbars_Status_SentReq:
    case Toolbars_Status_Responded:
    case Toolbars_Status_Redirected:
    case Toolbars_Status_Connecting:
    case Toolbars_Status_Formatting:
    {
      char format[Limits_StatusFormat];

      /* For many occurrences, report an appropriate 'cumulative' */
      /* message; otherwise, report the one specific case.        */
      /*                                                          */
      /* If the browser has a parent - i.e. this is a frames      */
      /* document - then the 'many' equivalents are always used;  */
      /* this is to stop flickering between the 'single' and      */
      /* 'many' states during a fetch/reformat/etc.               */

      if (count > 1 || priority->real_parent)
      {
        if (highest == Toolbars_Status_Fetching)
        {
          /* This one is a little special, as we could be saving an object to disc */
          /* and the user may not have dealt with the save dialogue yet.           */

          if (priority->fetch_status == BS_DATAFETCH && !priority->save_file)
          {
            StrNCpy0(new_status, lookup_token("FetchWait:Waiting for a Save dialogue to be dealt with...", 0, 0))
          }
          else
          {
            StrNCpy0(new_status, lookup_token("FetchMany:Fetching frame contents...", 0, 0))
          }
        }

        /* Simpler cases */

        else if (highest == Toolbars_Status_Processing) StrNCpy0(new_status, lookup_token("ProcessMany:Processing frames contents...",                      0, 0))
        else if (highest == Toolbars_Status_Connected)  StrNCpy0(new_status, lookup_token("ConnectedMany:Connected to servers to fetch frames contents...", 0, 0))
        else if (highest == Toolbars_Status_SentReq)    StrNCpy0(new_status, lookup_token("SentReqMany:Sent requests to fetch frames contents...",          0, 0))
        else if (highest == Toolbars_Status_Responded)  StrNCpy0(new_status, lookup_token("RespondedMany:Responses received for frames contents...",        0, 0))
        else if (highest == Toolbars_Status_Connecting) StrNCpy0(new_status, lookup_token("ConnectingMany:Trying to connect to fetch frames contents...",   0, 0))
        else if (highest == Toolbars_Status_Redirected) StrNCpy0(new_status, lookup_token("RedirectedMany:Frame fetches are being redirected...",           0, 0))
        else                                            StrNCpy0(new_status, lookup_token("FormatMany:Formatting frames contents...",                       0, 0))
      }
      else
      {
        /* Find the URL to display, if any */

        if      (browser_fetch_url  (priority)) StrNCpy0(url, browser_fetch_url  (priority))
        else if (browser_current_url(priority)) StrNCpy0(url, browser_current_url(priority))
        else *url = 0;

        if (*url)
        {
          /* Get the Messages file token as a format string for sprintf, into */
          /* which the URL can be substituted.                                */

          if (highest == Toolbars_Status_Fetching)
          {
            if (priority->fetch_status == BS_DATAFETCH && !priority->save_file)
            {
              StrNCpy0(format, lookup_token("FetchWait:Waiting for a Save dialogue to be dealt with...", 0, 0))
            }
            else
            {
              StrNCpy0(format, lookup_token("Fetch:Fetching '%s'...", 0, 0))
            }
          }
          else if (highest == Toolbars_Status_Processing) StrNCpy0(format, lookup_token("Process:Processing '%s'...",                        0, 0))
          else if (highest == Toolbars_Status_Connected)  StrNCpy0(format, lookup_token("Connected:Connected to server to fetch '%s'...",    0, 0))
          else if (highest == Toolbars_Status_SentReq)    StrNCpy0(format, lookup_token("SentReq:Sent request to fetch '%s'...",             0, 0))
          else if (highest == Toolbars_Status_Responded)  StrNCpy0(format, lookup_token("RespondedMany:Response received for '%s'...",       0, 0))
          else if (highest == Toolbars_Status_Connecting) StrNCpy0(format, lookup_token("ConnectingMany:Trying to connect to fetch '%s'...", 0, 0))
          else if (highest == Toolbars_Status_Redirected) StrNCpy0(format, lookup_token("RedirectedMany:Redirecting to '%s'...",             0, 0))
          else                                            StrNCpy0(format, lookup_token("Format:Formatting '%s'...",                         0, 0))

          /* Possibly hide CGI information in the URL */

          #ifdef HIDE_CGI
            toolbars_hide_cgi(url);
          #endif

          /* Ensure the URL isn't too long to fit int he new_status */
          /* buffer along with the format string defined above. If  */
          /* the format string comes from a messages file we can't  */
          /* make assumptions about how many of its characters will */
          /* actually appear in the final output string after the   */
          /* sprintf call, so we must treat it as if they all will  */
          /* appear - hence the ' - 1'.                             */

          url[sizeof(new_status) - strlen(format) - 1] = 0;

          toolbars_hide_internal(url);

          /* Write the combined message into new_status */

          sprintf(new_status, format, url);
        }
        else
        {
          /* The URL is not known, so can do a direct lookup into new_status */

          if (highest == Toolbars_Status_Fetching)
          {
            if (priority->fetch_status == BS_DATAFETCH && !priority->save_file)
            {
              StrNCpy0(new_status, lookup_token("FetchWait:Waiting for a Save dialogue to be dealt with...", 0, 0))
            }
            else
            {
              StrNCpy0(new_status, lookup_token("FetchUK:Fetching web page...", 0, 0))
            }
          }
          else if (highest == Toolbars_Status_Processing) StrNCpy0(new_status, lookup_token("ProcessUK:Processing web page...",            0, 0))
          else if (highest == Toolbars_Status_Connected)  StrNCpy0(new_status, lookup_token("ConnectedUK:Connected to server...",          0, 0))
          else if (highest == Toolbars_Status_SentReq)    StrNCpy0(new_status, lookup_token("SentReqUK:Sent request for web page...",      0, 0))
          else if (highest == Toolbars_Status_Responded)  StrNCpy0(new_status, lookup_token("RespondedUK:Server response received...",     0, 0))
          else if (highest == Toolbars_Status_Connecting) StrNCpy0(new_status, lookup_token("ConnectingUK:Trying to connect to server...", 0, 0))
          else                                            StrNCpy0(new_status, lookup_token("FormatUK:Formatting web page...",             0, 0))
        }
      }

      if (new_status[0] == '-') use_status++, dontappend = 1;
    }
    break;

    case Toolbars_Status_Help:
    {
      StrNCpy0(new_status, priority->status_help);

      dontappend = 1;
    }
    break;

    case Toolbars_Status_LinkTo:
    {
      HStream * over;
      char      format[Limits_StatusFormat];
      int       allowed;
      int       dealt_with = 0;

      /* For comments on the use of the 'format' buffer, see the */
      /* code above.                                             */

      over = priority->pointer_over;

      /* If the token that the pointer is over isn't suitable for a LinkTo */
      /* message, use the keyboard selected item instead; so the pointer   */
      /* always takes priority over the keyboard.                          */

      if (
           !over ||
           (
             (
               !over->anchor  ||
               !*over->anchor
             )
             && !(over->type & (TYPE_ISMAP | TYPE_ISCLIENTMAP))
           )
         )
         over = ancestor->selected;

      /* So, do we now have a suitable token, be it from the token the */
      /* pointer was over or whatever is keyboard selected?            */

      if (
           over &&
           (
             (
               over->anchor &&
               *over->anchor
             )
             || (over->type & (TYPE_ISMAP | TYPE_ISCLIENTMAP))
           )
         )
      {
        /* Yes, so create an appropriate status message. */

        StrNCpy0(format, lookup_token("LinkTo:Link to '%s'...",0,0));

        /* If a client-side image map, must work out the URL */

        if (over->type & TYPE_ISCLIENTMAP)
        {
          char * csim_url;

          csim_return_info(priority,
                           over,
                           priority->map_x,
                           priority->map_y,
                           &csim_url,
                           NULL,
                           NULL);

          if (csim_url && *csim_url)
          {
            dealt_with = 1;

            StrNCpy0(url, csim_url)
          }
        }

        /* If a server side map and either not client side as well, */
        /* or the client side map gave us no URL, use the anchor    */
        /* instead, and append coordinate information.              */
        /*                                                          */
        /* If not server side, just use the anchor information in   */
        /* the token on its own.                                    */

        if (!dealt_with && over->anchor && *over->anchor)
        {
          StrNCpy0(url, over->anchor);

          #ifdef HIDE_CGI
            toolbars_hide_cgi(url);
          #endif

          allowed          = sizeof(new_status) - strlen(format);
          url[allowed - 1] = 0;

          toolbars_hide_internal(url);

          /* If a server-side map, want to append coordinate info. */

          if (over->type & TYPE_ISMAP)
          {
            int required = utils_number_length(priority->map_x) +
                           utils_number_length(priority->map_y) +
                           5; /* 5 = length of " (, )" */

            if (strlen(url) + required + 1 <= allowed)
            {
              char append[128];

              sprintf(append, " (%d, %d)", priority->map_x, priority->map_y);

              strcat(url, append);
            }
          }

          dealt_with = 1;
        }
      }

      /* Did we end up with something we can use in a LinkTo message? */

      if (dealt_with)
      {
        /* Yes, so compile the final message together now */

        sprintf(new_status, format, url);
        if (new_status[0] == '-') use_status++, dontappend = 1;
      }
      else
      {
        /* No suitable token, so the message is out of date; that */
        /* is, no object is selected (say) but the message is     */
        /* still on a timer. In that case, cancel it.             */

        toolbars_cancel_status(priority, highest);

        return Toolbars_Status_Ready;
      }
    }
    break;

    case Toolbars_Status_PlugIn:
    {
      StrNCpy0(new_status, priority->plugin_status ? priority->plugin_status : "");

      dontappend = 1;
    }
    break;
  }

  /* Right, finally have a message in new_status. Now */
  /* append the fetch progress, if required.          */
  /*                                                  */
  /* Any messages starting with '-' will never have a */
  /* counter appended, as dontappend will have been   */
  /* set to 1 by things checking this above.          */

  if (controls.append_status && !dontappend)
  {
    char progress[Limits_FetchProgress];
    int  add;

    toolbars_create_progress(contents[found].b, progress, sizeof(progress));

    add = 1 + 1 + (controls.use_brackets ? 2 : 0); /* (Terminating byte, plus separating space, possibly plus 2 brackets) */

    /* Only proceed if there's room for the extra text */

    if (strlen(new_status) + strlen(progress) + add <= sizeof(new_status))
    {
      /* Concatenate the extra text */

      strcat(new_status, " ");
      if (controls.use_brackets) strcat(new_status, "(");
      strcat(new_status, progress);
      if (controls.use_brackets) strcat(new_status, ")");
    }
  }

  /* Check that the string isn't the same as already */
  /* present, and if not, update the status bar. The */
  /* 'url' char array used temporarily is now free,  */
  /* with the new status line in new_status, so we   */
  /* can reuse that here.                            */

  ChkError(displayfield_get_value(0, t, StatusBarStatus, url, sizeof(url),NULL));

  if (
       strcmp(use_status, url)
     )
  {
    /* If the string has changed, display it */

    ChkError(displayfield_set_value(0,
                                    t,
                                    StatusBarStatus,
                                    use_status));

    /* Ensure the toolbar buttons are up to date in light of the new status */

    ChkError(toolbars_set_button_states(priority));
  }

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_write_status: Successful, returning with message type %d\n",priority);
  #endif

  return highest;
}

/*************************************************/
/* toolbars_cancel_status()                      */
/*                                               */
/* toolbars_remove_status_item is used to        */
/* remove a browser from its ancestor's array of */
/* status_content structures because the browser */
/* is about to become invalid (e.g. be deleted   */
/* because its associated window was closed).    */
/*                                               */
/* This function is used if an existing browser  */
/* wants to cancel a message it registered       */
/* earlier, before it times out. The message     */
/* type that is being cancelled must be stated;  */
/* if the browser's entry in the status_content  */
/* array does not record this type, no action    */
/* will be taken. Otherwise the message will be  */
/* cancelled as asked.                           */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which wants the message           */
/*             cancelling;                       */
/*                                               */
/*             Message type that it wants to     */
/*             remove.                           */
/*************************************************/

_kernel_oserror * toolbars_cancel_status(browser_data * b, status_type type)
{
  browser_data    * ancestor = utils_ancestor(b);
  status_content  * contents;
  int               i, found;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_cancel_status: Called for %p, type %d\n",b,type);
  #endif

  contents = ancestor->status_contents;
  if (!contents || !ancestor->nstatus)
  {
    #ifdef TRACE
      if (tl & (1u<<1)) Printf("toolbars_cancel_status: Exitting - ancestor has no array\n");
    #endif

    return NULL;
  }

  /* Find the entry */

  found = -1;

  for (i = 0; i < ancestor->nstatus; i++)
  {
    if (contents[i].b == b)
    {
      found = i;
      break;
    }
  }

  /* If not found, exit */

  if (found < 0)
  {
    #ifdef TRACE
      if (tl & (1u<<1)) Printf("toolbars_cancel_status: Exitting - can't find entry\n");
    #endif

    return NULL;
  }

  /* If not the given message type, exit */

  if (contents[found].type != type)
  {
    #ifdef TRACE
      if (tl & (1u<<1)) Printf("toolbars_cancel_status: Exitting - entry message type %d doesn't match given type %d\n", contents[found].type, type);
    #endif

    return NULL;
  }

  /* Otherwise, clear the message and restore something */
  /* more meaningful with the inference routine. To do  */
  /* this, we'll need to free any Plug-In message, if   */
  /* there was one.                                     */

  if (type == Toolbars_Status_PlugIn)
  {
    free(b->plugin_status);
    b->plugin_status = 0;
  }

  contents[found].start = 0;
  contents[found].end   = 0;
  contents[found].type  = Toolbars_Status_NoType;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_cancel_status: Exitting through toolbars_infer_status\n");
  #endif

  return toolbars_infer_status(b, ancestor, found);
}

/*************************************************/
/* toolbars_cancel_all()                         */
/*                                               */
/* If a browser wants to cancel all messages it  */
/* registered earlier, except for LinkTo or Help */
/* messages, perhaps to ensure that some message */
/* is displayed now rather than after another    */
/* times out, it should call this function. The  */
/* original idea was for browsers that have just */
/* completed a full fetch, which want to get rid */
/* of any timing out formatting or fetching      */
/* messages.                                     */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which wants the message           */
/*             cancelling.                       */
/*************************************************/

_kernel_oserror * toolbars_cancel_all(browser_data * b)
{
  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_cancel_all: Called\n");
  #endif

  RetError(toolbars_cancel_status(b, Toolbars_Status_PlugIn));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Connecting));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Redirected));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Responded));
  RetError(toolbars_cancel_status(b, Toolbars_Status_SentReq));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Connected));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Fetching));
  RetError(toolbars_cancel_status(b, Toolbars_Status_GetPics));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Processing));
  RetError(toolbars_cancel_status(b, Toolbars_Status_Formatting));

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_cancel_all: Successful\n");
  #endif

  return NULL;
}

/*************************************************/
/* toolbars_timeout_status()                     */
/*                                               */
/* A null event handler registered and deregis-  */
/* tered by toolbars_update_specific_status,     */
/* which handles checking the 'start' and 'end'  */
/* fields of the given ancestor browser_data     */
/* struct to see if any messages have expired.   */
/*                                               */
/* toolbars_update_specific_status will only     */
/* allow browsers to register progressively      */
/* higher priority messages than previously      */
/* registered - this routine allows those        */
/* previous priorities to drop down.             */
/*                                               */
/* Parameters are as standard for a Wimp null    */
/* event handler (handle = pointer to the        */
/* ancestor browser_data structure).             */
/*************************************************/

int toolbars_timeout_status(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
  browser_data   * ancestor = handle; /* Just to make things clearer */
  status_content * contents = ancestor->status_contents;
  int              i, timenow;

  /* Fail if there's no status_content array */

  if (!contents || !ancestor->nstatus)
  {
    #ifdef TRACE
      erb.errnum = Utils_Error_Custom_Normal;

      StrNCpy0(erb.errmess,
               "No status_content array in toolbars_timeout_status")

      show_error_ret(&erb);
    #endif

    return 0;
  }

  /* Go through all entries in the array */

  for (i = 0; i < ancestor->nstatus; i++)
  {
    if (contents[i].start > 0)
    {
      /* An active message that is timing out */

      _swix(OS_ReadMonotonicTime,
            _OUT(0),

            &timenow);

      if (contents[i].start != contents[i].end && timenow > contents[i].end)
      {
        /* Message has expired. Was it a Plug-In status message? */

        if (contents[i].type == Toolbars_Status_PlugIn)
        {
          free(ancestor->plugin_status);
          ancestor->plugin_status = NULL;
        }

        /* OK, set the status to 'nothing', then infer the current state */

        contents[i].start = 0;
        contents[i].end   = 0;
        contents[i].type  = Toolbars_Status_NoType;

        ChkError(toolbars_infer_status(contents[i].b, ancestor, i));
      }
    }
    else
    {
      /* Message has <= 0 in 'start' field; if non-idle, this is an expiry indicator */

      switch (contents[i].type)
      {
        case Toolbars_Status_NoType:
        case Toolbars_Status_Ready:
        case Toolbars_Status_Viewing:
        {
          /* Idle, so do nothing */

          i = i; /* Ensure compiler handles this OK... */
        }

        default:
        {
          /* Non-idle message; it has expired. Was it a Plug-In status message? */

          if (contents[i].type == Toolbars_Status_PlugIn)
          {
            free(ancestor->plugin_status);
            ancestor->plugin_status = NULL;
          }

          /* OK, set the status to 'nothing' */

          contents[i].start = 0;
          contents[i].end   = 0;
          contents[i].type  = Toolbars_Status_NoType;
        }
        break;
      }
    }
  }

  return 0;
}

/*************************************************/
/* toolbars_return_inferred()                    */
/*                                               */
/* Looks at a given browser_data struct to work  */
/* out what state it is in, returning this       */
/* information as a status_type value (see       */
/* Toolbars.h).                                  */
/*                                               */
/* Parameters: Pointer to the browser_data       */
/*             struct in question.               */
/*                                               */
/* Returns:    Its status, as a status_type      */
/*             value.                            */
/*************************************************/

static status_type toolbars_return_inferred(browser_data * b)
{
  status_type type = Toolbars_Status_Ready;

  /* Work out what message should be displayed. */
  /* Since this is most often called when a     */
  /* status message expires, any messages which */
  /* should appear persistently in the status   */
  /* bar - such as Fetching or Viewing - should */
  /* be returned by this function. Otherwise,   */
  /* the message will be replaced by another    */
  /* that this function chooses.                */

  /* Is there a Plug-In status message? */

  if (b->plugin_status && *b->plugin_status)
  {
    type = Toolbars_Status_PlugIn;
  }

  /* Otherwise, is a page fetch in progress? */

  else
  {
    if (fetch_fetching(b))
    {
      /* If fetching, may in fact just be passing tokens through the fetcher */
      /* with no new actual data to get from the server. In that case want   */
      /* to give a 'processing' message; otherwise, definitely 'fetching'.   */

      if (b->fetch_status == BS_PROCESS) type = Toolbars_Status_Processing;
      else
      {
        /* Need to find out the genuine fetch status, or all of the */
        /* varied fetch information that we can get out of the      */
        /* fetchers gets collapsed to some less meaningful generic  */
        /* message by this routine.                                 */

        int s;

        if (!url_status(0, b->fetch_handle, &s, NULL, NULL))
        {
          if      (s & URL_Status_Transfer)  type = Toolbars_Status_Fetching;
          else if (s & URL_Status_Responded) type = Toolbars_Status_Responded;
          else if (s & URL_Status_SentReq)   type = Toolbars_Status_SentReq;
          else if (s & URL_Status_SentData)  type = Toolbars_Status_SentReq;
          else if (s & URL_Status_Connected) type = Toolbars_Status_Connected;
          else if (!s)                       type = Toolbars_Status_Connecting;
        }
        else type = Toolbars_Status_Fetching;
      }
    }
    else
    {
      int specimg;

      /* If not fetching pages, are we fetching images? If so, display an */
      /* appropriate message.                                             */

      specimg = image_count_specific_pending(b);

      if (specimg && image_fetching(b)) type = Toolbars_Status_GetPics;
      else
      {
        /* If not fetching images either, then may be formatting or idle. */

        if (reformat_formatting(b)) type = Toolbars_Status_Formatting;
        else                        type = Toolbars_Status_Viewing;
      }
    }
  }

  return type;
}

/*************************************************/
/* toolbars_infer_status()                       */
/*                                               */
/* When a toolbar message in the status_content  */
/* array of an ancestor browser has expired,     */
/* this routine is called to work out what the   */
/* current status for the owner browser should   */
/* be. The toolbar is appropriately updated.     */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which owns the message;           */
/*                                               */
/*             Pointer to a browser_data struct  */
/*             which is the above's ancestor;    */
/*                                               */
/*             Index into the ancestor's         */
/*             status_content array for the      */
/*             message owner.                    */
/*                                               */
/* Assumes:    That the ancestor pointer is not  */
/*             NULL.                             */
/*************************************************/

static _kernel_oserror * toolbars_infer_status(browser_data * b, browser_data * ancestor, int entry)
{
  status_content * contents = ancestor->status_contents;
  status_type      type;

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_infer_status: Called for %p (ancestor %p)\n",b,ancestor);
  #endif

  /* Fail if there's no status_content array */

  if (!contents || !ancestor->nstatus)
  {
    #ifdef TRACE
      erb.errnum = Utils_Error_Custom_Normal;

      StrNCpy0(erb.errmess,
               "No status_content array in toolbars_infer_status")

      show_error_ret(&erb);
    #endif

    return NULL;
  }

  /* Find the message type */

  type = toolbars_return_inferred(b);

  /* Exit through the toolbar update routine */

  #ifdef TRACE
    if (tl & (1u<<1)) Printf("toolbars_infer_status: Exitting through toolbars_update_specific_status with type %d\n",type);
  #endif

  return toolbars_update_specific_status(b, ancestor, entry, type);
}

/*************************************************/
/* toolbars_add_status_item()                    */
/*                                               */
/* Adds an item to a given ancestor's array of   */
/* status_content structures. The contents are   */
/* not initialised - this is left to the caller. */
/*                                               */
/* Parameters: Pointer to browser_data struct in */
/*             which the addition should be made */
/*             (i.e. the ancestor).              */
/*                                               */
/* Assumes:    That the ancestor browser_data    */
/*             pointer is not NULL.              */
/*************************************************/

static _kernel_oserror * toolbars_add_status_item(browser_data * ancestor)
{
  /* Increment the status counter */

  ancestor->nstatus ++;

  /* Allocate the required memory */

  return memory_set_chunk_size(ancestor, NULL, CK_STAT, ancestor->nstatus * sizeof(status_content));
}

/*************************************************/
/* toolbars_remove_status_item()                 */
/*                                               */
/* Removes a browser_data structure from its     */
/* ancestor's array of status_content structs.   */
/*                                               */
/* Typically called by windows_close_browser, so */
/* issues of having children within the window   */
/* relating to the given browser are dealt with  */
/* automatically (children would be being closed */
/* through a function in Frames.c, with the      */
/* Windows.c function called as part of this).   */
/*                                               */
/* Parameters: Pointer to the browser_data       */
/*             struct to remove from the array;  */
/*                                               */
/*             Pointer to the ancestor           */
/*             browser_data structure.           */
/*                                               */
/* Assumes:    That the ancestor pointer is not  */
/*             NULL.                             */
/*************************************************/

_kernel_oserror * toolbars_remove_status_item(browser_data * b, browser_data * ancestor)
{
  status_content * contents = ancestor->status_contents;
  int              i, found;

  /* Can't proceed if the ancestor has no contents array */
  /* (this is fine, so TRACE builds don't give an error  */
  /* either).                                            */

  if (!contents || !ancestor->nstatus) return NULL;

  /* Find the browser's entry in the status contents array */

  found = -1;

  for (i = 0; i < ancestor->nstatus; i++)
  {
    if (contents[i].b == b)
    {
      found = i;
      break;
    }
  }

  /* If not found, exit */

  if (found < 0) return NULL;

  /* Otherwise, remove the entry */

  if (found < ancestor->nstatus - 1)
  {
    memmove(&contents[found],
            &contents[found + 1],
            (ancestor->nstatus - found - 1) * sizeof(status_content));
  }

  ancestor->nstatus--;

  return memory_set_chunk_size(ancestor, NULL, CK_STAT, ancestor->nstatus * sizeof(status_content));
}

/*************************************************/
/* toolbars_return_act_status()                  */
/*                                               */
/* Returns the highest status for the ancestor   */
/* of a given browser window that does not       */
/* include non-active transient items            */
/* (specifically, LinkTo and Help messages).     */
/*                                               */
/* This allows the caller to determine whether a */
/* browser and any of its frames are fetching,   */
/* for example.                                  */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the ancestor in       */
/*             question.                         */
/*                                               */
/* Returns:    A status_type (see Toolbars.h)    */
/*             describing the ancestor's current */
/*             status.                           */
/*************************************************/

static status_type toolbars_return_act_status(browser_data * b)
{
  browser_data   * ancestor = utils_ancestor(b);
  status_type      highest  = Toolbars_Status_NoType;
  status_content * contents;
  int              i;

  if (!b) return Toolbars_Status_NoType;

  /* Find the highest item that isn't a LinkTo or Help message */

  contents = ancestor->status_contents;

  for (i = 0; i < ancestor->nstatus; i++)
  {
    if (
         contents[i].type == Toolbars_Status_LinkTo ||
         contents[i].type == Toolbars_Status_Help
       )
    {
      status_type type;

      /* Non-active status entry, so need to work out what */
      /* it would say if this message had timed out        */

      type = toolbars_return_inferred(b);

      if (type > highest) highest = type;
    }
    else
    {
      /* Otherwise, remember this status if its the highest */

      if (contents[i].type > highest) highest = contents[i].type;
    }
  }

  return highest;
}

/*************************************************/
/* toolbars_update_progress()                    */
/*                                               */
/* Reflects a fetch's progress in the browser    */
/* window's status bar.                          */
/*                                               */
/* Parameters: A pointer to the browser_data     */
/*             structure associated with the     */
/*             fetch.                            */
/*************************************************/

void toolbars_update_progress(browser_data * b)
{
  char              progress [Limits_StatusBarProgress];
  char              old      [Limits_StatusBarProgress];
  ObjectId          t;
  _kernel_oserror * e;
  browser_data    * ancestor = utils_ancestor(b);
  int               saves;

  /* May want to only update at specific intervals of time */

  if (
       controls.progress_update_delay   &&
       !
       (
         b->fetch_status == BS_IDLE    ||
         b->fetch_status == BS_PROCESS
       )
     )
  {
    int time_now;

    if (
         !_swix(OS_ReadMonotonicTime,
                _OUT(0),

                &time_now)
       )
    {
      if (time_now - ancestor->progress_updated < controls.progress_update_delay) return;

      ancestor->progress_updated = time_now;
    }
  }

  /* Find out how many file saves, if any, are in progress */

  saves = toolbars_create_progress(b, progress, sizeof(progress));

  /* Find the toolbar and try to get the old progress string */

  t = toolbars_get_lower(ancestor);
  if (!t) return;

  e = button_get_value(0, t, StatusBarProgress, old, sizeof(old), NULL);

  /* Only update the display field if the contents have */
  /* changed, to avoid flicker.                         */

  if (!e && strcmp(progress, old))
  {
    int flags;
    int colour_old, colour_new;

    /* Set the colour if required */

    if (controls.colour_progress != Controls_ColourProgress_NotAColour)
    {
      if (!button_get_flags(0, t, StatusBarProgress, &flags))
      {
        browser_data * ancestor = b->ancestor;

        if (!ancestor) ancestor = b;

        /* Remember the old colour, and set the new according  */
        /* to whether or not file saves are in progress. If    */
        /* there, use the Messages file defined colour; else   */
        /* use the colour recorded in the browser_data struct. */

        colour_old = (flags & 0x0f000000) >> 24;
        colour_new = saves ? controls.colour_progress : ancestor->progress_colour;

        if (colour_new != colour_old)
        {
          button_set_flags(0,
                           t,
                           StatusBarProgress,
                           0x0f000000,
                           colour_new << 24);
        }
      }
    }

    button_set_value(0, t, StatusBarProgress, progress);
  }
  else if (e && controls.append_status) toolbars_update_status(b, Toolbars_Status_Ready);
}

/*************************************************/
/* toolbars_count_file_saves()                   */
/*                                               */
/* Checks to see if any frames in a given        */
/* frameset are saving out files.                */
/*                                               */
/* Parameters: Pointer to any browser_data       */
/*             structure in the frameset.        */
/*                                               */
/* Returns:    The number of file saves going on */
/*             in the parent and any children it */
/*             might have.                       */
/*************************************************/

static int toolbars_count_file_saves(browser_data * b)
{
  browser_data * ancestor = b->ancestor;

  if (!ancestor) ancestor = b;

  return toolbars_count_file_saves_r(ancestor);
}

/*************************************************/
/* toolbars_count_file_saves_r()                 */
/*                                               */
/* Recursive back-end to                         */
/* toolbars_count_file_saves.                    */
/*                                               */
/* Parameters: Pointer to the ancestor           */
/*             browser_data struct in the        */
/*             frameset.                         */
/*                                               */
/* Returns:    As toolbars_count_file_saves.     */
/*************************************************/

static int toolbars_count_file_saves_r(browser_data * b)
{
  int i, count = 0;

  if (b->nchildren)
  {
    for (i = 0; i < b->nchildren; i++)
    {
      count += toolbars_count_file_saves_r(b->children[i]);
    }
  }

  if (b->save_file) count ++;

  return count;
}

/*************************************************/
/* toolbars_calculate_progress()                 */
/*                                               */
/* Works out how much data has been fetched for  */
/* a frameset.                                   */
/*                                               */
/* If a file save is in progress, the amount of  */
/* data fetched for that file save and nothing   */
/* else is returned as a negative number (to     */
/* flag that this is happening). Callers must    */
/* remember to check for this, even if only to   */
/* reverse the sign on the returned value.       */
/*                                               */
/* Parameters: Pointer to any browser_data       */
/*             struct in the frameset in         */
/*             question.                         */
/*                                               */
/* Returns:    The amount collectively fetched,  */
/*             in bytes, or the amount fetched   */
/*             for a file save with its sign     */
/*             reversed (i.e. a negative number) */
/*             again in bytes.                   */
/*************************************************/

static int toolbars_calculate_progress(browser_data * b)
{
  browser_data * ancestor = b->ancestor;
  int            saves    = toolbars_count_file_saves(b);

  if (!ancestor) ancestor = b;

  return toolbars_calculate_progress_r(ancestor, saves);
}

/*************************************************/
/* toolbars_calculate_progress_r()               */
/*                                               */
/* Recursive back-end to                         */
/* toolbars_calculate_progress.                  */
/*                                               */
/* Parameters: Pointer to the ancestor           */
/*             browser_data struct in the        */
/*             frameset;                         */
/*                                               */
/*             0 if no browser in the frameset   */
/*             is saving data to a file, else    */
/*             non-zero.                         */
/*                                               */
/* Returns:    As toolbars_calculate_progress.   */
/*************************************************/

static int toolbars_calculate_progress_r(browser_data * b, int saves)
{
  int i, fetched = 0;

  if (b->nchildren)
  {
    int localfetched;

    /* For children, if the frameset has some file saving going on */
    /* use only negative numbers returned, i.e. report cumulative  */
    /* file sizes. Otherwise, use only positive numbers, i.e.      */
    /* report image / page source fetched data.                    */

    for (i = 0; i < b->nchildren; i++)
    {
      localfetched = toolbars_calculate_progress_r(b->children[i], saves);

      if (saves)
      {
        if (localfetched < 0) fetched += localfetched;
      }
      else
      {
        if (localfetched > 0) fetched += localfetched;
      }
    }
  }

  if (b->save_file)
  {
    /* If saving, don't want to confuse the issue with any image */
    /* fetch information or whatever. So just use the current    */
    /* output file size.                                         */

    fetched = (int) (-(ftell(b->save_file)));
  }
  else
  {
    /* Count the image data obtained so far */

    fetched += image_total_bytes_fetched(b);

    /* Add the current source store size */

    if (b->save_oldstore) fetched += b->save_oldstore;
    else if (b->source)   fetched += flex_size((flex_ptr) &b->source);
  }

  return fetched;
}

/*************************************************/
/* toolbars_create_progress()                    */
/*                                               */
/* Builds a string indicating fetch progress in  */
/* a given buffer.                               */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the fetch;            */
/*                                               */
/*             Pointer to the buffer;            */
/*                                               */
/*             Size of that buffer.              */
/*                                               */
/* Returns:    The number of file saves going on */
/*             inside the frameset, from         */
/*             toolbars_count_file_saves.        */
/*************************************************/

static int toolbars_create_progress(browser_data * b, char * buffer, int buffer_size)
{
  browser_data * ancestor   = utils_ancestor(b);
  int            saves      = 0;
  int            len        = 1; /* Start with the terminating zero byte accounted for */
  int            percentage = 0;
  int            fetched;

  fetched = toolbars_calculate_progress(ancestor);
  if (fetched < 0) fetched = -fetched, saves = toolbars_count_file_saves(b); /* If a negative number, the absolute value is the amount of data being saved to a file */

  /* Is the buffer big enough? */

  if      (fetched < 10240)    len = utils_number_length(fetched);
  else if (fetched < 10485760) len = utils_number_length((fetched + 512)    / 1024)    + 1; /* For 'K' */
  else                         len = utils_number_length((fetched + 524288) / 1048576) + 1; /* For the 'M' */

  if (saves) len += utils_number_length(saves) + 2;

  if (len > buffer_size)
  {
    #ifdef TRACE

      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Buffer size of %d isn't as large as required (%d) in toolbars_create_progress",
              buffer_size,
              len);

      show_error_ret(&erb);

    #endif

    return saves;
  }

  /* For single file saves, we may be able to use a percentage counter */

  if (saves == 1 && b->data_size > 0 && b->save_link)
  {
    percentage = (fetched * 100) / b->data_size;

    /* If the data size was misjudged, we can exceed 100% fetched. In */
    /* that case, drop back to a byte counter, rather than sticking   */
    /* at 100%.                                                       */

    if (percentage > 100) percentage = 0;
  }

  /* Write the amount into the buffer; '0' for <=0 bytes, a byte  */
  /* amount for less than 10K, a K amount for less than 10M, else */
  /* an amount in megabytes.                                      */

  if (saves < 2)
  {
    if (percentage)
    {
      /* Special case - if we know the data size, and we're saving an object, */
      /* then display a percentage amount fetched instead.                    */

      sprintf(buffer, "%d%%", percentage);
    }
    else
    {
      if      (fetched < 10240)    sprintf(buffer, "%d",  fetched);
      else if (fetched < 10485760) sprintf(buffer, "%dK", (fetched + 512)    / 1024);
      else                         sprintf(buffer, "%dM", (fetched + 524288) / 1048576);
    }
  }
  else
  {
    if      (fetched < 10240)    sprintf(buffer, "%d: %d",  saves, fetched);
    else if (fetched < 10485760) sprintf(buffer, "%d: %dK", saves, (fetched + 512)    / 1024);
    else                         sprintf(buffer, "%d: %dM", saves, (fetched + 524288) / 1048576);
  }

  return saves;
}

/*************************************************/
/* toolbars_update_url()                         */
/*                                               */
/* Reflects the currently fetching URL in the    */
/* URL bar of a browser window.                  */
/*                                               */
/* Parameters: A pointer to the browser_data     */
/*             structure relevant to the window. */
/*************************************************/

void toolbars_update_url(browser_data * b)
{
  char     url[Limits_URLBarWrit];
  char     cmp[sizeof(url)];
  ObjectId t;

  t = toolbars_get_upper(b);
  if (!t) return;

  if (browser_fetch_url(b))
  {
    StrNCpy0(url, browser_fetch_url(b));
  }
  else if (browser_current_url(b))
  {
    StrNCpy0(url, browser_current_url(b));
  }
  else *url = 0;

  /* If we can use URL aliases, then compare the text to put in */
  /* the bar against the Hotlist URL string. If the same, use   */
  /* an alias for the hotlist instead of the given URL.         */

  #ifdef ALIAS_URLS
  {
    char compare[sizeof(url)];

    urlutils_create_hotlist_url(compare, sizeof(compare));

    if (!strcmp(url, compare)) StrNCpy0(url, lookup_token("AtHotlist:Hotlist",0,0));
  }
  #endif

  #ifdef HIDE_CGI
    toolbars_hide_cgi(url);
  #endif

  /* For internal URLs, strip off the internal bit at the start */

  toolbars_hide_internal(url);

  /* Write the URL in only if it's different from the existing contents */

  writablefield_get_value(0, t, URLBarWrit, cmp, sizeof(cmp), NULL);
  if (strcmp(cmp, url)) writablefield_set_value(0, t, URLBarWrit, url);
}

/*************************************************/
/* toolbars_update_dialler_time()                */
/*                                               */
/* Updates the dialler status display in the     */
/* upper toolbar. Should only be called if there */
/* is a Display Field component, ID 0xF, which   */
/* can take the required display values.         */
/*                                               */
/* This shows online time. It is expected that   */
/* the function will only be called from a null  */
/* event handler to update the time regularly.   */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the display.          */
/*************************************************/

_kernel_oserror * toolbars_update_dialler_time(browser_data * b)
{
  _kernel_oserror * e;
  ObjectId          t;
  int               status, start_time, time_now;
  char              display[Limits_URLBarDiallerStatus];
  char              compare[Limits_URLBarDiallerStatus];

  t = toolbars_get_upper(b);
  if (!t) return NULL;

  e = _swix(Dialler_Status,
            _IN(0) | _OUTR(0,1),

            Dialler_Status_ConnectTime,

            &status,
            &start_time);

  /* If the dialler isn't present, don't want to end up */
  /* with a recursive error report, so fail silently.   */

  if (e) return NULL;

  _swix(OS_ReadMonotonicTime,
        _OUT(0),

        &time_now);

  /* Only update as often as specified in the Messages file */

  if (time_now - b->dialler_last > controls.show_dstat_for)
  {
    /* If connected, must display an online time, else show offline. */

    if (status & Dialler_Connected)
    {
      int hours, minutes, seconds;

      /* Remember when this was done */

      b->dialler_last = time_now;

      /* Work out how long we've been online */

      time_now -= start_time;

      if (time_now < 0) time_now = 0;

      hours     = time_now / 360000;
      time_now -= (hours * 360000);
      minutes   = time_now / 6000;
      time_now -= (minutes * 6000);
      seconds   = (time_now / (controls.quantise * 100)) * controls.quantise;

      if (hours > 99) hours = 99;

      if (sizeof(display) >= 9) sprintf(display, "%02u:%02u:%02u\0", hours, minutes, seconds);
      else *display = 0;

      /* Get the current string into 'compare' */

      e = displayfield_get_value(0, t, URLBarDiallerStatus, compare, sizeof(compare), NULL);
      if (e) return e;
      compare[sizeof(compare) - 1] = 0;

      /* Update the display field if necessary, else exit */

      if (strcmp(display, compare))
      {
        e = displayfield_set_value(0, t, URLBarDiallerStatus, display);
        if (e) return e;
      }
    }
  }

  return NULL;
}

/*************************************************/
/* toolbars_update_dialler_status()              */
/*                                               */
/* Updates the dialler status display in the     */
/* upper toolbar. Should only be called if there */
/* is a Display Field component, ID 0xF, which   */
/* can take the required display values.         */
/*                                               */
/* If the status is 'online', a null event       */
/* handler will be installed to call             */
/* toolbars_update_dialler_time to show the      */
/* online time. If the status is not 'online',   */
/* that handler will be deregistered if present. */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the display.          */
/*************************************************/

_kernel_oserror * toolbars_update_dialler_status(browser_data * b)
{
  _kernel_oserror * e;
  ObjectId          t;
  int               status;
  int               showing_time = 0;
  char              display[Limits_URLBarDiallerStatus];
  char              statstr[Limits_URLBarDiallerStatus];
  char              compare[sizeof(display)];

  t = toolbars_get_upper(b);
  if (!t) return NULL;

  memset(statstr, 0, sizeof(statstr));

  e = _swix(Dialler_Status,
            _INR(0,2) | _OUT(0),

            Dialler_Status_StatusString,
            statstr,
            sizeof(statstr),

            &status);

  /* If the dialler isn't present, don't want to end up */
  /* with a recursive error report, so fail silently.   */

  if (e) return NULL;

  statstr[sizeof(statstr) - 1] = 0;

  if (status & Dialler_StatusChanged)
  {
    /* Use the status string. Put the text in the 'tokens' messages buffer */
    /* as this is used lower down for the actual dialler status display    */
    /* string's source. To ensure that any future lookup_token calls don't */
    /* look at the 'lasttokn' buffer and think they don't need to do any   */
    /* work, must mark the contents of 'tokens' as invalid by setting      */
    /* the first char of 'lasttokn' to 0.                                  */

    *lasttokn = 0;
    StrNCpy0(tokens, statstr);
  }
  else
  {
    int info = status & Dialler_GeneralInfoMask;

    /* Get the relevant status text in the 'tokens' messages buffer. */
    /* If an item is missing from the Messages file, the lookup will */
    /* fail silently leaving '!' in the tokens buffer. This is taken */
    /* to mean 'don't show this status', and the routine will exit.  */

    switch (info)
    {
      case Dialler_ExecutingScript_Dial:     lookup_token("Dialling",  0, 0); break; /* Executing dialling script */
      case Dialler_ExecutingScript_Hangup:   lookup_token("Hangup",    0, 0); break; /* Executing hangup script   */
      case Dialler_ExecutingScript_Answer:   lookup_token("Answering", 0, 0); break; /* Answering                 */
      case Dialler_AbortedScript_Syntax:     lookup_token("SError",    0, 0); break; /* Script syntax error       */
      case Dialler_AbortedScript_Timeout:    lookup_token("Timeout",   0, 0); break; /* Timed out                 */
      case Dialler_AbortedScript_NoCarrier:  lookup_token("Carrier",   0, 0); break; /* No carrier                */
      case Dialler_AbortedScript_Error:      lookup_token("MError",    0, 0); break; /* 'ERROR' from modem        */
      case Dialler_AbortedScript_NoDialtone: lookup_token("Dialtone",  0, 0); break; /* No dialtone               */
      case Dialler_AbortedScript_Busy:       lookup_token("MBusy",     0, 0); break; /* 'BUSY' from modem         */
      case Dialler_AbortedScript_NoAnswer:   lookup_token("Answer",    0, 0); break; /* No answer                 */

      /* If there's no specific special status, are we online? */

      default:
      {
        if (status & Dialler_Connected) showing_time = 1;
        else lookup_token("Offline", 0, 0);
      }
      break;
    }
  }

  if (showing_time)
  {
    /* If we want to show online time, install the handler to do so */
    /* (if it isn't already installed).                             */

    if (!b->dialler_last)
    {
      /* dialler_last holds a timer, and if non-zero is used by window close */
      /* routines to show that the null claimant needs deregistering. It is  */
      /* unlikely, but nonetheless possible, that the window could be closed */
      /* after the handler is registered but before it is called, so the     */
      /* dialler_last field would still be zero and no deregistration would  */
      /* take place. Hence to ensure that this doesn't happen, set the field */
      /* to a (small) non-zero value for now.                                */

      b->dialler_last = 1;
      register_null_claimant(Wimp_ENull, (WimpEventHandler *) handle_dialler_display, b);
    }
  }
  else
  {
    /* Otherwise, remove the handler if it is installed */

    if (b->dialler_last) deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) handle_dialler_display, b);
    b->dialler_last = 0;

    /* Copy the token contents to the display buffer and update the field */
    /* if the value has changed.                                          */

    StrNCpy0(display, tokens);

    e = displayfield_get_value(0, t, URLBarDiallerStatus, compare, sizeof(compare), NULL);
    if (e) return e;

    /* Update the display field if necessary, else exit */

    if (strcmp(display, compare))
    {
      e = displayfield_set_value(0, t, URLBarDiallerStatus, display);
      if (e) return e;
    }
  }

  /* May need to alter the label on this display, if there is one */

  {
    char label[Limits_URLBarDiallerStatusLabel];

    if (button_get_value(0, t, URLBarDiallerStatusLabel, label, sizeof(label), NULL)) return NULL;
    label[sizeof(label) - 1] = 0;

    if (!showing_time) lookup_token("DiaStatusDial:Dialler",0,0);
    else               lookup_token("DiaStatusTime:Time"   ,0,0);

    if (strcmp(label, tokens))
    {
      StrNCpy0(label, tokens);

      return button_set_value(0, t, URLBarDiallerStatusLabel, label);
    }
  }

  return NULL;
}

/*************************************************/
/* toolbars_merged_to_status()                   */
/*                                               */
/* If the URL writable and status lines are      */
/* merged, this ensures that the combined field  */
/* is put into 'status' display.                 */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the field;            */
/*                                               */
/*             Object ID of the toolbar the      */
/*             gadgets are in.                   */
/*                                               */
/* Assumes:    That the fields are indeed merged */
/*             though a null object ID can be    */
/*             given.                            */
/*************************************************/

void toolbars_merged_to_status(browser_data * b, ObjectId t)
{
  if (t)
  {
    char label[Limits_StatusBarStatusLabel];

    show_gadget(t, StatusBarStatus);
    hide_gadget(t, URLBarWrit);

    /* Update the label, if present */

    if (!button_get_value(0, t, StatusBarStatusLabel, label, sizeof(label), NULL))
    {
      label[sizeof(label) - 1] = 0;

      lookup_token("DisplayStats:Status",0,0);

      if (strcmp(label, tokens))
      {
        StrNCpy0(label, tokens);
        button_set_value(0, t, StatusBarStatusLabel, label);
      }
    }
  }
}

/*************************************************/
/* toolbars_merged_to_url()                      */
/*                                               */
/* If the URL writable and status lines are      */
/* merged, this ensures that the combined field  */
/* is put into 'URL entry' display.              */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the field;            */
/*                                               */
/*             Object ID of the toolbar the      */
/*             gadgets are in.                   */
/*                                               */
/* Assumes:    That the fields are indeed merged */
/*             though a null object ID can be    */
/*             given.                            */
/*************************************************/

void toolbars_merged_to_url(browser_data * b, ObjectId t)
{
  if (t)
  {
    char label[Limits_StatusBarStatusLabel];

    show_gadget(t, URLBarWrit);
    hide_gadget(t, StatusBarStatus);

    /* Update the label, if present */

    if (!button_get_value(0, t, StatusBarStatusLabel, label, sizeof(label), NULL))
    {
      label[sizeof(label) - 1] = 0;

      lookup_token("DisplayURL:URL",0,0);

      if (strcmp(label, tokens))
      {
        StrNCpy0(label, tokens);
        button_set_value(0, t, StatusBarStatusLabel, label);
      }
    }
  }
}

/*************************************************/
/* toolbars_set_bistate_state()                  */
/*                                               */
/* Sets a bistate button to a given state, which */
/* depends on the type of button in use.         */
/*                                               */
/* Naming conventions on the button types should */
/* dictate which state is which, with the word   */
/* order of the name relating to the states (so  */
/* for example, BiState_Cancel_Back would be at  */
/* Cancel for state 0, and Back for state 1).    */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the button;           */
/*                                               */
/*             Object ID of the toolbar the      */
/*             button is in;                     */
/*                                               */
/*             State (0 or 1) to set it to.      */
/*************************************************/

void toolbars_set_bistate_state(browser_data * b, ObjectId t, int state)
{
  switch (b->bistate)
  {
    case BiState_Cancel_Back:
    {
      ObjectId source;

      /* State 0 = Cancel, state 1 = Back */

      source = state ? ButtonBarBack : ButtonBarCancel;

      /* Copy the characteristics of the gadget over. */

      ChkError(copy_toolaction_info(t, source, t, ButtonBarBistate));

      b->bistate_state = state;
    }
    break;
  }
}

/*************************************************/
/* toolbars_set_tristate_state()                 */
/*                                               */
/* Sets a tristate button to a given state,      */
/* which depends on the type of button in use.   */
/*                                               */
/* Naming conventions on the button types should */
/* dictate which state is which, with the word   */
/* order of the name relating to the states (so  */
/* for example, TriState_Go_GoTo_Stop would be   */
/* at Go for state 0, GoTo for state 1, and Stop */
/* for state 2).                                 */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the button;           */
/*                                               */
/*             Object ID of the toolbar the      */
/*             button is in;                     */
/*                                               */
/*             State (0, 1 or 2) to set it to.   */
/*************************************************/

void toolbars_set_tristate_state(browser_data * b, ObjectId t, int state)
{
  ObjectId source;

  switch (b->tristate)
  {
    case TriState_Go_GoTo_Stop:
    {
      /* State 0 = Go, 1 = GoTo, 2 = Stop */

      if (!state)          source = ButtonBarGo;
      else if (state == 1) source = ButtonBarGoTo;
      else                 source = ButtonBarStop;

      /* Copy the characteristics of the gadget over. */

      ChkError(copy_toolaction_info(t, source, t, ButtonBarTristate));

      b->tristate_state = state;
    }
    break;
  }
}

/*************************************************/
/* toolbars_button_height()                      */
/*                                               */
/* Returns the button bar height for a window,   */
/* or 0 if there is no bar present. If there is  */
/* both a button bar and URL bar present the     */
/* combined height is less than the height of    */
/* both individual bars summed, due to an extra  */
/* gap at the edges for aesthetics. This         */
/* function does not attempt to compensate for   */
/* this (see toolbars_url_height, which does).   */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which holds the toolbars of       */
/*             interest.                         */
/*************************************************/

int toolbars_button_height(browser_data * b)
{
  if (b->button_bar)
  {
    ObjectId t;
    BBox     w;

    if (b->all_in_bottom) return 0;

    t = toolbars_get_upper(b);
    if (!t) return 0;

    if (!gadget_get_bbox(0, t, ButtonBarSpacer, &w)) return (w.ymax - w.ymin);
  }

  return 0;
}

/*************************************************/
/* toolbars_url_height()                         */
/*                                               */
/* Returns the URL bar height for a window, or 0 */
/* if there is no URL bar present. If there is   */
/* both a button bar and a URL bar present the   */
/* returned value will be reduced to account for */
/* the effective overlap of the two bars, as     */
/* when each is present individually there is a  */
/* gap at the edges for aesthetics.              */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which holds the toolbars of       */
/*             interest.                         */
/*************************************************/

int toolbars_url_height(browser_data * b)
{
  if (b->url_bar)
  {
    ObjectId t;
    BBox     w;

    if (b->all_in_bottom) return 0;

    t = toolbars_get_upper(b);
    if (!t) return 0;

    if (!gadget_get_bbox(0, t, URLBarSpacer, &w))
    {
      if (b->button_bar) return (w.ymax - w.ymin - toolbars_bar_overlap(t));
      else return (w.ymax - w.ymin);
    }
  }

  return 0;
}

/*************************************************/
/* toolbars_status_height()                      */
/*                                               */
/* Returns the status bar height for a window,   */
/* or 0 if there is no status bar present.       */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             which holds the toolbars of       */
/*             interest.                         */
/*************************************************/

int toolbars_status_height(browser_data * b)
{
  if (b->status_bar)
  {
    ObjectId t;
    BBox     w;

    if (b->all_in_top) return 0;

    t = toolbars_get_lower(b);
    if (!t) return 0;

    if (!gadget_get_bbox(0, t, StatusBarSpacer, &w)) return (w.ymax - w.ymin);
  }

  return 0;
}

/*************************************************/
/* toolbars_set_button_states()                  */
/*                                               */
/* Sets the button states in the button bar and  */
/* URL bar of a given browser window, greying or */
/* ungreying them according to the browser's     */
/* current state.                                */
/*                                               */
/* This call will not return errors derived from */
/* attempts to access non-existant gadgets; they */
/* will fail silently, to allow more varied UI   */
/* designs to work correctly.                    */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the browser window.   */
/*************************************************/

_kernel_oserror * toolbars_set_button_states(browser_data * b)
{
  ObjectId t;

  t = toolbars_get_upper(b);

  if (!t) return NULL; /* (E.g., parents (but not ancestors) in framesets won't have toolbars) */

  if (controls.dont_grey == Controls_DontGrey_GreyAll)
  {
    /* Can only stop if there's activity of some sort */

    if (
         (b->anim_handler    && !b->anim_drift)      ||
         (b->meta_refresh_at && b->meta_refresh_url)
       )
       set_gadget_state(t, ButtonBarStop, 0);

    else set_gadget_state(t, ButtonBarStop, 1);

    /* Can only go back if we're not at the start of the history */
    /* and there's a history to go into.                         */

    if (!history_can_go_backwards(b)) set_gadget_state(t, ButtonBarBack,    1);
    else                              set_gadget_state(t, ButtonBarBack,    0);

    /* Can only go forward if we're in the history somewhere */

    if (!history_can_go_forwards(b))  set_gadget_state(t, ButtonBarForward, 1);
    else                              set_gadget_state(t, ButtonBarForward, 0);

    /* Can only view or save the document source if there is some... */

    if (!b->source)
    {
      set_gadget_state(t, ButtonBarViewSource, 1);
      set_gadget_state(t, ButtonBarSaveSource, 1);
    }
    else
    {
      set_gadget_state(t, ButtonBarViewSource, 0);
      set_gadget_state(t, ButtonBarSaveSource, 0);
    }

    /* Can only save the page as text or a Draw file, or print it, if */
    /* we have a visible line list.                                   */

    if (b->nchildren || !b->cell || !b->cell->nlines)
    {
      set_gadget_state(t, ButtonBarPrint,      1);
      set_gadget_state(t, ButtonBarSaveAsText, 1);
      set_gadget_state(t, ButtonBarSaveAsDraw, 1);
    }
    else
    {
      set_gadget_state(t, ButtonBarPrint,      0);
      set_gadget_state(t, ButtonBarSaveAsText, 0);
      set_gadget_state(t, ButtonBarSaveAsDraw, 0);
    }

    /* Only need to load images if delayed image loading is set  */
    /* in the local browser flags, or plain backgrounds are set. */

    if (
         (
           !b->show_foreground &&
           b->displayed != Display_External_Image
         )
         ||
         !b->show_background
       )
       set_gadget_state(t, ButtonBarLoadImages, 0);

    else set_gadget_state(t, ButtonBarLoadImages, 1);
  }

  if (controls.dont_grey != Controls_DontGrey_GreyNone)
  {
    /* Can only get a history menu if there's a history present. */

    if (history_empty(b)) set_gadget_state(t, URLBarHistoryMenuR, 1);
    else                  set_gadget_state(t, URLBarHistoryMenuR, 0);
  }

  /* Handle bistate buttons */

  if (b->bistate)
  {
    switch (b->bistate)
    {
      case BiState_Cancel_Back:
      {
        /* If the URL writable and status display are merged, */
        /* and the URL display is visible, then the field is  */
        /* in writable mode and the bistate should be at      */
        /* 'cancel'. Otherwise, it should be at 'back'.       */

        if (b->merged_url && !gadget_hidden(t, URLBarWrit)) toolbars_set_bistate_state(b, t, 0);
        else                                                toolbars_set_bistate_state(b, t, 1);
      }
      break;
    }
  }

  /* Handle tristate buttons */

  if (b->tristate)
  {
    switch (b->tristate)
    {
      case TriState_Go_GoTo_Stop:
      {
        /* If the URL writable and status display are merged, */
        /* and the status display is hidden, then the field   */
        /* is in writable mode and the tristate should be at  */
        /* 'go'.                                              */

        if (b->merged_url && !gadget_hidden(t, URLBarWrit)) toolbars_set_tristate_state(b, t, 0);
        else
        {
          /* If we have an animation handler, should be showing 'Stop', */
          /* else we should be at 'go to'. However, odd states can      */
          /* occur so it's wise to check with this tristate, where the  */
          /* state is very important (you can't go anywhere if it's     */
          /* stuck on Stop, for example), what the status bar says.     */

          if (
               (b->anim_handler    && !b->anim_drift)      ||
               (b->meta_refresh_at && b->meta_refresh_url)
             )
          {
            toolbars_set_tristate_state(b, t, 2); /* Stop */
          }
          else
          {
            status_type type = toolbars_return_act_status(b);

            switch (type)
            {
              default:
              case Toolbars_Status_NoType:
              case Toolbars_Status_Ready:
              case Toolbars_Status_Viewing:
              {
                toolbars_set_tristate_state(b, t, 1); /* Go To */
              }
              break;

              case Toolbars_Status_Formatting:
              case Toolbars_Status_Processing:
              case Toolbars_Status_GetPics:
              case Toolbars_Status_Connected:
              case Toolbars_Status_SentReq:
              case Toolbars_Status_Responded:
              case Toolbars_Status_Redirected:
              case Toolbars_Status_Connecting:
              case Toolbars_Status_Fetching:
              {
                toolbars_set_tristate_state(b, t, 2); /* Stop */
              }
              break;
            }
          }
        }
      }
      break;
    }
  }

  return NULL;
}

/*************************************************/
/* toolbars_set_all_button_states()              */
/*                                               */
/* Sets all the button states in the toolbars of */
/* all the browser windows currently open; that  */
/* is, it greys and ungreys them as appropriate  */
/* for that browser's current state.             */
/*************************************************/

_kernel_oserror * toolbars_set_all_button_states(void)
{
  _kernel_oserror * e;
  browser_data    * b;

  b = last_browser;

  while (b)
  {
    e = toolbars_set_button_states(b);
    if (e) return e;

    b = b->previous;
  }

  return NULL;
}