Reformat

/* 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   : Reformat.c                             */
/*                                                 */
/* Purpose: Functions to handle page reformatting. */
/*                                                 */
/* Author : A.D.Hodgkinson                         */
/*                                                 */
/* History: 03-Dec-96: Created                     */
/*          16-Apr-97: First merge with T.Cheal's  */
/*                     table code...               */
/*          22-May-97: Amazingly, *still* trying   */
/*                     to get this to work.        */
/*          18-Jun-97: Hpmh; works, but very slow. */
/*                     Will need to rewrite at     */
/*                     some stage; for the moment, */
/*                     moved a few bits over to    */
/*                     Tables.c as they fitted in  */
/*                     better over there.          */
/***************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "swis.h"
#include "flex.h"

#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */

#include "wimp.h"
#include "wimplib.h"
#include "event.h"

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

#include "Browser.h"
#include "Fetch.h" /* (Which itself includes URLstat.h) */
#include "FetchPage.h"
#include "FontManage.h"
#include "Forms.h"
#include "History.h"
#include "Images.h"
#include "Memory.h"
#include "Object.h"
#include "Redraw.h"
#include "Tables.h"
#include "Toolbars.h"

#include "Reformat.h"

/* Local constant definitions */

#define BULLET_GAP 12

/* Static function prototypes */

static int               reformat_istext           (HStream * tp);
static int               reformat_useless_token    (HStream * tp);
static int               reformat_newline_check    (HStream * current, HStream * last, int offset);
static int               reformat_datasize         (HStream * p);
static _kernel_oserror * reformat_token_width      (reformat_width_data * w, unsigned int flags);
static void              reformat_check_visited    (browser_data * b, HStream * token);

static _kernel_oserror * reformat_add_line         (browser_data * b, reformat_cell * cell);
static _kernel_oserror * reformat_add_line_chunk   (browser_data * b, reformat_cell * cell);

static _kernel_oserror * reformat_format_from_now  (browser_data * b, int lastline);

static _kernel_oserror * reformat_text_line_height (browser_data * b, HStream * tp, int * top, int * bot);
static _kernel_oserror * reformat_check_height     (int toplevel, browser_data * b, reformat_cell * d, int line, HStream * tp, HStream * tpLast, int offset);
static int               reformat_reformatter_r    (unsigned int flags, browser_data * b, reformat_cell * d, HStream * streambase);

/* Local compilation options */

#undef SUPPORT_NOBR

// static void              reformat_strip_prespace (browser_data * b, int chunk, HStream * tp);

/*************************************************/
/* reformat_formatting()                         */
/*                                               */
/* Returns 0 if reformatting is not in progress, */
/* else non-zero.                                */
/*                                               */
/* Parameters: Pointer to the browser_data       */
/*             structure associated with the     */
/*             page which might be reformatting. */
/*                                               */
/* Returns:    0 if reformatting is not in       */
/*             progress, else it is.             */
/*************************************************/

int reformat_formatting(browser_data * b)
{
//  if (b->suspend_format) Printf("reformat_formatting: %p suspend_format set\n",b);
//  else if (b->last_token)
//  {
//    if (!b->last_token->next) Printf("reformat_formatting: %p b->last_token->next = NULL\n",b);
//    else if (b->last_token->next && !(b->last_token->next->flags & HFlags_DealtWithToken)) Printf("reformat_formatting: %p last_token->next HFlags NULL\n",b);
//    else if (b->cell->nlines <= 0) Printf("reformat_formatting: %p will return b->final_token != NULL: %d\n",b,b->final_token != NULL);
//    else Printf("reformat_formatting: %p will return 1\n",b);
//  }
//  else if (b->cell->nlines <= 0) Printf("reformat_formatting: %p will return b->final_token != NULL: %d\n",b,b->final_token != NULL);
//  else Printf("reformat_formatting: %p will return 1\n",b);

  /* Reformatting had been suspended due to an error */

  if (b->suspend_format) return 0;

  if (b->last_token)
  {
    /* If we've not overrun the tokens dealt with by the fetcher, */
    /* the fetcher could have exitted and this could be the last  */
    /* token (so we've finished).                                 */
    /*                                                            */
    /* The check for a 'next' token is done as final_token only   */
    /* records main token stream tokens dealt with by the         */
    /* preprocessor. It is possible for a precise set of          */
    /* circumstances to leave last_token and final_token          */
    /* equivalent due to table parsing, though there is more data */
    /* in the main token stream after it (this happened during    */
    /* testing, so it isn't all that rare).                       */

    if (!b->last_token->next) return 0;

    /* If the token after the last one dealt with by the   */
    /* fetcher had not been looked at by the preprocessor, */
    /* the reformatter must have exitted for that reason.  */

    if (b->last_token->next && !(b->last_token->next->flags & HFlags_DealtWithToken)) return 0;
  }

  /* If there are no lines, are there any HStream structures? */
  /* If so, the preprocessor has got stuff from the fetcher   */
  /* but the reformatter hasn't built anything with them yet. */

  if (b->cell->nlines <= 0) return (b->final_token != NULL);

  /* If none of the above, we must still be formatting */

  return 1;
}

/*************************************************/
/* reformat_stop()                               */
/*                                               */
/* Suspends a reformat, flagging that this has   */
/* been done in the browser_data structure.      */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             with the details of the reformat  */
/*             process to stop inside it.        */
/*************************************************/

_kernel_oserror * reformat_stop(browser_data * b)
{
  b->suspend_format = 1;

  return toolbars_set_button_states(b);
}

/*************************************************/
/* reformat_istext()                             */
/*                                               */
/* Returns 1 if an HStream structure represents  */
/* neither a horizontal rule nor an image.       */
/*                                               */
/* Parameters: Pointer to the HStream structure. */
/*                                               */
/* Returns:    1 if the struct represents text,  */
/*             else 0.                           */
/*************************************************/

static int reformat_istext(HStream * tp)
{
  return (
           ((tp->style) & (IMG | HR)) == 0 &&
           tp->tagno != TAG_TABLE          &&
           !ISOBJECT(tp)                   &&
           !
           (
             tp->tagno         == TAG_INPUT &&
             HtmlINPUTtype(tp) == inputtype_IMAGE
           )
         );
}

/*************************************************/
/* reformat_token_width()                        */
/*                                               */
/* Fills in the 'width' and 'bytes' fields of a  */
/* reformat_width_data structure according to    */
/* the contents of the token (HStream structure) */
/* that the reformat_width_data structure points */
/* to (this structure is defined in Reformat.h). */
/*                                               */
/* The idea is to fit the token into maxwidth    */
/* coordinates (in millipoints). The actual      */
/* width is returned (which may be greater than, */
/* or less than maxwidth) and the number of      */
/* bytes used to make that width is returned.    */
/*                                               */
/* Parameters: Pointer to a reformat_width_data  */
/*             structure (see Reformat.h);       */
/*                                               */
/*             A flags word, as ppassed to       */
/*             reformat_reformatter.             */
/*                                               */
/* Returns:    Fills in the structure's 'width'  */
/*             and 'bytes' fields with width and */
/*             byte count information.           */
/*************************************************/

static _kernel_oserror * reformat_token_width(reformat_width_data * w, unsigned int flags)
{
  _kernel_oserror * e = NULL;
  BBox box;

  /* Deal with tables */

  if (w->tp->tagno == TAG_TABLE)
  {
    reformat_cell * cellarray;
    table_stream  * table = (table_stream *) w->tp;
    int             size;
    int             toplevel;

    #ifdef TRACE
      if (tl & (1u<<20)) Printf("reformat_token_width: Dealing with table, token %p\n",table);
    #endif

    tables_count_table(w->b, table);

    size = table->ColSpan * table->RowSpan;

    #ifdef TRACE

      if (tl & (1u<<20))
      {
        Printf("reformat_token_width: Size of table is %d\n",size);
        if (!size) Printf("                      (Table has no cells...)\n");
      }

    #endif

    if (size) tables_position_table(w->b, table);

    #ifdef TRACE
      if (tl & (1u<<20)) Printf("reformat_token_width: Tag is now 0x%x\n",w->tp->tag);
    #endif

    /* If the table has no cells, may need to clear an existing cell array */

    if (!size)
    {
      if (table->cells) HtmlFree(table->cells);

      table->ncells = 0;
    }
    else
    {
      /* If we've got an existing cell array and the number of cells has */
      /* not changed, don't need to do anything. Otherwise, (re)allocate */
      /* the cell array.                                                 */

      if (!table->cells || table->ncells != size)
      {
        reformat_cell * old_cells = table->cells;

        /* Now allocate a new cell array and initialise the cell contents */

        table->cells = HtmlMalloc(size * sizeof(reformat_cell), table);

        /* If the allocation fails, can't possibly continue so jump */
        /* back to poll loop after reporting the error.             */

        if (!table->cells) show_error_cont(make_no_table_memory_error(9));

        /* Otherwise, initialise the cell contents */

        tables_init_table(w->b, table, table->cells);

        /* Copy over any old cells ('ncells' still holds the old number) */

        if (table->ncells && old_cells)
        {
          memcpy(table->cells, old_cells, table->ncells * sizeof(reformat_cell));

          /* Free the old cell array */

          HtmlFree(old_cells);
        }

        /* Now update 'ncells' */

        table->ncells = size;
      }
    }

    cellarray = table->cells;

    if (cellarray)
    {
      /* Find the width and height of the cells and fix their positions */
      /* as millipoint offsets from the top left of the table.          */
      /*                                                                */
      /* If the reformatter flags say not to generate lines, then we    */
      /* must be doing a width finding session as part of a parent      */
      /* table, so toplevel is 0. Otherwise, this is the highest level  */
      /* and toplevel is therefore set to 1.                            */

      if (flags & Reformatter_Virtual) toplevel = 1;
      else                             toplevel = 0;

      w->width = tables_width_table (toplevel, w->b, table, w->maxwid, cellarray, flags);
      w->bytes = tables_height_table(toplevel, w->b, table,            cellarray);

      tables_fix_table(w->b, table, cellarray);
    }

    #ifdef TRACE
      if (tl & (1u<<20)) Printf("reformat_token_width: Tag is now 0x%x\n",w->tp->tag);
    #endif

    /* Return the cell array pointer for convenience (may prove useful */
    /* to have this in the reformatter some time...).                  */

    w->data = (char *) cellarray;

    return e;
  }

  /* Deal with forms: Text-based elements */

  else if (
            w->tp->tagno == TAG_SELECT   ||
            w->tp->tagno == TAG_TEXTAREA ||
            w->tp->tagno == TAG_INPUT
          )
  {
    if (
         w->tp->tagno         == TAG_SELECT         ||
         w->tp->tagno         == TAG_TEXTAREA       ||
         HtmlINPUTtype(w->tp) == inputtype_PASSWORD ||
         HtmlINPUTtype(w->tp) == inputtype_TEXT
       )
    {
      int h;
      int done = 0;
      int length;

      if (w->tp->tagno == TAG_TEXTAREA)
      {
        /* Text areas */

        length = w->tp->cols;

        if (length == 1) length = 2;
        else if (length < 2) length = 30;

        done = 0;
      }
      else if (w->tp->tagno == TAG_SELECT)
      {
        /* SELECT elements (have pop-up menus) */

        int    width, l;
        int    extra = 0;
        char * p;

        e = read_sprite_size("fgright", &width, NULL);
        if (e) return e;

        width += 32; /* Account for border and gap */
        convert_to_points(width, &extra);

        /* Need to find out the actual used width, or we end up */
        /* generally overestimating the required size.          */

        p      = (char *) HtmlSELECToptions(w->tp) + 8;
        h      = fm_find_token_font(w->b, w->tp, 0);
        l      = 0;
        width  = 0;
        length = 0; /* Not used, but stops compiler giving warnings */

        /* Some fields can hold the selNONE or selMANY text, as well */
        /* as the menu item texts.                                   */

        if (HtmlSELECTmultiple(w->tp) || *p == 0xff)
        {
          e = fm_get_string_width(h,
                                  lookup_token("selNONE:<None>",0,0),
                                  Reformat_AsWideAsPossible_MP,
                                  strlen(tokens),
                                  -1,
                                  NULL,
                                  &width);

          if (!e && width > l) l = width;
        }

        if (HtmlSELECTmultiple(w->tp))
        {
          e = fm_get_string_width(h,
                                  lookup_token("selMANY:<Many>",0,0),
                                  Reformat_AsWideAsPossible_MP,
                                  strlen(tokens),
                                  -1,
                                  NULL,
                                  &width);

          if (!e && width > l) l = width;
        }

        /* Look for the width of the widest OPTION field */

        while (*p != 0xff)
        {
          p++;

          e = fm_get_string_width(h,
                                  p,
                                  Reformat_AsWideAsPossible_MP,
                                  strlen(p),
                                  -1,
                                  NULL,
                                  &width);

          if (e)
          {
            erb   = *e, e = &erb;
            width = 16000; /* Arbitrary! Give it 40 OS units on error */
            break;
          }

          /* Record if this is the widest and skip to the next field */

          if (width > l) l = width;

          p += strlen(p) + 1;
          p += strlen(p) + 1;
        }

        /* Set the width and flag that we've done the calculation */
        /* already so code lower down doesn't try.                */

        w->width = l + extra;
        done     = 1;
      }
      else
      {
        /* One line writable */

        length = HtmlINPUTsize(w->tp);

        if (length == 1) length = 2;
        else if (length < 2)
        {
          length = w->tp->maxlen;
          if (length > 40) length = 40;
        }

        done = 0;
      }

      /* Some cases above may have worked out the width already. */
      /* For those that haven't, do it on the basis of 'length', */
      /* holding the maximum number of characters, and the       */
      /* width of the widest character possible in the item.     */

      if (!done)
      {
        BBox box;

        if (length == 1) length = 2;
        else if (length < 2) length = 20;

        /* Finding the width based on font BBox multipled by the */
        /* field length usually is a significant overestimation, */
        /* so use a number instead - this is typically closer.   */

        h = fm_find_token_font(w->b, w->tp, 0);

        e = fm_char_box(h, '0', &box);

        if (e) erb = *e, e = &erb;
        else
        {
          w->width = ((box.xmax - box.xmin) * length) + 20;

          convert_to_points(w->width, &w->width);
        }
      }

      w->bytes = 0;

      return e;
    }
    else switch(HtmlINPUTtype(w->tp))
    {
      case inputtype_SUBMIT: /* No break - same as RESET */
      case inputtype_BUTTON: /* Again, no break          */
      case inputtype_RESET:
      {
        const char * p;
        int    h, length, end;

        p = form_button_text(w->tp);
        length = strlen(p);
        end = 0;

        while(end < length && p[end] != '\n') end++;

        h = fm_find_token_font(w->b, w->tp, 0);
        e = fm_get_string_width(h,
                                p,
                                Reformat_AsWideAsPossible_MP,
                                end - w->offset,
                                -1,
                                &w->bytes,
                                &w->width);

        if (e) erb = *e, e = &erb;

        w->width += 400 * 4 * 12; /* Account for border */
        w->bytes  = 0;

        return e;
      }
      break;

      case inputtype_CHECKBOX:
      {
        w->bytes = 0;

        read_sprite_size("fopton", &w->width, NULL);

        convert_to_points(w->width, &w->width);
      }
      break;

      case inputtype_RADIO:
      {
        w->bytes = 0;

        read_sprite_size("fradioon", &w->width, NULL);

        convert_to_points(w->width, &w->width);
      }
      break;

      case inputtype_HIDDEN:
      {
        w->width = w->bytes = 0;
      }
      break;

      case inputtype_IMAGE:
      {
        goto do_image; /* See below */
      }
      break;
    }
  }

  /* Handle OBJECT, EMBED and APPLET tags */

  else if (ISOBJECT(w->tp))
  {
    RetError(reformat_get_object_size(w->b, w->tp, &box));

    w->width = box.xmax - box.xmin;

    convert_to_points(w->width, &w->width);
  }

  /* Handle images */

  else if (w->tp->style & IMG)
  {
do_image: /* Used by switch statement above */

    w->bytes = 0;
    w->width = 0;

    /* Now get the size of the image for reformatting purposes */

    RetError(reformat_get_image_size(w->b, w->tp, &box));

    w->width = box.xmax - box.xmin;

    convert_to_points(w->width, &w->width);
  }
  else if (w->tp->style & HR)
  {
    /* For a horizontal rule, there's no extra data to put in (so */
    /* the w->bytes field is zero) and the width is as wide as    */
    /* the specified maximum width, unless the HR specifies a     */
    /* particular width directly.                                 */
    /*                                                            */
    /* The special case of finding min/max widths is checked in   */
    /* the flags here, as otherwise any HR tag can force the      */
    /* width up to maxwid - which may be very large.              */

    w->bytes = 0;

    if (!HR_HAS_WIDTH(w->tp) || HR_WIDTH_UNITS(w->tp) == UNITS_PERCENT)
    {
      if (
           !(flags & Reformatter_FindingWidest)   &&
           !(flags & Reformatter_FindingSmallest)
         )
      {
        if (HR_HAS_WIDTH(w->tp)) w->width = (w->maxwid * HR_WIDTH(w->tp)) / 100;
        else                     w->width = w->maxwid;
      }

      else w->width = 0;
    }
    else
    {
      w->width = HR_WIDTH(w->tp) * 2; /* 1 'web pixel' = 2 OS units */

      convert_to_points(w->width, &w->width);
    }
  }
  else if (ISBULLET(w->tp)) /* ISBULLET is defined in Fetch.h */
  {
    /* For a bullet, there is again no extra data so bytes = 0, */
    /* and the width is taken from the sprite width of the      */
    /* bullet point.                                            */

    w->bytes = 0;

    convert_to_points(reformat_bullet_width(w->tp->indent), &w->width);
  }
  else
  {
    int h, end, split;

    /* Can't do anything if there's no text */

    if (!w->data || !*w->data)
    {
      w->bytes = 0;
      w->width = 0;
    }
    else
    {
      /* Loop round until a newline is found, or the end of the  */
      /* string is reached, starting at the offset into the data */
      /* specified by the 'offset' field.                        */

      end = w->offset;

      while (w->data[end] && w->data[end] != '\n') end++;

      /* If the text is preformatted, set a null split character. */
      /* Else specify splitting on spaces.                        */

      split = (w->tp->style & PRE) ? -1 : ' ';

      /* Get a font handle for rendering the token */

      h = fm_find_token_font(w->b, w->tp, 0);

      /* If end > offset, the loop above must have gone through at least */
      /* one non-newline character in the string, or there was no string */
      /* to look through; find the width of the string (the call won't   */
      /* mind if there's no string, it'll just return 0)                 */

      if (end > w->offset) e = fm_get_string_width(h,
                                                   w->data + w->offset,
                                                   w->maxwid,
                                                   end - w->offset,
                                                   split,

                                                   &w->bytes,
                                                   &w->width);

      /* If finding the minimum or maximum width for tables, add a little to */
      /* the above width to account for italics etc. - the font manager will */
      /* not have returned the upper limit on either side.                   */

      if (
           (flags & Reformatter_FindingWidest)   ||
           (flags & Reformatter_FindingSmallest)
         )
         w->width += 3200;

      /* If the scan for a newline finished before the end of the string (so */
      /* a newline was found) and the chunk of data defined by the call to   */
      /* fm_get_string_width above gave a string ending in a newline, add 1  */
      /* to the bytes counter to ensure that the chunk includes it.          */

      if (w->data[end] && w->data[w->offset + w->bytes] == '\n') w->bytes++;
    }
  }

  return e;
}

/*************************************************/
/* reformat_useless_token()                      */
/*                                               */
/* Checks to see if a token (HStream struct) is  */
/* of any use to the reformatter.                */
/*                                               */
/* Parameters: Pointer to the HStream struct.    */
/*                                               */
/* Returns:    1 = the token is useless, else 0. */
/*************************************************/

static int reformat_useless_token(HStream * tp)
{
  if (ISHEAD(tp)) return 1;
  if (ISNULL(tp)) return 1;

  if (tp->flags & HFlags_IgnoreObject) return 1;

  if (
       ISBODY(tp)   &&
       !tp->tag     &&
       !tp->tagno   &&
       !tp->text    &&
       !tp->anchor  &&
       !tp->src     &&
       !tp->enctype &&
       !tp->name    &&
       !tp->value   &&
       !tp->target  &&
       (
         tp->style == 0x00000000 ||
         tp->style == 0x80000000
       )
     )
     return 1;

  return 0;
}

/*************************************************/
/* reformat_newline_check()                      */
/*                                               */
/* Works out whether or not there should be a    */
/* line break in the page, according to the      */
/* token (HStream structure) that is currently   */
/* being considered and the token that was last  */
/* considered, and the offset into the data of   */
/* the tokens.                                   */
/*                                               */
/* Parameters: Pointer to the current token (the */
/*             HStream structure that is being   */
/*             dealt with by the reformatter,    */
/*             say, at the moment);              */
/*                                               */
/*             Pointer to the last token that    */
/*             was dealt with;                   */
/*                                               */
/*             Data offset into the tokens.      */
/*                                               */
/* Returns:    0 if there is no line break       */
/*             needed, or a value between 1 and  */
/*             8 that says 'yes, line break      */
/*             needed' and also holds details of */
/*             the conditions that were met to   */
/*             determine the line break was      */
/*             needed.                           */
/*************************************************/

static int reformat_newline_check(HStream * current, HStream * last, int offset)
{
  /* It generally looks better if there's a line break for tables, */
  /* though this is theoretically not necessary. In practice you   */
  /* find various line spacing and redraw problems without the     */
  /* break - this may get sorted one day...!                       */

  if (current->tagno == TAG_TABLE || last->tagno == TAG_TABLE) return 9;

  /* If the current token represents a horizontal rule and the last token also */
  /* represented one, with no offset indicating extra data in the tokens (and  */
  /* provided that there is actually a last token!), then return 1.            */

  if (((current->style) & HR) || ((!offset) && (last) && ((last->style) & HR))) return 1;

  /* If we have a paragraph break but the last item was a <li> tag, and we are */
  /* at the top of the line, then HTML like '<ul><li><p>Text' is being used -  */
  /* we should ignore the <p> tag. The position of this line of code relative  */
  /* to other checks in this function is obviously quite important (so be      */
  /* careful with it!)...                                                      */

  if (!offset && (current->style & P) && (last->style & LI)) return 0;

  /* If the tag itself indicates that a linebreak is needed, and we are at the */
  /* start of this line (offset into it is zero), return 2. This may be due to */
  /* <P>, <BR> and the like, in the document source.                           */

  if ((!offset) && ((current->style) & LINEBREAK)) return 2;

  /* If, again, this is the start of a line, and the pointer to the previous */
  /* token dealt with is not null, proceed with other line break checks.     */

  if ((!offset) && (last))
  {
    /* If the indentation has changed since the last token (e.g. a new list has */
    /* been started or an old one closed between the two tokens) then return 3. */

    if (current->indent != last->indent) return 3;

    /* If the header type changed between the two tokens, then provided the     */
    /* last token wasn't a list item (in which case a line break will already   */
    /* have been put in) return 4.                                              */

    if (((current->style & H_MASK) != (last->style & H_MASK)) && !(last->style & LI)) return 4;

    /* When certain tags are turned on or off, we want a linebreak. For example */
    /* it looks tidier for preformatted text to have a gap above and below it,  */
    /* rather than having it touch the previous and following text. The macro   */
    /* LINEBREAKSW (defined in Reformat.h) has a list of these tags ORed        */
    /* together to form a mask - if this mask changes between the tokens, one   */
    /* of the listed tags must have turned on or off. So we want a line break;  */
    /* hence, return 5.                                                         */

    if ((current->style & LINEBREAKSW) != (last->style & LINEBREAKSW)) return 5;

    /* CENTRED is defined in Reformat.h, and is 1 if the token holds data that  */
    /* should be displayed centred in the page. If switching from centred to    */
    /* uncentred text or vice versa, there must be a line break. So return 6.   */

    if (CENTRED(current) != CENTRED(last)) return 6;

    /* Some tags need a line break when they turn on, for example at the start  */
    /* of certain special kinds of list. The LINEBREAKON macro is defined in    */
    /* reformat.h and contains an ORed together list of such tags (just like    */
    /* the LINEBREAKSW macro used above) - so if the current token has one of   */
    /* these turned on, but the last token had it turned off, we want another   */
    /* line break; return 7.                                                    */

    if ((current->style & LINEBREAKON) && !(last->style & LINEBREAKON)) return 7;

    /* Similarly, some tags need a line break when they turn off; for example,  */
    /* headers look better if they have a gap underneath them. So again, there  */
    /* is a macro (LINEBREAKOFF) in Reformat.h which has a list of these tags   */
    /* and a value of 8 is returned if we go from one of these being turned     */
    /* on to one being turned off.                                              */

    if (!(current->style & LINEBREAKOFF) && (last->style & LINEBREAKOFF)) return 8;
  }

  /* If none of the above conditions are met, we need no line break - return 0. */

  return 0;
}

/*************************************************/
/* reformat_newline()                            */
/*                                               */
/* Returns 1 if a line break should be inserted  */
/* onto the page, or 0 if not. Does this by      */
/* calling reformat_newline_check and is only    */
/* interested in if the value the call returned  */
/* was zero or not.                              */
/*                                               */
/* Parameters: As for reformat_newline_check.    */
/*                                               */
/* Returns:    1 = line break required, else 0.  */
/*************************************************/

int reformat_newline(HStream * current, HStream * last, int offset)
{
  return (reformat_newline_check(current, last, offset) != 0);
}

/*************************************************/
/* reformat_datasize()                           */
/*                                               */
/* Returns the size of standard data pointed to  */
/* by an HStream (e.g. the length of any text    */
/* string it points to).                         */
/*                                               */
/* Parameters: Pointer to the HStream struct     */
/*                                               */
/* Returns:    Size of associated data in bytes. */
/*************************************************/

static int reformat_datasize(HStream * tp)
{
  /* Is this a text item? */

  if (!reformat_istext(tp)) return 0;

  /* If the HStream has a pointer to some text, return the */
  /* length of that text, else return zero.                */

  return (tp->text ? strlen(tp->text) : 0);
}

/*************************************************/
/* reformat_shift_vertically()                   */
/*                                               */
/* Shifts all lines between two given line       */
/* numbers (inclusive) by a given y coordinate,  */
/* in OS units. A redraw is generated with       */
/* Wimp_BlockCopy if moved lines lie inside the  */
/* visible area of the browser window.           */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             holding information on the lines; */
/*                                               */
/*             The line number at which to start */
/*             (inclusive);                      */
/*                                               */
/*             The line number at which to end   */
/*             (inclusive);                      */
/*                                               */
/*             The value to shift the lines by,  */
/*             in OS units - since the Y coords  */
/*             of the lines are for a window,    */
/*             a negative value would move the   */
/*             lines down the window and vice    */
/*             versa.                            */
/*************************************************/

_kernel_oserror * reformat_shift_vertically(browser_data * b, int start, int end, int y_shift)
{
  _kernel_oserror         * e;
  reformat_cell           * cell = b->cell;
  int                       line;
  WimpGetWindowStateBlock   s;

  if (!y_shift) return NULL;

  /* Limit check start and end, and exit if there appear */
  /* to be no lines to move                              */

  if (start > cell->nlines - 1) return NULL;
  if (start < 0) start = 0;
  if (end > cell->nlines - 1) end = cell->nlines - 1;
  if (end < 0) end = 0;
  if (start > end) line = start, start = end, end = line;

  if ((end < 0) || (start < 0) || (!cell->ldata)) return NULL;

  /* Alter the lines' y-coordinates */

  for (line = start; line <= end; line ++) cell->ldata[line].y += y_shift;

  /* Have to force a redraw of the entire page to ensure */
  /* that image positions are updated                    */

  s.window_handle = b->window_handle;
  e = wimp_get_window_state(&s);
  if (e) return e;

  coords_box_toworkarea(&s.visible_area, (WimpRedrawWindowBlock *) &s);

  return wimp_force_redraw(s.window_handle,
                           s.visible_area.xmin,
                           s.visible_area.ymin,
                           s.visible_area.xmax,
                           s.visible_area.ymax);
}

/*************************************************/
/* reformat_format_from()                        */
/*                                               */
/* Starts a new reformat session, possibly       */
/* starting after a given last line (i.e. from   */
/* a certain point in the page, rather than the  */
/* whole page).                                  */
/*                                               */
/* The reformat session may be postponed until   */
/* later according to the RefoTime and RefoWait  */
/* entires in the Choices file.                  */
/*                                               */
/* The defined way to ensure all line and chunk  */
/* data for a given browser is freed, including  */
/* that tied up in tables, is by calling with    */
/* the browser_data struct, -1, 1, and -1 (see   */
/* parameters list below).                       */
/*                                               */
/* Parameters: A pointer to a browser_data       */
/*             structure for which the reformat  */
/*             is to take place;                 */
/*                                               */
/*             The number of the last valid      */
/*             reformat_line structure;          */
/*                                               */
/*             1 to format now, else the request */
/*             may be delayed for some time;     */
/*                                               */
/*             For requests generated by the     */
/*             resizing of images, pass the      */
/*             image number, else pass -1.       */
/*************************************************/

_kernel_oserror * reformat_format_from(browser_data * b, int lastline, int immediate, int image)
{
  _kernel_oserror * e;

  /* Do we delay these requests? Yes if told to in the Choices,  */
  /* in the function parameters, or if we're showing an external */
  /* image (want to see that come in progressively, not wait for */
  /* a reformat which is in this particular case completely      */
  /* trivial anyway).                                            */

  if (
       !choices.refo_wait ||
       immediate          ||
       b->displayed == Display_External_Image
     )
  {
    reformat_format_from_now(b, lastline);
  }
  else
  {
    if (b->refo_time)
    {
      /* If there's already a pending request, is the line number */
      /* specified for this one lower than the one already there? */
      /* If so, then use that higher line, else stick with the    */
      /* old one. Nothing else to do - the null handler takes     */
      /* care of it all.                                          */

      if (lastline < b->refo_line) b->refo_line = lastline;
    }
    else
    {
      /* This is the first reformat request; so set the timer and */
      /* install a null handler for it.                           */

      e = _swix(OS_ReadMonotonicTime,
                _OUT(0),

                &b->refo_time);

      if (e) return e;

      b->refo_line = lastline;

      register_null_claimant(Wimp_ENull, (WimpEventHandler *) reformat_format_timer, b);
    }
  }

  return NULL;
}

/*************************************************/
/* reformat_format_timer()                       */
/*                                               */
/* Calls the reformatter after a delay given by  */
/* the Choices file entry 'RefoTime', according  */
/* to the start time specified by the            */
/* 'refo_time' field of the browser_data         */
/* structure.                                    */
/*                                               */
/* Parameters are as standard for a Wimp event   */
/* handler.                                      */
/*************************************************/

int reformat_format_timer(int eventcode, WimpPollBlock * b, IdBlock * idb, browser_data * handle)
{
  int timenow;

  /* If there appears to be no initiation time specified in the      */
  /* browser_data structure, dereigster and exit (being cautions...) */

  if (!handle->refo_time)
  {
    handle->refo_time = 1; /* So that reformat_stop_pending will deregister this handler */

    reformat_stop_pending(handle);

    return 0;
  }

  /* Otherwise, get the current time into 'timenow' */

  if (_swix(OS_ReadMonotonicTime,
            _OUT(0),

            &timenow)) return 0;

  /* Do we need to reformat yet? */

  if (timenow - handle->refo_time > choices.refo_time)
  {
    /* reformat_format_from_now will deregister this handler */

    ChkError(reformat_format_from_now(handle, handle->refo_line));
  }

  return 0;
}

/*************************************************/
/* reformat_format_from_now()                    */
/*                                               */
/* Starts a new reformat session, possibly       */
/* starting after a given last line (i.e. from   */
/* a certain point in the page, rather than the  */
/* whole page).                                  */
/*                                               */
/* The reformat session will be stared           */
/* immediately - it will not be delayed. Don't   */
/* call this directly - go through               */
/* reformat_format_from instead.                 */
/*                                               */
/* Parameters: A pointer to a browser_data       */
/*             structure for which the reformat  */
/*             is to take place;                 */
/*                                               */
/*             The number of the last valid      */
/*             reformat_line structure.          */
/*************************************************/

static _kernel_oserror * reformat_format_from_now(browser_data * b, int lastline)
{
  int             bottom = 0;
  reformat_cell * cell   = b->cell;

  /* If this browser had any queued reformats, cancel them */

  if (b->refo_time)
  {
    if (b->refo_line < lastline) lastline = b->refo_line;

    reformat_stop_pending(b);
  }

  /* Line numbers less than -1 are invalid, and can't end */
  /* on a line greater than the number of lines present!  */

  if (lastline < -1) lastline = -1;
  if (lastline >= cell->nlines) lastline = cell->nlines - 1;

  /* Clear the flag that says formatting is suspended due to error */

  b->suspend_format = 0;

  /* Clear the field holding the last token number for which */
  /* reformatting was definitely completed                   */

  b->last_token = NULL;

  /* If lastline holds a valid line number, set bottom to the */
  /* bottom y coordinate of the last line. Otherwise leave    */
  /* bottom set at 0 (we're reformatting to no lines).        */

  if (lastline >= 0) bottom = cell->ldata[lastline].y;

  /* If there's existing line data, need to ensure that all  */
  /* memory allocated in table cells is freed before getting */
  /* rid of the lines after lastline.                        */

  tables_free_memory(1, b, cell, lastline + 1);

  /* If we're reformatting to less than the current number of */
  /* lines, 'chop off' those that are left over.              */

  if ((lastline + 1) < cell->nlines)
  {
    int size;//, topline;

//    /* Before anything else, mark the token currently displayed at the */
//    /* top of the page so it can be shown after the reformat.          */
//
//    topline = browser_top_line(b, cell, 0) - 1;
//
//    if (topline >= 0 && (lastline + 1) < topline)
//    {
//      b->display_request = cell->cdata[cell->ldata[topline].chunks].t;
//      b->display_offset  = cell->cdata[cell->ldata[topline].chunks].o;
//      b->display_vscroll = 0;
//    }

    /* Size = offset of line chunks for the last line, plus  */
    /*        the number of line chunks times the size of a  */
    /*        chunk. I.e. the offset for the end of the line */
    /*        chunks for the last line - so size = size of   */
    /*        data that is needed for all the line chunks    */
    /*        with lastline chunks present.                  */

    if (lastline < 0) size = 0;
    else
    {
      /* If it turns out this line has no chunks, need to use the chunk address */
      /* and number of chunks for the previous line; unless, of course, this is */
      /* line 0, in which case there are no previous lines to refer to.         */

      if (!cell->ldata[lastline].n)
      {
        if (lastline == 0) size = 0;
        else size = (cell->ldata[lastline - 1].chunks + /* Base array offset into chunks                                    */
                    cell->ldata[lastline - 1].n)      * /* Add number of chunks for this line to get total number of chunks */
                    sizeof(reformat_line_chunk);        /* Multiply by size of a reformat_line_chunk to get total size      */
      }

      /* Otherwise, we're OK; the last line has line chunks. */

      else size = (cell->ldata[lastline].chunks +
                  cell->ldata[lastline].n)      *
                  sizeof(reformat_line_chunk);
    }

    /* Clip the number of lines to the new value */

    cell->nlines = lastline + 1;

    /* Make sure that the right amount of memory is allocated */

    #ifdef TRACE
      if (tl & (1u<<12)) Printf("reformat_format_from: Chunk CK_LINE set to %d\n",(lastline + 1) * sizeof(reformat_line));
    #endif

    memory_set_chunk_size(b, cell, CK_LINE, (lastline + 1) * sizeof(reformat_line));

    #ifdef TRACE
      if (tl & (1u<<12)) Printf("reformat_format_from: Chunk CK_LDAT set to %d\n",size);
    #endif

    memory_set_chunk_size(b, cell, CK_LDAT, size);
  }

  if (!printing)
  {
    /* Ensure null events are claimed for the rest of the reformat */

    if (!b->fetch_handler) fetchpage_claim_nulls(b);

    /* Update the status bar */

    toolbars_update_status(b, Toolbars_Status_Formatting);
  }

  /* Ensure the pointer shape is OK */

  browser_pointer_check(0, NULL, NULL, b);

  /* Redraw the bottom line of the window if not printing */

  return (!printing ? browser_update_bottom(b, bottom) : NULL);
}

/*************************************************/
/* reformat_stop_pending()                       */
/*                                               */
/* Stops any pending reformats from happening,   */
/* deregistering handlers etc. as needed.        */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the queue.            */
/*************************************************/

void reformat_stop_pending(browser_data * b)
{
  if (b->refo_time) deregister_null_claimant(Wimp_ENull, (WimpEventHandler *) reformat_format_timer, b);

  b->refo_time = 0;
  b->refo_line = Reformat_UnrealisticallyHighLineNumber;
}

/*************************************************/
/* reformat_get_image_size()                     */
/*                                               */
/* Gets a BBox for a specified image in OS       */
/* coordinates relative to the font base line    */
/* and left hand edge.                           */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the image;            */
/*                                               */
/*             A token address for the image;    */
/*                                               */
/*             Pointer to a BBox in which the    */
/*             relevant coords are returned.     */
/*                                               */
/* Assumes:    Pointer to the BBox may not be    */
/*             NULL.                             */
/*************************************************/

_kernel_oserror * reformat_get_image_size(browser_data * b, HStream * tp, BBox * box)
{
  _kernel_oserror * e;
  imgalign          align;
  fm_face           h;
  BBox              hbox;
  int               height = 0;

  /* We can't easily find out how high text is surrounding */
  /* the image for align=top, align=middle or whatever,    */
  /* but we can do a reasonable guess based on whatever    */
  /* font the given token would use if it held text.       */

  h = fm_find_token_font(NULL, tp, 0);

  if (h)
  {
    if (!fm_font_box(h, &hbox)) height = hbox.ymax - hbox.xmin;

    fm_lose_font(NULL, h);
  }

  /* Get the image size from the image library */

  e = image_get_token_image_size(b, tp, box);
  if (e) return e;

  /* Deal with alignments */

  if (tp->style & IMG) /* It'll either be an IMG or an INPUT TYPE=IMAGE item */
  {
    if      ((tp->type & TYPE_ALIGN_MASK) == TYPE_MIDDLE) align = imgalign_MIDDLE;
    else if ((tp->type & TYPE_ALIGN_MASK) == TYPE_TOP)    align = imgalign_TOP;
    else                                                  align = imgalign_NONE;
  }
  else align = HtmlINPUTalign(tp);

  switch (align)
  {
    case imgalign_MIDDLE:
    {
      int hh = height / 3; /* Technically '/ 2', but '/ 3' looks, on average, better in practice */

      box->ymin -= box->ymax / 2;
      box->ymax /= 2;

      box->ymin += hh;
      box->ymax += hh;
    }
    break;

    case imgalign_TOP:
    {
      box->ymin = height - box->ymax;
      box->ymax = height;
    }
    break;
  }

  /* Deal with links - need to account for a border */
  /* of maxlen * 2 pixels width. ISLINK is defined  */
  /* in Fetch.h.                                    */

  if (tp->style & IMG)
  {
    int b;

    b = tp->maxlen * 2;

    box->xmax += b;
    box->ymax += b;
    box->xmin -= b;
    box->ymin -= b;
  }

  return NULL;
}

/*************************************************/
/* reformat_get_object_size()                    */
/*                                               */
/* Gets a BBox for a specified Object in OS      */
/* coordinates relative to the font base line    */
/* and left hand edge.                           */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the Object;           */
/*                                               */
/*             A token address for the Object;   */
/*                                               */
/*             Pointer to a BBox in which the    */
/*             relevant coords are returned.     */
/*                                               */
/* Assumes:    Pointer to the BBox may not be    */
/*             NULL.                             */
/*************************************************/

_kernel_oserror * reformat_get_object_size(browser_data * b, HStream * tp, BBox * box)
{
  imgalign align;

  /* Get the Object size from the Object library */

  RetError(object_get_token_object_size(b, tp, box));

  /* Deal with alignments */

  align = HtmlOBJECTalign(tp);

  switch (align)
  {
    case imgalign_MIDDLE:
    {
      box->ymin -= box->ymax / 2;
      box->ymax /= 2;
    }
    break;

    // Sort this out, as with image handling

    case imgalign_TOP:
    {
      box->ymin =- box->ymax;
      box->ymax = 0;
    }
    break;
  }

  /* Account for a border */

  if (HtmlOBJECTborder(tp))
  {
    int b;

    b = HtmlOBJECTborder(tp) * 2;

    box->xmax += b;
    box->ymax += b;
    box->xmin -= b;
    box->ymin -= b;
  }

  return NULL;
}
/*************************************************/
/* reformat_get_placeholder_size()               */
/*                                               */
/* Gets a BBox that a placeholder would fill     */
/* based on given ALT text to plot inside it.    */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the placeholder;      */
/*                                               */
/*             Pointer to an HStream struct      */
/*             representing the placeholder;     */
/*                                               */
/*             Pointer to the ALT text (or NULL  */
/*             or a null string for no text);    */
/*                                               */
/*             Pointer to a BBox, in which the   */
/*             required bounding box for the     */
/*             placeholder is written.           */
/*                                               */
/* Assumes:    Pointer to the BBox may not be    */
/*             NULL.                             */
/*************************************************/

void reformat_get_placeholder_size(browser_data * b, HStream * tp, const char * text, BBox * box)
{
  int  h, temp, size;
  BBox fbox;

  /* Quick sanity check */

  if (!box) return;

  box->xmin = box->ymin = 0;

  if (!b || !tp || !text || !*text)
  {
    box->xmax = ImageDefaultOSSize_X;
    box->ymax = ImageDefaultOSSize_Y;

    return;
  }

  /* Claim the font */

  size = (fm_size(tp->fontsize) * 80) / 100;

  h = fm_find_font(b,
                   "sans",
                   size,
                   size,
                   0,
                   0);

  /* Find the string width of the ALT text */

  fm_get_string_width(h,
                      text,
                      Reformat_AsWideAsPossible_MP,
                      strlen(text),
                      -1,
                      &temp,
                      &box->xmax);

  convert_to_os(box->xmax, &box->xmax);

  /* Find the font height */

  fm_font_box(h, &fbox);

  /* As well as subtracting ymin (the y minimum coordinate */
  /* of the font bbox) from ymax, need to also add some    */
  /* height to give a gap between the text and slabbed box */
  /* that's drawn to mark the image's position.            */

  box->ymax = fbox.ymax - fbox.ymin;

  convert_to_os(choices.font_size, &temp);

  if (temp < 20) temp = 20;

  box->ymax += temp;
  box->xmax += temp + temp / 2; /* Looks better to have extra horizontally */

  /* Don't want to force the page width up just because of */
  /* ALT text in images, especially in narrow items such   */
  /* as navigation frames, so limit check xmax.            */

  // Currently this is done by an absolute hard coded upper
  // limit, but ultimately it would ideally be limited e.g.
  // by cell width. Just as soon as I work out a nice way
  // of doing that... (Remember, you may not know the cell
  // width at times when this is being called to try and
  // determine it; yet you must return consistent and
  // appropriate values subsequently for redraw purposes).

  {
    int remain;

    convert_to_os(b->left_margin + b->right_margin, &remain);

    remain = b->display_width - remain;
    if (remain > 320) remain = 320;

    if (box->xmax > remain) box->xmax = remain;
  }

  /* Finished */

  return;
}

/*************************************************/
/* reformat_bullet_width()                       */
/*                                               */
/* Returns the width of a given bullet in OS     */
/* units.                                        */
/*                                               */
/* Parameters: The bullet number (in the Sprites */
/*             file, bullets are named b1, b2,   */
/*             ...bn).                           */
/*************************************************/

int reformat_bullet_width(int bullet)
{
  char spr[32];
  int  w;

  sprintf(spr, "b%d\0", (bullet + bullets - 1) % bullets);

  if (read_sprite_size(spr, &w, NULL)) w = 32;

  /* See top of the file for BULLET_GAP */

  return w + BULLET_GAP;
}

/*************************************************/
/* reformat_bullet_height()                      */
/*                                               */
/* Returns the height of a given bullet in OS    */
/* units.                                        */
/*                                               */
/* Parameters: The bullet number (in the Sprites */
/*             file, bullets are named b1, b2,   */
/*             ...bn).                           */
/*************************************************/

int reformat_bullet_height(int bullet)
{
  char spr[32];
  int  h;

  sprintf(spr, "b%d\0", (bullet + bullets - 1) % bullets);

  if (read_sprite_size(spr, NULL, &h)) h = 32;

  return h;
}

/*************************************************/
/* reformat_y_offset()                           */
/*                                               */
/* Returns the y offset from the top of a page,  */
/* in OS units, for all lines on that page.      */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             representing the page.            */
/*                                               */
/* Returns:    y offset for all the lines on the */
/*             page, in OS units, from the top.  */
/*************************************************/

int reformat_y_offset (browser_data * b)
{
  int offset;

  if (!controls.swap_bars) offset = toolbars_button_height(b) + toolbars_url_height(b);
  else                     offset = toolbars_status_height(b);

  /* The '4' accounts for the bottom window frame of the toolbars */

  if (offset) offset += wimpt_dy();

  if (!b->ancestor) offset += b->leading; /* Only put a gap at the top for base browsers, not for frames */

  return -offset;
}

/*************************************************/
/* reformat_text_line_height()                   */
/*                                               */
/* Works out how tall a line of text should be,  */
/* returning the height above and below the      */
/* notional text baseline in OS units.           */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the line;             */
/*                                               */
/*             Pointer to an HStream which is    */
/*             used to determine what font the   */
/*             line would use;                   */
/*                                               */
/*             Pointer to an int, in which the   */
/*             height above the baseline is      */
/*             written;                          */
/*                                               */
/*             Pointer to an int, in which the   */
/*             height below the baseline is      */
/*             written.                          */
/*                                               */
/* Assumes:    Either int pointer may be NULL.   */
/*             If the HStream pointer is NULL, a */
/*             value based on the base (normal)  */
/*             font size will be used.           */
/*************************************************/

static _kernel_oserror * reformat_text_line_height(browser_data * b, HStream * tp, int * top, int * bot)
{
  int  h;
  int  rettop, retbot;
  BBox box;

  if (tp) h = fm_find_token_font(b, tp, 1);
  else    h = fm_find_font(b, "serif", choices.font_size, choices.font_size, 0, 0);

//  {
//     int face, size, italic, bold, scale;

  RetError(fm_font_box(h, &box));

  /* We know the font is 'size' 16ths, so we can work */
  /* out the line spacing from this. Don't use the    */
  /* font metrics - otherwise, bold text (say) will   */
  /* force the line spacing higher than plain.        */

  rettop = box.ymax - ((b->page_is_text && !choices.system_font) ? b->leading * 2 : 0);
  retbot = -box.ymin + b->leading;

//     fm_token_font_info(tp, &face, &size, &italic, &bold);
//
//     bot = b->leading;
//
//     convert_to_points(1, &scale);
//     top += (size * 1000) / (16 * scale);

  if (top) *top = rettop;
  if (bot) *bot = retbot;

  return NULL;
}

/*************************************************/
/* reformat_check_height()                       */
/*                                               */
/* Looks at the contents of a reformat_line      */
/* structure and ensures that it's y coordinate, */
/* height and font baseline offset fields are    */
/* correctly filled in.                          */
/*                                               */
/* Parameters: 1 for all external callers, but   */
/*             will be 0 if it calls itself      */
/*             internally;                       */
/*                                               */
/*             Pointer to a browser_data struct  */
/*             relevant to the line;             */
/*                                               */
/*             Pointer to a reformat_cell struct */
/*             that the line lies in;            */
/*                                               */
/*             Number of the line to alter;      */
/*                                               */
/*             Pointer to the token that may     */
/*             cause the line height to alter;   */
/*                                               */
/*             Pointer to the last token dealt   */
/*             with by the reformatter;          */
/*                                               */
/*             Offset into the current token's   */
/*             data.                             */
/*                                               */
/* Returns:    Fills in bits of the line struct, */
/*             as mentioned above.               */
/*************************************************/

static _kernel_oserror * reformat_check_height(int toplevel, browser_data * b, reformat_cell * d, int line, HStream * tp, HStream * tpLast, int offset)
{
  _kernel_oserror * e;
  int               top     = 0;
  int               bot     = 0;
  int               setpara = 0; /* Flags that a paragraph break should be added later on */

  if (!d) d = b->cell;

  /* Some initial white space calculations. All these rely on the */
  /* item being at the start of a paragraph - 'offset' is zero.   */

  if (!offset)
  {
    /* If the token represents a line break, include a gap, unless */
    /* we're at the top of a page / cell or just after a LI tag.   */

    if (
         line > 0              &&
         !(tpLast->style & LI) &&
         (tp->style & P)
       )
       setpara = 1;

    /* Alternatively, if the indent has changed, insert some */
    /* space above the item (but don't do this for UL and DL */
    /* items, as these are handled more carefully later).    */

    else if (
              tpLast                       &&
              tpLast->indent != tp->indent &&
              !(tp->style & UL)            &&
              !(tp->style & DL)
            )
            setpara = 1;

    /* The next few require text before them to gain a gap, or if */
    /* the last tag was BR and the tag before that was text, the  */
    /* gaps can still be added as BR just breaks the line.        */

    else if (
              tpLast &&
              (
                (tpLast->style & PCDATA) ||
                (
                  (tpLast->tagno == TAG_BR)      &&
                  tpLast->prev                   &&
                  (tpLast->prev->style & PCDATA)
                )
              )
            )
    {
      /* Want a space above UL items */

      if (tp->style & UL) setpara = 1;

      /* If a header type has changed, and we are dealing with a */
      /* text token, insert a gap above the item to push it away */
      /* either from the text above or from the header above.    */

      else if (
                (tp->style & PCDATA) &&
                redraw_header(tp->style) != redraw_header(tpLast->style)
              )
              setpara = 1;

      /* If we're about to enter a definition list, the 'spaces if */
      /* indent changes' code above will make the spaces look odd  */
      /* unless we also give a space above the first item in the   */
      /* definition list (the DT elements are not indented, so no  */
      /* white space would have been inserted so far).             */

      else if (tp->style & DL) setpara = 1;
    }
  }

  /* If flagged to do so, set 'top' for an initial paragraph break */

  if (setpara)
  {
    int texttop, textbot;

    RetError(reformat_text_line_height(b,
                                       NULL,
                                       &texttop,
                                       &textbot));

    top = ((texttop + textbot) * 7) >> 3;
  }

  /* BRs - a single BR between bits of text will force a new line and be the     */
  /* first token in the new line, but will then have other tokens in that same   */
  /* line. It should not alter the line height itself under these circumstances. */
  /* However, two consecutive BRs should - that is, when the second is found, it */
  /* should force a P-style break, and so-on for all subsequent BRs. It is also  */
  /* the case that a BR at the top of a page / cell should similarly force a     */
  /* paragraph-like break.                                                       */

  {
    HStream * fol; /* First On Line */

    fol = d->cdata[d->ldata[line].chunks].t;

    if (
         (fol->tagno == TAG_BR) &&
         (
           (
             fol->prev &&
             (fol->prev->tagno == TAG_BR)
           )
           || line == 0
         )
       )
    {
      int texttop, textbot;

      RetError(reformat_text_line_height(b,
                                         tp,
                                         &texttop,
                                         &textbot));

      top = texttop + textbot;
    }
  }

  /* Find out the height of an image */

  if (
       (tp->style & IMG) ||
       (
         tp->tagno         == TAG_INPUT &&
         HtmlINPUTtype(tp) == inputtype_IMAGE
       )
     )
  {
    BBox box;

    RetError(reformat_get_image_size(b, tp, &box));

    top +=  box.ymax;
    bot  = -box.ymin;
  }

  /* Deal with OBJECT, APPLET and EMBED tags */

  else if (ISOBJECT(tp))
  {
    BBox box;

    RetError(reformat_get_object_size(b, tp, &box));

    top += box.ymax;
    bot  = -box.ymin;
  }

  /* Size of a horizontal rule; the rule is plotted */
  /* centred vertically within its bounding box so  */
  /* there is no need to set both bot and top to    */
  /* the same value. With top = 0, setting bot is   */
  /* enough.                                        */

  else if (tp->style & HR)
  {
    int size;

    /* Deal with a (vertical) size specifier */

    if (HR_HAS_SIZE(tp))
    {
      /* (Only recognise pixels at present) */

      switch (HR_SIZE_UNITS(tp))
      {
        case UNITS_PIXELS: size = HR_SIZE(tp) * 2; break;

        default: size = 4; break;
      }
    }
    else size = 4;

    if (size < 24) size = 24;

    bot = size + 4;
  }

  /* A few easy to work out forms elements */

  else if (
            tp->tagno         == TAG_INPUT &&
            HtmlINPUTtype(tp) == inputtype_CHECKBOX
          )
  {
    int size;

    read_sprite_size("fopton", NULL, &size);
    top += size - 8;
    bot = 8;
  }

  else if (
            tp->tagno         == TAG_INPUT &&
            HtmlINPUTtype(tp) == inputtype_RADIO
          )
  {
    int size;

    read_sprite_size("fradioon", NULL, &size);
    top += size - 8;
    bot = 8;
  }

  /* Height of a bullet point */

  else if (ISBULLET(tp))
  {
    top += reformat_bullet_height(tp->indent);
  }

  else if (tp->tagno == TAG_TABLE)
  {
    /* Don't do anything! h is already correct */

    tp = tp; /* Make sure the compiler gets the if..else if.. etc. right */
  }

  /* If the above matches aren't found, use a more general routine */

  else
  {
    /* Get the bounding box of the font that should be used for the token */
    /* if we've got some text, and we're either a visible forms element   */
    /* or the text consists of more than one single space.                */

    if (
         (
           (tp->style & FORM)        &&
           tp->tagno != TAG_FORM     &&
           tp->tagno != TAG_FORM_END &&
           HtmlINPUTtype(tp) != inputtype_HIDDEN
         )
         ||
         (
           (tp->text) &&
           (
             tp->text[0] &&
             !
             (
               tp->text[0] == ' '  &&
               tp->text[1] == '\0'
             )
           )
         )
       )
    {
      int texttop, textbot;

      RetError(reformat_text_line_height(b,
                                         tp,
                                         &texttop,
                                         &textbot));

      top += texttop;
      bot =  textbot;
    }
  }

  /* Work out height of various forms elements */

  if (tp->tagno == TAG_TEXTAREA)
  {
    /* Text areas, based on the number of rows */

    BBox box;
    int  h;
    int  r;
    int  lh, lb;

    h = fm_find_token_font(b, tp, 0);
    e = fm_font_box(h, &box);
    if (e) return e;

    r = tp->rows;
    if (r < 2) r = 2;

    form_get_linesize(&box, &lh, &lb);

    bot += lh * (r - 1) + 8; /* + 8 for the border; r - 1 as bot is already below the first text line, so drop it by (rows - 1) more  */
    top += 8;
  }
  else if (tp->tagno == TAG_SELECT)
  {
    /* Selection lists - a pop-up menu icon */

    int h;

    if (read_sprite_size("fgright", NULL, &h)) h = 44;

    bot += 8;
    top += 8;

    if (top + bot < h) top += h - top - bot;
  }
  else if (tp->tagno == TAG_INPUT)
  {
    /* General input types */

    switch(HtmlINPUTtype(tp))
    {
      case inputtype_TEXT: /* No break - same as PASSWORD */
      case inputtype_PASSWORD:
      {
        bot += 8;
        top += 8;
      }
      break;

      case inputtype_SUBMIT: /* No break - same as RESET */
      case inputtype_BUTTON: /* Again, no break          */
      case inputtype_RESET:
      {
        bot += 8;
        top += 12;
      }
      break;
    }
  }

  /* Round up top and bot to a multiple of 4 */

  if (top & 3) top += 4 - (top & 3);
  if (bot & 3) bot += 4 - (bot & 3);

  /* 'top' will correspond to the line height above the font baseline. */
  /* If it is greater than the current value, extend the top of the    */
  /* line by the difference. Move the line y coordinate down to make   */
  /* room for the extra height.                                        */

  if (top > (d->ldata[line].h - d->ldata[line].b))
  {
    int diff;

    diff = top - (d->ldata[line].h - d->ldata[line].b);

    d->ldata[line].h += diff;
    d->ldata[line].y -= diff;
  }

  /* Similarly, if bot is greater than the offset of the baseline from */
  /* the bottom of the line, account for the extra offset.             */

  if (bot > d->ldata[line].b)
  {
    int diff;

    diff = bot - d->ldata[line].b;

    d->ldata[line].h += diff; /* (Since 'h' is the total height above and below the baseline) */
    d->ldata[line].b += diff;
    d->ldata[line].y -= diff;
  }

  return NULL;
}

/*************************************************/
/* reformat_check_visited()                      */
/*                                               */
/* Looks at a given token and compares it to the */
/* global history, setting a bit in the flags    */
/* word if a link it represents has been visited */
/* before.                                       */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the token;            */
/*                                               */
/*             Pointer to the token.             */
/*************************************************/

static void reformat_check_visited(browser_data * b, HStream * token)
{
  if (ISLINK(token) && history_visited(token->anchor)) token->flags |= HFlags_LinkVisited;
}

/*************************************************/
/* reformat_check_extent()                       */
/*                                               */
/* Sets the browser window vertical extent to    */
/* match the page, by looking at the last line   */
/* in the line list.                             */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             holding details of the window to  */
/*             alter.                            */
/*************************************************/

_kernel_oserror * reformat_check_extent(browser_data * b)
{
  /* Nothing to do for small fetch windows */

  if (b->small_fetch) return NULL;

  /* Otherwise exit through the extent setting routines */

  return reformat_set_extent(b, -reformat_return_extent(b, NULL));
}

/*************************************************/
/* reformat_return_extent()                      */
/*                                               */
/* Returns the height of a page in OS units,     */
/* according to its current formatted state.     */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             holding details of the page;      */
/*                                               */
/*             Pointer to a reformat_cell struct */
/*             holding redraw information.       */
/*************************************************/

int reformat_return_extent(browser_data * b, reformat_cell * cell)
{
  int extent = 0;

  if (!cell) cell = b->cell;

  if (cell->ldata) extent = -cell->ldata[cell->nlines - 1].y;

  return extent;
}

/*************************************************/
/* reformat_set_extent()                         */
/*                                               */
/* Sets the browser window vertical extent. The  */
/* extent can only ever grow.                    */
/*                                               */
/* Parameters: A pointer to a browser_data       */
/*             structure containing details of   */
/*             the window to alter;              */
/*                                               */
/*             A new vertical extent in OS units */
/*             - this is a *negative* number,    */
/*             expressed as a downward offset    */
/*             from the top of the window.       */
/*************************************************/

_kernel_oserror * reformat_set_extent(browser_data * b, int y_extent)
{
  WimpGetWindowStateBlock s;
  BBox                    new_extent;
  int                     hbot, width;

  #ifdef TRACE
    if (tl & (1u<<8)) Printf("\nreformat_set_extent: Called, -y_extent = %d\n",-y_extent);
  #endif

  /* For windows with frames, don't want to mess around with the extent */

  if (b->nchildren) return NULL;

  s.window_handle = b->window_handle;
  RetError(wimp_get_window_state(&s));

  /* Y extent is set to the requested value plus an amount for the toolbars */
  /* and an extra amount for aesthetics.                                    */

  if (!controls.swap_bars) hbot = toolbars_status_height(b);
  else                     hbot = toolbars_button_height(b) + toolbars_url_height(b);

  y_extent -= (hbot + b->leading);

  /* Ensure that the extent is at least as great as the minimum height */

  if ((-y_extent) < b->min_height) y_extent = -(b->min_height);

  /* For the height, don't want to resize below the current */
  /* visible height. Things are a bit messy due to the      */
  /* negative signs on extent, etc.                         */

  if ((-y_extent) < (s.visible_area.ymax - s.visible_area.ymin)) y_extent = -(s.visible_area.ymax - s.visible_area.ymin);

  new_extent.ymax = 0;
  new_extent.ymin = y_extent;

  /* x extent must only match or be larger than the visible */
  /* area, never smaller.                                   */

  width = s.visible_area.xmax - s.visible_area.xmin;

  if (b->display_width < width) b->display_width = width;
  if (b->display_extent < b->display_width) b->display_extent = b->display_width;

  new_extent.xmin = 0;
  new_extent.xmax = b->display_extent;

  /* Update height, too */

  {
    int h1, h2;

    h1 = toolbars_button_height(b) + toolbars_url_height(b);
    h2 = toolbars_status_height(b);

    if (h1) h1 += wimpt_dy();
    if (h2) h2 += wimpt_dy();

    b->display_height = s.visible_area.ymax - s.visible_area.ymin - h1 - h2;
  }

  /* Set the extent */

  RetError(window_set_extent(0,b->self_id,&new_extent));

  /* Can't set extent so visible area is now outside the work area; */
  /* call wimp_open_window to make sure scroll positions are OK.    */

  {
    ObjectId    po;
    ComponentId pc;

    RetError(toolbox_get_parent(0, b->self_id, &po, &pc));

    return toolbox_show_object(0, b->self_id, 1, (void *) &s.visible_area, po, pc);
  }
}

/*************************************************/
/* reformat_add_line()                           */
/*                                               */
/* Adds a line to the array of line structures.  */
/* The contents are NOT initialised.             */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the page;             */
/*                                               */
/*             Pointer to the reformat_cell      */
/*             structure to add the chunks to.   */
/*************************************************/

static _kernel_oserror * reformat_add_line(browser_data * b, reformat_cell * cell)
{
  _kernel_oserror * e;

  #ifdef TRACE
    if (tl & (1u<<8)) Printf("reformat_add_line: Called with cell %p, cell->nlines = %d\n",cell,cell->nlines);
  #endif

  /* Allocate memory for the new number of lines */

  #ifdef TRACE
    if (tl & (1u<<12)) Printf("reformat_add_line: Chunk CK_LINE set to %d\n",(cell->nlines + 1) * sizeof(reformat_line));
  #endif

  e = memory_set_chunk_size(b,
                            cell,
                            !cell->table ? CK_LINE : CK_LINV, /* Variable granularity allocation for table cells */
                            (cell->nlines + 1) * sizeof(reformat_line));
  if (e) return e;

  /* Increment the line counter in the browser_data structure */

  cell->ldata[cell->nlines].x = cell->ldata[cell->nlines].y = 0;

  cell->nlines++;

//  memset( - something! - ,0,sizeof(reformat_line));

  #ifdef TRACE
    if (tl & (1u<<8)) Printf("reformat_add_line: Successful with cell->nlines = %d\n",cell->nlines);
  #endif

  return NULL;
}

/*************************************************/
/* reformat_add_line_chunk()                     */
/*                                               */
/* Adds a line chunk to the array of line chunks */
/* associated with a particular line structure.  */
/* This is complicated slightly by the variable  */
/* length of the arrays of line chunks. The new  */
/* chunk's contents are NOT initialised.         */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the page;             */
/*                                               */
/*             Pointer to the reformat_cell      */
/*             structure to add the chunks to.   */
/*************************************************/

static _kernel_oserror * reformat_add_line_chunk(browser_data * b, reformat_cell * cell)
{
  int               size, cline = cell->nlines - 1;
  _kernel_oserror * e;

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

  /* The function can only ever add a chunk to the end of the list. */
  /* So the chunk must belong to the last line in the list, and     */
  /* if it is the first chunk for the line structure that line      */
  /* structure's pointer to the chunks will be filled in. The chunk */
  /* counter for that line is incremented.                          */

  #ifdef TRACE
    /* If there are no lines, we can't proceed - something has gone wrong */

    if (!cell->nlines)
    {
      erb.errnum = 0;

      strcpy(erb.errmess,
             "Serious internal error - There are no line structures defined in reformat_add_line_chunk; must exit immediately.");
      show_error(&erb);
    }
  #endif

  /* If there is no chunk data already, this is the first   */
  /* chunk allocation so the block size we want to move to  */
  /* is easy to work out.                                   */

  if (!cell->cdata) size = sizeof(reformat_line_chunk);
  else
  {
    /* We want to find the current size of data and put it into size. To do this, */
    /* get the last line's offset to the chunks and add the number of chunks it   */
    /* claims to have multiplied by the size of one chunk. The complication is    */
    /* that the last line(s) may not have any chunks, so we need to go back to    */
    /* a line that does, if that is the case.                                     */

    while (!cell->ldata[cline].n && cline >= 0) cline --;

    #ifdef TRACE
      if (cline < 0)
      {
        erb.errnum = 0;

        strcpy(erb.errmess,
               "Serious internal error - No lines have associated chunks defined in reformat_add_line_chunk; must exit immediately.");
        show_error(&erb);
      }
    #endif

    size = (cell->ldata[cline].chunks +
            cell->ldata[cline].n + 1) *
            sizeof(reformat_line_chunk);
  }

  // if (cell->cdata) Printf("!! Consistency check - Current block size for chunks  = %p\n",(void *) flex_size((flex_ptr) &cell->cdata));
  // else Printf("!! Consistency check - Current block size for chunks  = none allocated\n");
  // Printf("!!                     New block size to be allocated = %p\n",(void *) size);

  /* Now allocate the memory */

  #ifdef TRACE
    if (tl & (1u<<12)) Printf("reformat_add_line_chunk: Chunk CK_LDAT set to %d\n",size);
  #endif

  e = memory_set_chunk_size(b,
                            cell,
                            !cell->table ? CK_LDAT : CK_LDAV, /* Variable granularity allocation for table cells */
                            size);
  if (e) return e;

  /* Update the chunk counter on the last line and the base chunk */
  /* array number, if it wasn't already set (when the line is     */
  /* created, the chunks field is filled with -1. When the first  */
  /* chunk is added for the line the chunks field is filled in,   */
  /* and it is left alone subsequently - which is exactly what we */
  /* want, as the chunks field holds the base array index of the  */
  /* chunks for the line, not the last chunk array index.         */

  cline = cell->nlines - 1;
  cell->ldata[cline].n++;
  if (cell->ldata[cline].chunks < 0) cell->ldata[cline].chunks = (int) size / sizeof(reformat_line_chunk) - 1;

  /* Success */

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

  return NULL;
}

/*************************************************/
/* reformat_reformatter()                        */
/*                                               */
/* The actual working end of the reformat        */
/* routines - takes the list of HStream structs  */
/* (or tokens) and turns them into reformat_line */
/* structures for the redraw routines etc.       */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             containing all the info on the    */
/*             fetch for which reformatting is   */
/*             to take place.                    */
/*************************************************/

void reformat_reformatter(browser_data * b)
{
  reformat_reformatter_r(0, b, b->cell, b->stream);

  /* The browser may have the input focus inside a forms */
  /* item, so after each loop of the reformatter ask the */
  /* forms library to ensure the caret position is OK.   */

  form_caret_may_need_moving(b);
}

/*************************************************/
/* reformat_reformatter_r()                      */
/*                                               */
/* Recursive back-end to reformat_reformatter.   */
/*                                               */
/* Parameters: Flags (see Reformat.h);           */
/*                                               */
/*             Pointer to a browser_data struct  */
/*             relevant to the reformat session; */
/*                                               */
/*             Pointer to the reformat_cell      */
/*             struct that is to be acted upon;  */
/*                                               */
/*             Pointer to the first token in the */
/*             list of HStreams to use if there  */
/*             is no evidence of a previous      */
/*             incomplete reformat session in    */
/*             the browser_data structure.       */
/*                                               */
/* Returns:    Width of the widest line that was */
/*             generated, in millipoints. This   */
/*             includes the left hand margin /   */
/*             gap; however, if there is no      */
/*             stream to reformat, 0 is returned */
/*             rather than purely the left hand  */
/*             margin plus zero to indicate this */
/*             special case to the caller.       */
/*             Ideally the caller should never   */
/*             invoke the reformatter without a  */
/*             stream though, it's not very      */
/*             efficient...                      */
/*************************************************/

static int reformat_reformatter_r(unsigned int flags, browser_data * b, reformat_cell * d, HStream * streambase)
{
  int                   lnCurr        = -1;
  int                   cnCurr        = -1;
  int                   cnLast        = 0;
  _kernel_oserror     * e             = NULL;
  HStream             * tpCurr        = NULL, * tpLast   = NULL;
  HStream             * tnCurr        = NULL, * tnLast   = NULL;
  int                   bottom        = 0,      extent   = 0;
  int                   newlines      = 0,      newline  = 0;
  int                   newchunks     = 0,      newchunk = 0;
  int                   done          = 0;
  int                   linewidth     = 0;
  int                   widest        = 0;
  int                   offset        = 0;
  reformat_width_data   wd;
  int                   displaywidth, left_margin, right_margin;
  int                   toplevel, doall, fromstart, noalloc;
  int                   token_has_text;

  /* Read various flags */

  toplevel  = !(flags & Reformatter_KeepGoingToEnd); /* (This may get more complex, hence 'doall' is not just '!toplevel') */
  doall     = (flags & Reformatter_KeepGoingToEnd);
  fromstart = (flags & Reformatter_FromStreamStart);

  if (doall) noalloc = (flags & Reformatter_Virtual);
  else       noalloc = 0;

  /* If there is more than one line, find the y coordinate */
  /* of the last one and put it into 'bottom'              */

  if      (d->nlines > 2)  bottom = d->ldata[d->nlines - 2].y;
  else if (d->nlines == 1) bottom = d->ldata[0].y;

  /* This y coordinate is for the last line, so it also gives the vertical extent */

  extent = bottom;

  /* Work out the current width to format to, in millipoints. */
  /* The width is the size of the visible area, but not less  */
  /* than min_width.                                          */

  if      (flags & Reformatter_FindingWidest)   displaywidth = Reformat_AsWideAsPossible_MP;
  else if (flags & Reformatter_FindingSmallest) displaywidth = 1600;
  else convert_to_points(redraw_display_width(b, d), &displaywidth);

  if (d->nlines && !noalloc)
  {
    /* If there are some lines, set up the local variables */
    /* according to the last line's contents.              */

    int i;

    /* Set lnCurr to the last line, and set cnLast to the first chunk */
    /* number on that line. Note that if the line has no chunks, the  */
    /* routine steps back one. The function will exit if it turns out */
    /* that the first line has no chunks (after all, there's nothing  */
    /* to format if this is the case!)                                */

    lnCurr = d->nlines - 1;

    while (!d->ldata[lnCurr].n && lnCurr >= 0) lnCurr --;
    if (lnCurr < 0) return 0;

    cnLast = d->ldata[lnCurr].chunks;

    /* Get the address of the HStream associated with the */
    /* first chunk of the last line into tpLast.          */

    tpLast = d->cdata[cnLast].t;

//    /* Since the current tag is be at the start of this line,   */
//    /* strip out any preceeding spaces in it (the function      */
//    /* deals with the special case of preformatted text, etc.). */
//
//    reformat_strip_prespace(b, cnCurr, tpCurr);

    /* Set 'linewidth' to the indentation requried at this line, */
    /* and add the widths of the line chunks to this.            */

    linewidth = redraw_left_gap(b, d, tpLast);

    for (
          i = 0;
          i < d->ldata[lnCurr].n;
          i++, cnLast++
        )
        linewidth += d->cdata[cnLast].w;

    if (linewidth > widest) widest = linewidth;

    /* If the current line has at least 1 chunk... */

    if (d->ldata[lnCurr].n)
    {
      /* Set cnLast to now hold the number of the last chunk for the */
      /* last line, and tpCurr and tpLast to hold the address of the */
      /* token associated with the chunk.                            */

      cnLast = d->ldata[lnCurr].n + d->ldata[lnCurr].chunks - 1;
      tnCurr = tnLast = tpCurr = tpLast = d->cdata[cnLast].t;

      /* Set 'offset' to the offset into the token associated with the last */
      /* chunk in the last line, plus the amount of data to take from that  */
      /* token - i.e. it points to the first unused byte in that token,     */
      /* as far as the last chunk of the last line is concerned.            */

      offset = d->cdata[cnLast].o + d->cdata[cnLast].l;

      /* If the number of bytes into the token is <=0, then find out the */
      /* total size of data normally associated with the token (e.g. the */
      /* string length of any text it points to) and put this in offset. */

      if (d->cdata[cnLast].l <= 0)
      {
        /* In this case associated data will *almost* always be zero length, */
        /* in terms of text, but there are some rare circumstances when it   */
        /* won't be. Hence the reformat_datasize call.                       */

        offset = reformat_datasize(tpLast);
      }

      /* If the tag represents text, points to a text string, and that text */
      /* string terminates in a new line character, then need to start on a */
      /* new line.                                                          */

      if (
           offset > 0                       &&
           reformat_istext(tpCurr)          &&
           tpCurr->text                     &&
           tpCurr->text[offset - 1] == '\n'
         )
         newline = 1;
    }
    else newchunk = 1; /* Otherwise, flag that a chunk needs adding */
  }

  /* There are no line structures currently present; we aren't, then, */
  /* going to add to an existing line and need to flag that a new     */
  /* line must be created before chunks can be added.                 */

  else newline = 1;

  /* Loop round the reformatter whilst there is no error, the reformat */
  /* hasn't completed (we are still reformatting and the 'done' flag   */
  /* isn't set), and the number of new lines dealt with is less than   */
  /* 10 (don't want to do too much in one go, or the Desktop will      */
  /* feel very jerky) or we haven't flagged a new line is needed - the */
  /* reformat will only keep going for a certain number of lines, but  */
  /* won't stop mid-line.                                              */

  while (
          !e    &&
          !done &&
          (
            doall         ||
            newlines < 10 ||
            !newline
          )
          && reformat_formatting(b)
        )
  {
    /* tpCurr points the the token we're currently dealing with. If */
    /* this is NULL, or the offset into that token seems to point   */
    /* past its associated data, we've finished with the token. So  */
    /* move onto another, or if there are no more, set 'done' to 1. */

    if (tpCurr) token_has_text = tpCurr->text ? reformat_istext(tpCurr) : 0;
    else        token_has_text = 0;

    // Used to be 'if (!tpCurr || offset >= reformat_datasize(tpCurr))'
    // Really should check that the below never differs from it.

    if (!token_has_text || offset < 0 || !tpCurr->text[offset])
    {
      /* Record the last token that was dealt with in the browser_data structure */

      if (!fromstart) b->last_token = tnLast;

      /* Advance to the next token after that last one */

      if (tpLast) tnCurr = tnLast->next;
      else        tnCurr = streambase;

      /* Proceed if we haven't just run out of tokens */

      if (tnCurr && (tnCurr->flags & HFlags_DealtWithToken))
      {
        tpCurr = tnCurr;

        /* If this token isn't of any use to the reformatter (it */
        /* might correspond to header information rather than    */
        /* body text, say), keep getting new tokens until they   */
        /* are useful or we run out. If we run out, set 'done'   */
        /* again to show that the tokens have all been dealt     */
        /* with.                                                 */

        while (
                tpCurr                                  &&
                (tpCurr->flags & HFlags_DealtWithToken) &&
                reformat_useless_token(tpCurr))
        {
          if (!fromstart) b->last_token = tpCurr; /* Update the record of the last token dealt with */
          tnCurr = tpCurr = tpCurr->next;         /* Get the pointer to the new token               */
        }

        /* If we've ended up off the end of the token list (tpCurr is */
        /* NULL) or on a token that the fetcher hasn't dealt with yet */
        /* (the HFlags_DealtWithToken bit in the flags word is unset) */
        /* then signal that the reformatter should exit by setting    */
        /* 'done' to 1.                                               */

        if (!tpCurr) done = 1;
        else
        {
          if (!(tpCurr->flags & HFlags_DealtWithToken))
          {
            b->last_token = tpCurr->prev;
            tpCurr        = NULL;
            tnCurr        = NULL;
            done          = 1;
          }
        }

        /* Offset is set to 0 to show this is a new token, and we haven't */
        /* dealt with any of the data in it yet.                          */

        offset = 0;
      }

      /* The current token number was greater than the number of tokens - */
      /* we've run out of tokens, so flag that this in 'done'.            */

      else done = 1;
    }

    /* Continue with the reformat if it hasn't been flagged as finished through 'done'. */

    if (!done)
    {
      /* The left hand margin - zero for horizontal rules, which can span the whole     */
      /* display (their actual visible extent is determined by the redraw routine);     */
      /* else equal to the result of redraw_left_gap in Redraw.c (converted to points). */

      left_margin = redraw_left_gap(b, d, tpCurr);

      /* Can't have a margin greater than display width, but this consideration */
      /* only applies if we're not finding the smallest the stream can be.      */

      if (!(flags & Reformatter_FindingSmallest) && left_margin > displaywidth) left_margin = 0;

      /* The right hand gap value */

      right_margin = redraw_right_gap(b, d, tpCurr);

      /* Can't have margins greater than the display width */

      if (left_margin + right_margin > displaywidth) right_margin = 0;

//      /* If the text is not preformatted and the line width has gone over */
//      /* over the available display width, flag that a new line is needed */
//
      if (!newline && !(tpCurr->style & PRE) && linewidth > displaywidth - right_margin) newline = 1;

      /* If the difference between the current and last tags say we should */
      /* put in a line break, flag this in newline.                        */

      if (!newline && reformat_newline(tpCurr,tpLast,offset)) newline = 1;

      /* Right, if newline is set, create a new line. */

      if (newline)
      {
        int y = 0;

        newline  = 0;
        newchunk = 1;
        newlines ++;

        if (!noalloc)
        {
          /* Set y to hold the y coordinate the line is to be placed */
          /* at. This will either be determined by the previous      */
          /* line's y coordinate or if there are no lines, the       */
          /* toolbars and aesthetic lead-in considerations. The line */
          /* at this stage is of zero height; as it's height grows,  */
          /* the y value worked out here has the height subtracted   */
          /* from it to get the actual line position.                */

          if (lnCurr >= 0) y = d->ldata[lnCurr].y;

          /* (The 4 is to allow for the window frame of the toolbars) */

          else y = toplevel ? reformat_y_offset(b) : 0;

          /* If there aren't any new chunks, the bottom line hasn't */
          /* changed so set bottom to y; this stops the unchanged   */
          /* line being redrawn.                                    */

          if (!newchunks) bottom = y;

          /* Add the new line structure */

          e = reformat_add_line(b, d);
        }
        else e = NULL;

        /* If the addition was successful, fill in various details */

        if (!e)
        {
          tpCurr = tnCurr;
          tpLast = tnLast;

          if (!noalloc)
          {
            /* Advance the current line number in lnCurr to this new line */

            lnCurr = d->nlines - 1;

            /* Set the line height as zero, and baseline offset as zero. We */
            /* have no contents with which to do anything different yet.    */
            /* Changing 'b' will move the font baseline relative to the     */
            /* line base, and force the line height up. 'h' is the line     */
            /* height total including the baseline offset.                  */
            /*                                                              */
            /* When reformat_check_height is called, it will go through     */
            /* working out values called 'top' and 'bot'. The first is the  */
            /* amount by which the line height above the baseline (i.e.     */
            /* ...[...].h - ...[...].b) is to be extended; the second is    */
            /* the amount by which the space below the baseline is to be    */
            /* extended. These can thus be played about with to do vertical */
            /* alignment on images and so-forth.                            */

            d->ldata[lnCurr].h = 0;
            d->ldata[lnCurr].y = y;
            d->ldata[lnCurr].b = 0;

            /* The line has no chunks associated with it yet. */

            d->ldata[lnCurr].n      = 0;
            d->ldata[lnCurr].chunks = -1;
          }

          /* In light of this new line, set linewidth back to just the left margin,  */
          /* as there are no previous chunks to consider in working out chunk widths */
          /* in the add chunk code below.                                            */

          linewidth = left_margin;

          if (linewidth > widest) widest = linewidth;
        }

      /* End of newline check; if newline != 0, a new line is added to the line structure array. */
      }

      /* If there's no error, continue with the reformat procedure. */

      if (!e)
      {
        int available;

//        /* If the image has a known width and height, the reformatter is  */
//        /* about to deal with it - so the image library can mark it as    */
//        /* redrawable now (otherwise, for delayed reformats, some images  */
//        /* which were cross referenced and did not have reformat sessions */
//        /* explicitly started for them, may get stuck in a                */
//        /* 'non-redrawable' state).                                       */
//        /*                                                                */
//        /* Important to call this *before* trying to find the item height */
//        /* or width, as the image size routines will lie about the real   */
//        /* size if they think the item is not redrawable because it has   */
//        /* not be reformatted yet - chicken and egg...                    */
//
//        // Mmm, nice. And robust too. Or Your Money Back (TM).
//        //
//        // Really *must* do something about this (but probably won't...)
//
//        if (
//             (tpCurr->style & IMG) ||
//             (
//               tpCurr->tagno         == TAG_INPUT &&
//               HtmlINPUTtype(tpCurr) == inputtype_IMAGE
//             )
//           )
//           image_token_check_redrawable(b, tpCurr);

        /* If the image has a known width and height, the reformatter */
        /* has dealt with it; so both mark it as redrawable, and lock */
        /* its size down.                                             */

        image_token_reformatted(b, tpCurr);

        /* Fill in the reformat_width_data structure */

        wd.b      = b;
        wd.d      = d;
        wd.tp     = tpCurr;
        wd.data   = reformat_istext(tpCurr) ? tpCurr->text : NULL;
        wd.offset = offset;

        /* Tables, when specifying percentage widths, take up the whole */
        /* page - e.g. 100% when in an indented list will result in the */
        /* right hand edge of the table being off the page. Well, this  */
        /* is what MSIE / NN do anyway, despite it being stupid IMHO.   */

        if (tpCurr->tagno == TAG_TABLE && (TABLE_HAS_WIDTH((table_stream *) tpCurr)))
        {
          available = displaywidth - redraw_left_margin(b, d) - right_margin;
        }
        else
        {
          available = displaywidth - linewidth - right_margin;
        }

        /* The maximum width is 'very large' for preformatted text (effectively limitless).  */
        /* Similarly, for any text items in NOBR, the width in effect is without a limit.    */
        /* For other tokens, the left hand edge is at an indent equal to the left hand       */
        /* margin plus the summed widths of preceeding chunks (this is kept in 'linewidth'), */
        /* so the width is the available display width minus this left hand value.           */

        wd.maxwid = (
                      (
                        (tpCurr->style & PRE) &&
                        reformat_istext(tpCurr)
                      )

                      #ifdef SUPPORT_NOBR
                        ||
                        (
                          (tpCurr->style & PCDATA) &&
                          (tpCurr->style & NOBR)
                        )
                      #endif

                    )

                    ?

                    Reformat_AsWideAsPossible_MP : available;

        if (wd.maxwid < 0) wd.maxwid = 0;

        /* Set the (returned) bytes and width fields to zero initially */

        wd.bytes = wd.width = 0;

        /* Find out the width */

        e = reformat_token_width(&wd, flags);

        /* Adjust the line height for tables based on */
        /* the data from the above call               */

        if (tpCurr->tagno == TAG_TABLE)
        {
          if (!noalloc)
          {
            /* Take the height in millipoints (overloaded into wd.bytes) and use */
            /* this as the line height.                                          */

            convert_to_os(wd.bytes, &d->ldata[lnCurr].h);

            /* Correct the line's y coordinate given the above height. */

            d->ldata[lnCurr].y -= d->ldata[lnCurr].h;

            /* P tags before tables get attached to the TABLE HStream itself. */

            if ((tpCurr->style & P) && (lnCurr > 0))
            {
              int texttop, textbot;

              e = reformat_text_line_height(b, NULL, &texttop, &textbot);

              if (!e) d->ldata[lnCurr].y -= texttop + textbot;
            }
          }

          wd.bytes = 0;
        }

        /* If the chunk width'd and defined by the above call ends in a newline character, */
        /* flag a line break is needed through newline = 1.                                */

        else if (reformat_istext(tpCurr) && wd.bytes && wd.data[wd.offset + wd.bytes - 1] == '\n') newline = 1;
      }

      /* A new chunk is forced by setting 'newchunk' if the previous item and this one    */
      /* should not be split up. For example, an LI bullet point and the text that        */
      /* follows it (if any) should appear on the same line.                              */

      if (!e && !newchunk)
      {
        if (
             !offset                    &&
             tpCurr->prev               &&
             !(tpCurr->style & LI)      &&
             (tpCurr->prev->style & LI)
           )
           newchunk = 1;
      }

      /* Proceed if there is no error, to add a chunk. If the current line has no chunks, */
      /* then one will always be added. If there are already chunks present, another is   */
      /* added only if it will fit in the display (wd.width is less than wd.maxwid), or   */
      /* if the text is preformatted (in which case you keep adding chunks until there's  */
      /* a line break in the source).                                                     */

      if (
           !e &&
           (
             newchunk              || /* Will be set if current line has no chunks yet */
             wd.width <= wd.maxwid ||
             (tpCurr->style & PRE)
           )
         )
      {
        newchunk = 0;
        newchunks ++;

        if (!noalloc) e = reformat_add_line_chunk(b, d);
        else          e = NULL;

        /* Proceed if the above didn't return an error */

        if (!e)
        {
          tpCurr = tnCurr;
          tpLast = tnLast;

          if (!noalloc)
          {
            /* Set cnCurr to the array index of the last (i.e new) chunk; */
            /* we know that if a new chunk has been added the last line   */
            /* must have at least the one chunk now, so no need for all   */
            /* the checking for various cases of lines not having chunks  */
            /* that has gone on elsewhere.                                */

            cnCurr = d->ldata[d->nlines - 1].chunks + d->ldata[d->nlines - 1].n - 1;

            /* Fill in the new line chunk */

            d->cdata[cnCurr].t = tpCurr;
            d->cdata[cnCurr].w = wd.width;
            d->cdata[cnCurr].o = offset;
            d->cdata[cnCurr].l = wd.bytes;

            /* If this holds an image, need to invalidate the x and y position */
            /* information that the redraw routines set up, as it may have     */
            /* moved. The new position will be set when the reformatted        */
            /* region is next redrawn.                                         */

            if (
                 (tpCurr->style & IMG) ||
                 (
                   tpCurr->tagno         == TAG_INPUT &&
                   HtmlINPUTtype(tpCurr) == inputtype_IMAGE
                 )
               )
               image_set_token_image_position(b, tpCurr, -1, -1);

            #ifdef TRACE
              if ((tl & (1u<<20)) && tpCurr->tagno == TAG_TABLE) Printf("reformat_reformatter_r: Added a table\n");
            #endif

//            if (d->ldata[d->nlines - 1].n == 1)
//            {
//              /* Since the current chunk will be at the start of a new line, */
//              /* strip out any preceeding spaces in it (the function deals   */
//              /* with the special case of preformatted text, etc.).          */
//
//              reformat_strip_prespace(b, cnCurr, tpCurr);
//            }

//            if (d->ldata[d->nlines - 1].n == 1)
//            {
//              if (tpCurr->text && !(tpCurr->style & PRE))
//              {
//                while (*(tpCurr->text + d->cdata[cnCurr].o) == ' ' && d->cdata[cnCurr].l) d->cdata[cnCurr].o++, d->cdata[cnCurr].l--, offset++;
//              }
//            }


            /* Set the Visited flag if this token is a link and is in the global History */

            reformat_check_visited(b, tpCurr);

            /* Ensure the line's height details are updated in light of the new chunk */

            e = reformat_check_height(toplevel, b, d, lnCurr, tpCurr, tpLast, offset);
          }
          else e = NULL;

          if (!e)
          {
            int w;

//            if (!noalloc)
//            {
//              /* If a form had input focus, hopefully the forms library can now find */
//              /* the caret. This call will check if the token we're dealing with is  */
//              /* the currently editing one, and if so try to find its position and   */
//              /* move the caret as necessary. We do this only if 'noalloc' is unset, */
//              /* as if we're a 'virtual reformat loop', the token won't necessarily  */
//              /* have presence in any lines anyway. It might not be found if noalloc */
//              /* is unset anyway, but at least we increase the chances...            */
//
//              form_caret_may_be_moving(b, tnCurr);
//            }

            /* Advance through the token data */

            if (wd.bytes <= 0) offset = -1; /* Flag we need a new token */
            else
            {
              int has_text;

              offset += wd.bytes;

              /* Need a new line if we've not run off the end of the text - */
              /* there must have been a split point within it. This is not  */
              /* true, though, if NOBR is set.                              */

              if (tpCurr) has_text = tpCurr->text ? reformat_istext(tpCurr) : 0;
              else        has_text = 0;

              #ifdef SUPPORT_NOBR
                if (has_text && tpCurr->text[offset] && !(tpCurr->style & NOBR)) newline = 1;
              #else
                if (has_text && tpCurr->text[offset]) newline = 1;
              #endif
            }

            /* Make the last poken pointer is now updated */

            tnLast = tnCurr;
            tpLast = tpCurr;

            /* Add the chunk's width to the line width total */

            linewidth += wd.width;

            if (linewidth > widest) widest = linewidth;

            /* Convert the width to OS units and compare to the minimum width for */
            /* the browser so far. If the width as gone up, i.e. there is an      */
            /* enforced minimum for whatever reason (preformatted text, say) then */
            /* update the minimum width field appropriately.                      */

            convert_to_os(linewidth, &w);

            if (linewidth >= displaywidth - right_margin)
            {
              /* ...But shouldn't flag a new line if NOBR is set... */

              #ifdef SUPPORT_NOBR
                if (!(tpCurr->style & 0*NOBR)) newline = 1;
              #else
                newline = 1;
              #endif

              if (!d->table && w > b->display_extent) b->display_extent = w;
            }
          }
        }
      }
      else newline = 1;
    }
  }

  /* If there has been an error, stop the reformat and report it */

  if (e)
  {
    reformat_stop(b);
    show_error_ret(e); /* This call returns to this point rather than jumping to the poll loop */
  }
  else
  {
    browser_data * ancestor = utils_ancestor(b);

    /* For keyboard control, try to find something to select. */
    /* Browser windows that have children can't have visible  */
    /* tokens, so don't bother for them, and for anything     */
    /* with a selected item, check that it has't acquired     */
    /* children over the reformat - if it has, move the       */
    /* selection out of there.                                */

    if (choices.keyboard_ctrl)
    {
      /* Clear the selection if the owner has acquired children */

      if (ancestor->selected)
      {
        browser_data * owner = ancestor->selected_owner;

        if (owner && owner->nchildren) browser_clear_selection(owner, 0);
      }

      /* If there is no selection (whether this is due to the */
      /* above code or not), and the current browser has no   */
      /* children, try to select something in it.             */

      if (!ancestor->selected && !b->nchildren)
      {
        ancestor->selected = browser_find_first_selectable(b, NULL, 0);

        if (ancestor->selected) ancestor->selected_owner = b;
      }
    }
  }

  /* Make sure the window is the right size and ensure */
  /* that the altered regions are redrawn, unless      */
  /* we are printing (so the reformat doesn't actually */
  /* correspond to any real window).                   */

  if (toplevel && !printing)
  {
    reformat_check_extent(b);
    browser_update_bottom(b, bottom + 4);
  }

  /* Return the width of the widest line generated in this session, in millipoints */

  return widest;
}

/*************************************************/
/* reformat_format_cell()                        */
/*                                               */
/* Reformats a specific table cell to a given    */
/* width.                                        */
/*                                               */
/* Parameters: 1 for a top level call, 0 if      */
/*             being called as part of a nested  */
/*             table parse;                      */
/*                                               */
/*             Pointer to a browser_data struct  */
/*             relevant to the table;            */
/*                                               */
/*             Pointer to the first HStream      */
/*             structure in the stream that will */
/*             be formatted into the cell;       */
/*                                               */
/*             Pointer to the table_stream       */
/*             struct representing the table;    */
/*                                               */
/*             Pointer to the table's array of   */
/*             reformat_cell structures;         */
/*                                               */
/*             Allowed cell (column) width, in   */
/*             millipoints;                      */
/*                                               */
/*             Row number of the cell;           */
/*                                               */
/*             Column number of the cell.        */
/*                                               */
/* Returns:    Actual final cell width in        */
/*             millipoints.                      */
/*************************************************/

int reformat_format_cell(int toplevel, browser_data * b, HStream * streambase, table_stream * table,
                         reformat_cell * cellarray, int ColWidth, int Row, int Column)
{
  int             dheight;
  int             cellindex = Row * table->ColSpan + Column;
  reformat_cell * c;

  /* Can't do anything if the cell index is out of range */

  if (cellindex >= table->RowSpan * table->ColSpan) return 1600;
  else c = &cellarray[cellindex];

  #ifdef TRACE
    if (tl & (1u<<20))
    {
      Printf("tables_width_cell: %p %d %d %d %d\n",streambase,ColWidth,table->ColSpan,Row,Column);
      Printf("tables_width_cell in: %d\n", ColWidth / 400);
    }
  #endif

  /* Format the cell to the specified width. If 'toplevel' is 0, this is */
  /* being called as part of a format for a parent table, so don't       */
  /* generate lines (flag Virtual in the reformatter). Otherwise, allow  */
  /* line generation (don't flag Virtual).                               */

  c->width = c->cellwidth = ColWidth;

  if (c->width <= 400) c->width = 400; /* Give at least 1 OS unit to avoid possible problems in the reformatter */

  reformat_reformatter_r(Reformatter_KeepGoingToEnd            |
                         Reformatter_FromStreamStart           |
                         (toplevel ? Reformatter_Virtual : 0),

                         b,
                         c,
                         streambase);

  /* Set the height to the line list extent, rounded down to an */
  /* integer number of pixels.                                  */

  dheight = reformat_return_extent(b, c) & ~(wimpt_dy() - 1);

  /* Convert to millipoints for storing in the cell */

  convert_to_points(dheight, &c->height);

  #ifdef TRACE
    if (tl & (1u<<20))
    {
      Printf("width found is %d\n", c->width);
      Printf("height found is %d\n",c->height);
    }
  #endif

  return c->width;
}

/*************************************************/
/* reformat_find_cell_limits()                   */
/*                                               */
/* Works out the narrowest and widest widths a   */
/* given table cell could be, in millipoints.    */
/*                                               */
/* Parameters: 1 for a top level call, 0 if      */
/*             being called as part of a nested  */
/*             table parse;                      */
/*                                               */
/*             Pointer to a browser_data struct  */
/*             relevant to the table;            */
/*                                               */
/*             Pointer to the first HStream      */
/*             structure in the stream that the  */
/*             cell is to contain;               */
/*                                               */
/*             Pointer to the table_stream       */
/*             struct representing the table;    */
/*                                               */
/*             Pointer to the table's array of   */
/*             reformat_cell structures;         */
/*                                               */
/*             Row number of the cell;           */
/*                                               */
/*             Column number of the cell;        */
/*                                               */
/*             Pointer to an int, in which the   */
/*             minimum width is returned;        */
/*                                               */
/*             Pointer to an int, in which the   */
/*             maximum width is returned;        */
/*************************************************/

void reformat_find_cell_limits(int toplevel, browser_data * b, HStream * streambase, table_stream * table,
                               reformat_cell * cellarray, int Row, int Column, int * retmin, int * retmax)
{
  int             maxwidth  = 0;
  int             minwidth  = 0;
  int             cellindex = Row * table->ColSpan + Column;
  reformat_cell * c;

  /* Can't find the limits of something outside the cell range */
  /* of the table...                                           */

  if (cellindex >= table->RowSpan * table->ColSpan)
  {
    if (retmin) *retmin = 1600;
    if (retmax) *retmax = 1600;

    return;
  }
  else c = &cellarray[cellindex];

  /* If we've already got values for this cell, return them now */

  if (c->minwid >= 0 && c->maxwid >= 0)
  {
    if (retmin) *retmin = c->minwid;
    if (retmax) *retmax = c->maxwid;

    return;
  }

  if (streambase)
  {
    /* Find the maximum width used by the cell; first, reformat */
    /* to a 'large width' (effectively, no line breaks).        */

    maxwidth = reformat_reformatter_r(Reformatter_KeepGoingToEnd  |
                                      Reformatter_FindingWidest   |
                                      Reformatter_FromStreamStart |
                                      Reformatter_Virtual,

                                      b,
                                      c,
                                      streambase);

    #ifdef TRACE
      if (c->nlines || c->ldata || c->cdata)
      {
        erb.errnum = Utils_Error_Custom_Normal;

        strcpy(erb.errmess,"Line or chunk data allocated inside reformat_find_cell_limits for maxwidth check");

        show_error_ret(&erb);
      }
    #endif

    /* Find the minimum width */

    minwidth = reformat_reformatter_r(Reformatter_KeepGoingToEnd  |
                                      Reformatter_FindingSmallest |
                                      Reformatter_FromStreamStart |
                                      Reformatter_Virtual,

                                      b,
                                      c,
                                      streambase);

    #ifdef TRACE
      if (c->nlines || c->ldata || c->cdata)
      {
        erb.errnum = Utils_Error_Custom_Normal;

        strcpy(erb.errmess,"Line or chunk data allocated inside reformat_find_cell_limits for minwidth check");

        show_error_ret(&erb);
      }
    #endif
  }
  else minwidth = maxwidth = redraw_left_margin(b, c);

  /* Account for cellpadding */

  {
    int cellpadmp = table->cellpadding * 2;  /* 1 'web pixel' = 2 OS units, but only for right hand edge - redraw_left_margin takes care of the rest */

    convert_to_points(cellpadmp, &cellpadmp);

    minwidth += cellpadmp;
    maxwidth += cellpadmp;
  }

  /* Store the values */

  c->minwid = minwidth;
  c->maxwid = maxwidth;

  if (retmin) *retmin = minwidth;
  if (retmax) *retmax = maxwidth;

  /* Finished */

  return;
}

/*************************************************/
/* reformat_change_text()                        */
/*                                               */
/* Used to alter text in a tag, to provide (for  */
/* example) smart quotes handling.               */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             with information on the fetch     */
/*             Pointer to a token to alter.      */
/*                                               */
/* Assumes:    The browser_data struct may not   */
/*             be NULL, but the token pointer    */
/*             can be and the token does not     */
/*             have to contain text.             */
/*************************************************/

void reformat_change_text(browser_data * b, HStream * tp)
{
// Note that this, then, does nothing right now - fix this function up some time!

  return;

  if (tp && tp->text && !(tp->style & TT) && (reformat_istext(tp)))
  {
    char * curr = tp->text;

    while (*curr)
    {
      if (*curr == '`') *curr = 148; /* Always make this quote an opening quote */

      if (*curr == '\'') /* Dumb single quote */
      {
        if   (b->last_char == ' '
           || b->last_char == '('
           || b->last_char == 148  /* Opening double quote */
           || b->last_char == '\"')

             *curr = 144; /* Opening single quote */
        else *curr = 145; /* Closing single quote */
      }
      else if (*curr == '\"') /* Dumb double quote */
      {
        if   (b->last_char == ' '
           || b->last_char == '('
           || b->last_char == 144  /* Opening single quote */
           || b->last_char == '\''
           || b->last_char == '`')

             *curr = 148; /* Opening double quote */
        else *curr = 149; /* Closing double quote */
      }
      else if (*curr == '-' && b->last_char == ' ') *curr = 151; /* 'en' dash */
//      else if (*curr == '-' && b->last_char == 151) memmove - something!

      b->last_char = *curr;
      curr ++;
    }
  }

  /* If we have ALT text for an image, strip off any preceeding */
  /* spaces or [s, and any trailing spaces or ]s.               */

  else if (
            tp       &&
            tp->text &&
            (
              (tp->style & IMG) ||
              (
                tp->tagno         == TAG_INPUT &&
                HtmlINPUTtype(tp) == inputtype_IMAGE
              )
            )
          )
  {
    char * start, * end;
    char   last;
    int    len;

    len = strlen(tp->text);

    /* Get rid of preceeding characters */

    start = tp->text;
    end   = tp->text + len - 1;

    while (*start == ' ' || *start == '[') start ++;

    /* If there's anything left... */

    if (*start)
    {
      /* Get rid of trailing characters */

      while (*end == ' ' || *end == ']')
      {
        *end = '\0';
        end --;
      }
    }

    /* If there's still something left, move the */
    /* string contents down so tp->text points   */
    /* past the stripped preceeding chracters.   */

    if (start <= end) memmove(tp->text, start, strlen(start) + 1); /* 'strlen + 1' to get the string terminator */
    else
    {
      /* If there was nothing left, did we originally have     */
      /* enough to put '[]' to mark that there's no text left? */

      if (len > 1) strcpy(tp->text,"[]");
    }

    /* Now do smart quotes substitution. Need to do this  */
    /* separately from the main text routines as the      */
    /* last_char variable must not be changed by ALT text */
    /* - it stands alone for each image.                  */

    last = ' ';
    start = tp->text;

    while (*start)
    {
      if (*start == '\'' || *start == '`') /* Dumb single quote */
      {
        if   (last == ' '
           || last == '('
           || last == 148  /* Opening double quote */
           || last == '\"')

             *start = 144; /* Opening single quote */
        else *start = 145; /* Closing single quote */
      }
      else if (*start == '\"') /* Dumb double quote */
      {
        if   (last == ' '
           || last == '('
           || last == 144  /* Opening single quote */
           || last == '\''
           || last == '`')

             *start = 148; /* Opening double quote */
        else *start = 149; /* Closing double quote */
      }
      else if (*start == '-' && last == ' ') *start = 151; /* 'en' dash */

      last = *start;
      start ++;
    }
  }
}