FontManage

/* 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   : FontManage.c                           */
/*                                                 */
/* Purpose: A range of font management veneers.    */
/*                                                 */
/* Author : Merlyn Kline for Customer browser     */
/*          This source adapted by A.D.Hodgkinson  */
/*                                                 */
/* History: 05-Dec-96: Created.                    */
/*          14-Apr-97: Merged in a bug fix to      */
/*                     fm_get_string_width spotted */
/*                     by T.Cheal (see source for  */
/*                     more info).                 */
/***************************************************/

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

#include "swis.h"

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

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

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

#include "Redraw.h"

#include "FontManage.h"

/* Conditional includes */

#ifdef UNIFONT
  #include "Unicode/iso10646.h"
  #include "Unicode/utf8.h"
  #include "Unifont.h"
#endif

#ifndef Font_WideFormat
  #define Font_WideFormat 0x400A9
#endif

/**************************************************************************************************/
/*                                                                                                */
/* Merlyn's original overview comments (corrected where necessary, due to changes in the source): */
/* ============================================================================================== */
/*                                                                                                */
/* RISC OS Font management                                                                        */
/*                                                                                                */
/* Merlyn Kline, 1995                                                                             */
/*                                                                                                */
/* This module provides a range of veneers for font management. It allows a typeface              */
/* to be defined including bold, italic and bold-italic attributes. These typefaces               */
/* are given names by which they are referred to in subsequent use. When defining a               */
/* typeface an alternative to be used can be specified for cases where the primary                */
/* selection is unavailable for some reason. If the alternative does not exist, *its*             */
/* alternative is checked. This goes on for several attempts (about 4) before giving              */
/* up after which the ordinary system font is used, scaled appropriately. This limit              */
/* on the number of attempts improves performance and means you don't have to worry too           */
/* much about defining loops (eg pairs of typefaces which specify each other as alternatives).    */
/*                                                                                                */
/* The system provides veneers for all font related functions and these use an internal           */
/* font handle. This font handle is either the RISC OS font handle when an appropriate            */
/* font was available or a negative number made up from the x and y font sizes.                   */
/*                                                                                                */
/* Note the use of the word 'typeface' to describe the four-font structure used by this           */
/* module. This is to avoid confusion with the RISC OS term 'font' underlying it.                 */
/*                                                                                                */
/* Typefaces are defined by passing strings to the font definition routine, which contain         */
/* a description of the desired font, like:                                                       */
/*                                                                                                */
/*    name=normal:italic:bold:bolditalic;alternative                                              */
/*                                                                                                */
/* where:                                                                                         */
/*                                                                                                */
/*    name         is the name you want to refer to this typeface by (case *sensitive* for speed) */
/*    normal       is the RISC OS font name to use in normal rendering                            */
/*    italic       is the RISC OS font name to use in italic rendering                            */
/*    bold         is the RISC OS font name to use in bold rendering                              */
/*    bolditalic   is the RISC OS font name to use in bold plus italic rendering                  */
/*    alternative  is the alternative typeface name to use if necessary                           */
/*                                                                                                */
/* Any of these fields may be missing except <name>. If the font names used for                   */
/* bold/italic rendering are missing, the normal one will be used instead. If                     */
/* the normal font name is missing, the alternative typface is used. If the                       */
/* alternative is missing, system font will be used when the requested fonts are                  */
/* not available.                                                                                 */
/*                                                                                                */
/* When defining typefaces for optimum performance define the one which will be used              */
/* most, last. This is because they are kept in a linked list and new ones are added to           */
/* the start of the list and so will be found more quickly.                                       */
/*                                                                                                */
/* If you define a typeface with the same name as an existing one the new definition              */
/* overwrites the old one.                                                                        */
/*                                                                                                */
/* Default font definitions are available as follows:                                             */
/*                                                                                                */
/*   system=System.Fixed:Corpus.Medium.Oblique:Corpus.Bold:Corpus.Bold.Oblique;fixed              */
/*   sans=Homerton.Medium:Homerton.Medium.Oblique:Homerton.Bold:Homerton.Bold.Oblique;serif       */
/*   serif=Trinity.Medium:Trinity.Medium.Italic:Trinity.Bold:Trinity.Bold.Italic;sans             */
/*   fixed=Corpus.Medium:Corpus.Medium.Oblique:Corpus.Bold:Corpus.Bold.Oblique                    */
/*                                                                                                */
/* Font sizes are defined in sixteenths of a point. The system font is treated as a font          */
/* with a 2:1 aspect ratio so set both xsize and ysize to the same to get normal looking text.    */
/* A size of 205 (=8*2*16*72/90 ie:                                                               */
/*                                                                                                */
/*    pixels * os_units_per_pixel * sixteenths_of_a _point_per_inch / os_units_per_inch )         */
/*                                                                                                */
/* will get system font at its normal size. This size should therefore be used for any display    */
/* of information where size is pretty arbitrary, ensuring a reasonable appearnce should system   */
/* font be used. To help, it is #defined as FM_Standard_Size in FontManage.h.                     */
/*                                                                                                */
/*                     ------------------------------------------------------                     */
/*                                                                                                */
/* (Merlyn then goes on to describe the font menu display and interpretation functions, which are */
/* more or less redundant in this source due to the Toolbox's automation).                        */
/*                                                                                                */
/* Note that some specialisation of the library for use in the browser has been necessary, so     */
/* for example references to browser_data structures would need to be removed were this version   */
/* of the library to be used elsewhere.                                                           */
/*                                                                                                */
/**************************************************************************************************/

/* Statics */

static fm_typeface * fm_new_typeface  (void);
static fm_face       fm_sub_find_font (fm_typeface * f, int xsize, int ysize, int italic, int bold);

static fm_facelist * fm_list       = NULL;
static int           fm_systemfont = 0;
static int           fm_allowblend = -1;

/* Locals */

/* fm_faces allows typeface numbers to be defined internally */
/* which relate to typeface names held by the font managing  */
/* routines; these are easier to deal with than strings.     */

char * fm_faces[] = {
                      "serif",
                      "sans",
                      "fixed"
                    };

/* fm_handles records usage of font handles. For every font  */
/* font claim, an appropriate bit is examined in the         */
/* browser_data structure of the claimant (if available). If */
/* the bit is unset, it is set and the entry in fm_handles   */
/* incremented by one. For every font discard, the bit is    */
/* examined again and if set, it is cleared, and the entry   */
/* in fm_handles decremented by one. If that entry is now    */
/* zero, Font_LoseFont is called for the handle.             */

int fm_handles[Limits_OS_FontHandles];

/* fm_sizes allows quick lookup of a font size number, which */
/* otherwise would needed to be calculated on the fly (this  */
/* is slow). Initialisation is done in fm_init, and the size */
/* is looked up through fm_size.                             */
/*                                                           */
/* Whilst fm_find_token_font scales using this, fm_find_font */
/* doesn't. For speed, it's quicker if the caller can do the */
/* scaling, if needed, when falling fm_find_font.            */

int fm_sizes[Limits_FontSizes + 1]; /* (Indices 1 to Limits_FontSizes are used, with index 0 */
                                    /* filled with base size in case something goes wrong    */
                                    /* and a size of 0 is given)                             */

/*************************************************/
/* fm_find_typeface()                            */
/*                                               */
/* Goes through the linked list of fm_facelist   */
/* structures looking for one which is named,    */
/* returning the address of the fm_typeface      */
/* structure containing that name if it is found */
/* (or NULL if not). The name should be in lower */
/* case charaters.                               */
/*                                               */
/* Parameters: A pointer to a string holding the */
/*             name of the typeface to find, in  */
/*             lower case.                       */
/*                                               */
/* Returns:    Pointer to the fm_typeface struct */
/*             if found, else NULL.              */
/*************************************************/

fm_typeface * fm_find_typeface(char * name)
{
  fm_facelist * f;

  /* Set f to point to the start of the list */
  /* of fm_facelist structures, and go up    */
  /* the list looking for the named font.    */
  /* Return the address of the fm_typeface   */
  /* structure itself (rather than the       */
  /* fm_facelist structure that contains it) */
  /* if found, NULL if not.                  */

  f = fm_list;

  while (f)
  {
    if (!strcmp(f->face.name, name)) return &f->face;
    f = f->next;
  }

  return NULL;
}

/*************************************************/
/* fm_new_typeface()                             */
/*                                               */
/* Adds a new typeface to the list of typefaces. */
/* Returns a pointer to the fm_typeface struct   */
/* itself, when added, or NULL if the malloc     */
/* claim failed (so error check this externally) */
/*                                               */
/* Returns:    Pointer to the new fm_typeface    */
/*             struct, or NULL if malloc failed. */
/*************************************************/

static fm_typeface * fm_new_typeface(void)
{
  fm_facelist * f;

  /* Allocate memory for the fm_facelist struct */

  #ifdef TRACE
    if (tl & (1u<<12)) Printf("fm_new_typeface: malloc %d for 'fm_facelist' structure\n",sizeof(fm_facelist));
  #endif

  f = calloc(1, sizeof(fm_facelist));

  if (f)
  {
    #ifdef TRACE
      malloccount += sizeof(fm_facelist);
      if (tl & (1u<<13)) Printf("** malloccount (fm_new_typeface): \0211%d\0217\n",malloccount);
    #endif

    /* If the claim succeeded, link the new item into */
    /* the list, and return with the address of the   */
    /* fm_typeface structure.                         */

    f->next = fm_list;
    fm_list = f;

    return &f->face;
  }

  /* The malloc claim failed, so return NULL */

  return NULL;
}

/*************************************************/
/* fm_define_typeface_explicit()                 */
/*                                               */
/* Adds a new fm_facelist structure to the list  */
/* of fm_facelist structures, but also names     */
/* the new typeface and only allocates a new     */
/* list item if one of the same name wasn't      */
/* already present.                              */
/*                                               */
/* Parameters: A pointer to an fm_typeface       */
/*             structure, in which only the      */
/*             'name' field is filled in. This   */
/*             becomes the name for the new      */
/*             typeface and is used to check if  */
/*             a typeface of that name is        */
/*             already present.                  */
/*************************************************/

_kernel_oserror * fm_define_typeface_explicit(fm_typeface * f)
{
  fm_typeface * fp;

  /* Try to find a typeface of the same name in the list */

  fp = fm_find_typeface(f->name);

  /* If there isn't one, create a new typeface entry */

  if (!fp) fp = fm_new_typeface();

  /* Report an error if the new typeface entry couldn't be created */

  if (!fp)
  {
    erb.errnum = Utils_Error_Custom_Fatal;

    StrNCpy0(erb.errmess,
             lookup_token("FontMem:There is not enough free memory for font handling (%0).",
                          0,
                          "1"));

    return(&erb);
  }

  /* Copy whole structure over to fp */

  *fp = *f;

  return(NULL);
}

/*************************************************/
/* fm_define_typeface()                          */
/*                                               */
/* This function defines a whole new typeface in */
/* full, according to a description string the   */
/* format of which is described in Merlyn's      */
/* comments at the top of this file.             */
/*                                               */
/* Parameters: A pointer to a string containing  */
/*             the typeface description.         */
/*************************************************/

_kernel_oserror * fm_define_typeface(char * description)
{
  fm_typeface   f;
  char        * p = description;
  int           i = 0;

  /* Ensure that the fm_typeface struct has been */
  /* allocated locally, then zero the contents   */

  f.name[0] = 0;
  memset(&f,0,sizeof(f));

  /* Travel through the description string looking for */
  /* an equals sign - this separates the name of the   */
  /* typeface from the actual RISC OS fonts it uses.   */
  /* Copy the text - which is the typeface name - into */
  /* the 'name' field of the new typeface structure    */
  /* that was filled with zeros above.                 */

  while ((*p) && (*p != '='))
  {
    if (i < (sizeof(f.name) - 1)) f.name[i++] = *p++;
  }

  /* If we're not now at the end of the string, get the */
  /* four RISC OS font names from the string.           */

  if (*p)
  {
    int n;

    for (n = 0; n < 4; n++)
    {
      p++; /* Skip past the =, : or ; that we last ended on */
      i=0;

      /* Copy between the current position and the next separator */
      /* (i.e. the font name) into the relevant fontname field of */
      /* the fm_typeface structure.                               */

      while ((*p) && (*p != ':') && (*p != ';'))
      {
        if (i < sizeof(f.fontnames[n]) - 1) f.fontnames[n][i++] = *p++;
      }

      /* If we've reached the end of the string or a ';', exit now */
      /* as there are no more font names.                          */

      if ((!*p) || (*p == ';')) break;
    }

    /* If there's a semicolon, there is an alternative typeface */
    /* name defined                                             */

    if (*p == ';')
    {
      p++; /* Skip past the ; */

      /* Copy the alternative typeface name to the fm_typeface struct */

      strncpy(f.alternative, p, sizeof(f.alternative) - 1);
    }
  }

  /* If there's at least one font name present, */
  /* actually allocate the memory for the       */
  /* typeface (or copy over an old one with the */
  /* same name).                                */

  if (f.name[0]) return fm_define_typeface_explicit(&f);

  /* There are no font names - the typeface is badly defined */

  erb.errnum = Utils_Error_Custom_Fatal;

  StrNCpy0(erb.errmess,
           lookup_token("BadType:Internal error - Bad typeface definition in %0.",
                        0,
                        "fm_define_typeface"));
  return &erb;
}

/*************************************************/
/* fm_define_default_typefaces()                 */
/*                                               */
/* Sets up the default typeface settings, for    */
/* system, fixed space, sans serif and serif     */
/* font 'banks'.                                 */
/*************************************************/

_kernel_oserror * fm_define_default_typefaces(void)
{
  /* These will be overridden if typefaces of the same name are read */
  /* in by load_choices later.                                       */

  RetError(fm_define_typeface("fixed=Corpus.Medium:Corpus.Medium.Oblique:Corpus.Bold:Corpus.Bold.Oblique"));
  RetError(fm_define_typeface("sans=Homerton.Medium:Homerton.Medium.Oblique:Homerton.Bold:Homerton.Bold.Oblique;serif"));
  RetError(fm_define_typeface("serif=Trinity.Medium:Trinity.Medium.Italic:Trinity.Bold:Trinity.Bold.Italic;sans"));

  return NULL;
}

/*************************************************/
/* fm_claim_basic_typefaces()                    */
/*                                               */
/* Claim a few basic fonts which will probably   */
/* be needed for the duration of the application */
/* run time.                                     */
/*                                               */
/* Parameters: Base font size to claim at.       */
/*************************************************/

void fm_claim_basic_typefaces(int base_size)
{
  fm_face h;

  #define FMCIncHandles(f) {                                              \
                             if (f >= 0)                                  \
                             {                                            \
                               if (!fm_handles[(f)]) fm_handles[(f)] = 1; \
                               else fm_lose_font(NULL, (f));              \
                             }                                            \
                           }

  if (!choices.system_font)
  {
    /* Need to be a bit careful here... Must not claim a font twice, if the */
    /* typeface is the same (e.g. System.Fixed for both fixed width normal  */
    /* and fixed width bold). The fm_handles array is an *internal* usage   */
    /* count - as far as the RISC OS Font Manager is concerned, for every   */
    /* font marked as used inside fm_handles, there's only one user in the  */
    /* browser. So if we claim something two or more times here, it'll only */
    /* get released once later on, thereby 'leaking' the font handle.       */

    h = fm_find_font(NULL, "sans",  base_size, base_size, 0, 0); FMCIncHandles(h)
    h = fm_find_font(NULL, "sans",  base_size, base_size, 0, 1); FMCIncHandles(h)
    h = fm_find_font(NULL, "sans",  base_size, base_size, 1, 0); FMCIncHandles(h)
    h = fm_find_font(NULL, "sans",  base_size, base_size, 1, 1); FMCIncHandles(h)

    h = fm_find_font(NULL, "serif", base_size, base_size, 0, 0); FMCIncHandles(h)
    h = fm_find_font(NULL, "serif", base_size, base_size, 1, 0); FMCIncHandles(h)
    h = fm_find_font(NULL, "serif", base_size, base_size, 0, 1); FMCIncHandles(h)
    h = fm_find_font(NULL, "serif", base_size, base_size, 1, 1); FMCIncHandles(h)

    h = fm_find_font(NULL, "fixed", base_size, base_size, 0, 0); FMCIncHandles(h)
    h = fm_find_font(NULL, "fixed", base_size, base_size, 0, 1); FMCIncHandles(h)
  }
}

/*************************************************/
/* fm_sub_find_font()                            */
/*                                               */
/* When asked for a standard, italic, bold or    */
/* bold italic variant of a typeface, this will  */
/* return the font handle for the requested font */
/* or -1 if it can't be found. The routine       */
/* will try for just a standard or bold variant  */
/* if an italic or bold italic variant isn't     */
/* defined, then drop to just standard, before   */
/* giving up.                                    */
/*                                               */
/* Parameters: Pointer to the fm_typeface struct */
/*             for the typeface in question;     */
/*                                               */
/*             The X and Y sizes, in 1/16ths of  */
/*             a point, of the font to claim;    */
/*                                               */
/*             1 to specify italics, else 0;     */
/*                                               */
/*             1 to specify bold, else 0.        */
/*                                               */
/* Returns:    The RISC OS font manager's font   */
/*             handle for the requested font (as */
/*             an fm_face) or -1 if the font     */
/*             couldn't be found either by this  */
/*             routine, or by the font manager   */
/*             itself.                           */
/*************************************************/

static fm_face fm_sub_find_font(fm_typeface * f, int xsize, int ysize, int italic, int bold)
{
  int        n;
  fm_face    h;

  /* Set bit 0 of n if italic was specified, and bit 1 */
  /* if bold was specified.                            */

  n=(italic ? 1 : 0) | (bold ? 2 : 0);

  /* So n = 0 for standard, 1 for italic, 2 for bold */
  /* and 3 for bold italic.                          */

  /* If there is no fontname defined for that combination, */
  /* AND n with 2 - i.e., drop the italic specifier and    */
  /* just try plain / bold.                                */

  if (!f->fontnames[n][0]) n &= 2;

  /* If there is still no font name, try the standard only */

  if (!f->fontnames[n][0]) n = 0;

  /* If there is *still* no font name, we can't match this */
  /* so flag that by returning -1.                         */

  if (!f->fontnames[n][0]) return -1;

  /* If the font manager can't find the font, again flag the */
  /* problem by returning -1. Otherwise, return the font     */
  /* handle returned by the font manager.                    */

  if (_swix(Font_FindFont,
            _INR(1,5) | _OUT(0),

            f->fontnames[n],     /* Font name to find    */
            xsize,               /* x size in 16ths pt   */
            ysize,               /* y size in 16ths pt   */
            180 / wimpt_dx(),    /* Current mode's x dpi */
            180 / wimpt_dy(),    /* Current mode's y dpi */

            &h))                 /* Font handle put in h */

            return -1;

  return h;
}

/*************************************************/
/* fm_size()                                     */
/*                                               */
/* Given an abstracted font size (from 1 to 7,   */
/* with 3 being 'base font' size), returns the   */
/* actual size (in 16ths of a point) to use.     */
/*                                               */
/* Parameters: The font size, from 1 to 7.       */
/*                                               */
/* Returns:    The equivalent font size, in      */
/*             16ths of a point.                 */
/*                                               */
/* Assumes:    For speed, the parameter is not   */
/*             limit checked, so if it falls     */
/*             outside the allowed range the     */
/*             returned value will be undefined  */
/*             and probably very inappropriate   */
/*             for a font size!                  */
/*************************************************/

int fm_size(int size)
{
  return fm_sizes[size];
}

/*************************************************/
/* fm_find_font()                                */
/*                                               */
/* Returns the font handle of a requested        */
/* typeface variant, optionally recording the    */
/* usage in a given browser_data structure.      */
/*                                               */
/* Parameters: Pointer to the browser_data       */
/*             struct relevant to the font;      */
/*                                               */
/*             Pointer to the typeface name;     */
/*                                               */
/*             X and Y sizes in 16ths of a pt;   */
/*                                               */
/*             1 for italics, 0 for not italic;  */
/*                                               */
/*             1 for bold, 0 for not bold.       */
/*                                               */
/* Returns:    A RISC OS font handle for the     */
/*             requested font or the closest     */
/*             available match to it; this may   */
/*             be the system font if no good     */
/*             match could be found.             */
/*                                               */
/* Assumes:    The browser_data struct pointer   */
/*             may be NULL.                      */
/*************************************************/

fm_face fm_find_font(browser_data * b, char * name, int xsize, int ysize, int italic, int bold)
{
  fm_typeface * f;
  fm_face       s,h;
  int           i;

  /* Work out the system font 'handle' for the given point size */

  s = FM_System_Handle(xsize,ysize); /* (Macro defined in FontManage.h) */

  /* If system font has been configured locally through the */
  /* fm_set_system_font function, return that handle now    */

  if (fm_systemfont) return s;

  /* The slower alternative - try to find the named typeface */

  f = fm_find_typeface(name);

  /* If it can't be found, return the system font */

  if (!f) return s;

  /* Get the RISC OS font handle for that typeface */

  h = fm_sub_find_font(f, xsize, ysize, italic, bold);

  /* If fm_sub_find_font returns -1, keep trying   */
  /* alternative typefaces as long as there are    */
  /* some defined, to a maximum of 4 alternatives. */

  for (
        i = 0;
        i < 3 && h < 0 && f->alternative[0];
        i++
      )
  {
    f = fm_find_typeface(f->alternative);
    if (!f) return s;
    h = fm_sub_find_font(f, xsize, ysize, italic, bold);
  }

  /* If we still haven't got a RISC OS font handle */
  /* return the system font handle.                */

  if (h < 0) return s;

  /* Success, eventually! */

  /* If the font has already been claimed (it has an entry in fm_handles) */
  /* don't want to keep the second claim caused by the Font_FindFont that */
  /* gave the handle. So, lose the font - we know that the Font Manager   */
  /* will still have a usage of at least 1 for the font as long as        */
  /* fm_handles has a non-zero usage count itself. This is somewhat       */
  /* inefficient, but otherwise, for every claimed font handle, the face  */
  /* name, style, and size would have to be recorded with it, and for     */
  /* every font claim these preclaimed fonts would need to checked        */
  /* through. This would end up being quite slow.                         */

  if (b && fm_handles[h]) _swix(Font_LoseFont, _IN(0), h);

  /* Record the usage of this font */

  if (b && !(Bitfield_Is_Set(&b->handles, h)))
  {
    fm_handles[h]++;
    Bitfield_Set_Bit(&b->handles, h);
  }

  return h;
}

/*************************************************/
/* fm_lose_font()                                */
/*                                               */
/* Forgets about the usage of a given font by a  */
/* given browser, and if there are no users at   */
/* this point, tell the RISC OS Font Manager     */
/* that the font is no longer in use.            */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the font;             */
/*                                               */
/*             The RISC OS font handle for the   */
/*             font to forget.                   */
/*                                               */
/* Assumes:    The pointer to the browser_data   */
/*             struct *may* be NULL, in which    */
/*             case the RISC OS Font Manager is  */
/*             told the font isn't needed        */
/*             straight away.                    */
/*************************************************/

void fm_lose_font(browser_data * b, fm_face h)
{
  if (h >= 0)
  {
    if (b)
    {
      if (Bitfield_Is_Set(&b->handles, h))
      {
        fm_handles[h]--;

        Bitfield_Clear_Bit(&b->handles, h);
      }

      if (!fm_handles[h]) _swix(Font_LoseFont,_IN(0),h);
      else if (fm_handles[h] < 0) fm_handles[h] = 0;
    }
    else _swix(Font_LoseFont,_IN(0),h);
  }
}

/*************************************************/
/* fm_lose_fonts()                               */
/*                                               */
/* Forgets about the usage of all fonts used by  */
/* a given browser, and if there are no longer   */
/* any users of any of the fonts, tells the      */
/* RISC OS Font Manager that those fonts are no  */
/* longer in use.                                */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the fonts.            */
/*************************************************/

void fm_lose_fonts(browser_data * b)
{
  int fh;

  for (fh = 0; fh < Limits_OS_FontHandles; fh++)
  {
    if (Bitfield_Is_Set(&b->handles, fh)) fm_lose_font(b, fh);
  }
}

/*************************************************/
/* fm_rescale_fonts()                            */
/*                                               */
/* For all currently claimed fonts, reclaim them */
/* with the current screen DPI. Useful for (say) */
/* mode changes, when the Desktop scaling may    */
/* have changed.                                 */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the fonts to rescale. */
/*************************************************/

_kernel_oserror * fm_rescale_fonts(browser_data * b)
{
  _kernel_oserror * e;
  browser_data      temp;
  int               fh, size, xsize, ysize;
  char              name[Limits_FontName];

  /* Can't lose and reclaim fonts within the same browser, */
  /* whilst scanning through its list of claimed fonts...  */
  /* if ever a font handle higher than the one just lost   */
  /* was returned, things would go very wrong. So copy     */
  /* the list of used fonts into a temporary store and use */
  /* this for the loses and claims, then copy that back to */
  /* the actual browser_data structure when finished.      */

  temp.handles = b->handles;

  /* Now loop round all the font handles */

  for (fh = 0; fh < Limits_OS_FontHandles; fh++)
  {
    /* If this font is claimed... */

    if (Bitfield_Is_Set(&b->handles, fh))
    {
      /* How much space does the font name need? */

      e = _swix(Font_ReadDefn,
                _INR(0,1) | _IN(3) | _OUT(2),

                fh,              /* Handle */
                0,               /* Return buffer size needed for name */
                Magic_Word_FULL, /* See MiscDefs.h */

                &size);

      if (e) return e;

      /* If the font name will fit, then get the name and size details */

      if (size < sizeof(name)) /* Not '<=' as need terminator */
      {
        int h;

        /* Fill the name buffer with zeros first, to ensure the */
        /* name string is correctly terminated.                 */

        memset(name, 0, sizeof(name));

        /* Now read the font information */

        e = _swix(Font_ReadDefn,
                  _INR(0,1) | _IN(3) | _OUTR(2,3),

                  fh,
                  name,
                  Magic_Word_FULL, /* See MiscDefs.h */

                  &xsize,
                  &ysize);

        if (e) return e;

        /* Lose the old font, and reclaim the same name and size */
        /* at a new resolution.                                  */

        fm_lose_font(&temp, fh);

        e = _swix(Font_FindFont,
                  _INR(1,5) | _OUT(0),

                  name,             /* Font name to find    */
                  xsize,            /* x size in 16ths pt   */
                  ysize,            /* y size in 16ths pt   */
                  180 / wimpt_dx(), /* Current mode's x dpi */
                  180 / wimpt_dy(), /* Current mode's y dpi */

                  &h);              /* Font handle put in h */

        if (e) return e;

        /* See fm_find_font for full comments on this bit, no need */
        /* to repeat it all here.                                  */

        if (fm_handles[h]) _swix(Font_LoseFont, _IN(0), h);

        /* Record the usage of this font */

        fm_handles[h]++;
        Bitfield_Set_Bit(&temp.handles, h);

      /* Closure of long 'if' to see if the font name would fit */
      /* in the allocated buffer. The code above executes if it */
      /* would.                                                 */
      }

    /* Closure of long 'if' to see if the current font handle */
    /* was claimed; the code above executes if it was.        */
    }

  /* Closure of 'for' loop going found all font handles. */
  }

  /* Copy the font usage information back to the actual browser. */

  b->handles = temp.handles;

  return NULL;
}

/*************************************************/
/* fm_font_box()                                 */
/*                                               */
/* Gets a bounding box large enough to cover any */
/* character in a given font, in OS units.       */
/*                                               */
/* Parameters: RISC OS font handle of the font;  */
/*                                               */
/*             Pointer to a BBox into which the  */
/*             bounding box is placed (min X and */
/*             Y are inclusive, max X and Y are  */
/*             exclusive).                       */
/*************************************************/

_kernel_oserror * fm_font_box(fm_face h, BBox * box)
{
  if (h < 0)
  {
    /* If we're passed a system font handle, */
    /* treat that as a special case.         */

    int xs,ys;

    xs = FM_System_Size_X(h); /* (Macros defined in FontManage.h) */
    ys = FM_System_Size_Y(h);

    /* The code is derived from this:        */
    /*                                       */
    /* box->xmin=0;                          */
    /* box->ymin=ys * (10 * -3) / (64 * 16); */
    /*                                       */
    /* box->xmax=xs * 10 / 128;              */
    /* box->ymax=ys * (10 * 13) / (64 * 16); */

    box->xmin = 0;
    box->ymin = (ys * -30) / (1024);

    box->xmax = (xs * 10) / 128;
    box->ymax = (ys * 130) / (1024);
  }
  else
  {
    /* Otherwise, ask the Font Manager for the bounding box */

    // this probably needs to a char by char scan of the font and cache the result

    return _swix(Font_ReadInfo,
                 _IN(0) | _OUTR(1,4),

                 h,            /* Handle                    */

                 &box->xmin,   /* Minimum X of bounding box */
                 &box->ymin,   /* Minimum Y of bounding box */
                 &box->xmax,   /* Maximum X of bounding box */
                 &box->ymax);  /* Maximum Y of bounding box */
  }

  return NULL;
}

/*************************************************/
/* fm_char_box()                                 */
/*                                               */
/* Gets the bounding box of a char, in OS units. */
/*                                               */
/* Parameters: RISC OS font handle of the font;  */
/*                                               */
/*             Character to measure;             */
/*                                               */
/*             Pointer to a BBox into which the  */
/*             bounding box is placed (min X and */
/*             Y are inclusive, max X and Y are  */
/*             exclusive).                       */
/*************************************************/

_kernel_oserror * fm_char_box(fm_face h, char c, BBox * box)
{
  /* Very similar structure to fm_font_box, so see that for */
  /* more comments.                                         */

  if (h < 0)
  {
    int xs,ys;

    xs = FM_System_Size_X(h);
    ys = FM_System_Size_Y(h);

    box->xmin = 0;
    box->ymin = (ys * -30) / (1024);

    box->xmax = (xs * 10) / 128;
    box->ymax = (ys * 130) / (1024);
  }
  else
  {
    #ifdef UNIFONT
      _swix(Font_WideFormat, _INR(0,1), h, 12);
    #endif

    return _swix(Font_CharBBox,
                 _INR(0,2) | _OUTR(1,4),

                 h,            /* Handle                    */
                 c,            /* Character                 */
                 FM_OSUnits,   /* Flags -> OS units, please */

                 &box->xmin,   /* Minimum X of bounding box */
                 &box->ymin,   /* Minimum Y of bounding box */
                 &box->xmax,   /* Maximum X of bounding box */
                 &box->ymax);  /* Maximum Y of bounding box */
  }

  return NULL;
}

/*************************************************/
/* fm_set_font_colour()                          */
/*                                               */
/* Sets the font colour for subsequent painting. */
/*                                               */
/* Parameters: The RISC OS font handle of the    */
/*             font in question;                 */
/*                                               */
/*             The foreground colour;            */
/*                                               */
/*             The background colour.            */
/*                                               */
/*             Colours are As palette entries,   */
/*             i.e. are in the form BBGGRRcc     */
/*             where cc = GCOL, else use the Red */
/*             Green and Blue bytes.             */
/*************************************************/

_kernel_oserror * fm_set_font_colour(fm_face h, int fore, int back)
{
  /* First, the system font case */

  if (h < 0)
  {
    #ifdef UNIFONT

      /* Need to set the background colour too */

      _swix(ColourTrans_SetGCOL,

                            _IN(0) | _INR(3,4),

                            fore,    /* Palette entry */
                            0x80,    /* Flags         */
                            0);      /* GCOL action   */

    #endif

    return _swix(ColourTrans_SetGCOL,
                          _IN(0) | _INR(3,4),

                          fore,    /* Palette entry */
                          0,       /* Flags         */
                          0);      /* GCOL action   */
  }
  else
  {
    /* Alternatively, deal with an outline font */

    return _swix(ColourTrans_SetFontColours,
                 _INR(0,3),

                 h,       /* Handle                            */
                 back,    /* Background colour palette entry   */
                 fore,    /* Foreground colour palette entry   */
                 14);     /* Maximum foreground colour offset  */
  }
}

/*************************************************/
/* fm_puts()                                     */
/*                                               */
/* Outputs a string in a given font at specified */
/* coordinates in a colour determined by calls   */
/* to fm_set_font_colour() prior to calling this */
/* function.                                     */
/*                                               */
/* Parameters: A RISC OS font handle;            */
/*                                               */
/*             X and Y coordinates of the bottom */
/*             left of the bounding box of the   */
/*             plotted string. These may be in   */
/*             OS units or millipoints (see      */
/*             below);                           */
/*                                               */
/*             Pointer to the string to output;  */
/*                                               */
/*             1 if using OS coords, else 0;     */
/*                                               */
/*             1 to use font blending, else 0 -  */
/*             do NOT use font blending on a     */
/*             Font Manager earlier than v3.37!  */
/*************************************************/

_kernel_oserror * fm_puts(fm_face h, int x, int y, const char * s, int os, int blend)
{
  #ifdef TRACE
    if (tl & (1u<<10)) Printf("\nfm_puts: Called with handle %p\n         String '%s'\n",(void *) h, s);
  #endif

  if (h < 0)
  {
    /* System font output */

    int xs,ys;

    if (!os) convert_pair_to_os(x, y, &x, &y);

    /* Work out the pixel size of the font; note that the */
    /* Y size is twice the X size for aesthetic reasons   */

    xs = FM_System_Size_X(h) * 10 / (128 * wimpt_dx());
    ys = FM_System_Size_Y(h) * 10 / (64  * wimpt_dy());

    /* Set the size and spacing */

    bbc_vduq(23,
             17,
             7,
             6,
             xs & 255,
             xs >> 8,
             ys & 255,
             ys >> 8,
             0,
             0);

    /* Move to the requested (converted) coordinates. 10/64 */
    /* converts to OS units, 13/16 is height above base     */

    bbc_move(x, y + (FM_System_Size_Y(h) * (10*13) / (64*16)) - 1);

    /* Output the string */

    #ifdef UNIFONT
      unifont_write0(s, x, y + (FM_System_Size_Y(h) * (10*13) / (64*16)) - 1, xs, ys);
    #else
      _swix(OS_Write0, _IN(0), s);
    #endif

    /* Set the text output size back (certainly get interesting */
    /* effects from Make if you don't do this...!)              */

    bbc_vduq(23,
             17,
             7,
             6,
             16 / wimpt_dx(),
             0,
             32 / wimpt_dy(),
             0,
             0,
             0);

    return NULL;
  }
  else
  {
    unsigned int flags;

    /* Outline font output */

    if (fm_allowblend < 0)
    {
      /* If we haven't already, check the Font Manager */
      /* version - for 3.37 or later, allow background */
      /* blending (fm_allowblend will set bit 11 of    */
      /* the flags for Font_Paint), else don't allow   */
      /* blending (earlier versions of the Font        */
      /* Manager will object strongly to bit 11 being  */
      /* set).                                         */

      int version;

      if (_swix(Font_CacheAddr,_OUT(0),&version)) version = 0;

      fm_allowblend = (version >= 337) ? FM_Blend : 0;
    }

    /* Paint the string. The parameters are a pointer to the string, */
    /* flags, and x and y coordinates. The flags have the blending   */
    /* set if asked for, specify absolute coordaintes, and tell the  */
    /* Font Manager whether x and y are OS units or millipoints.     */

    #ifdef TRACE
      if (tl & (1u<<10))
      {
        unsigned char * scan = (unsigned char *) s;

        while (*scan)
        {
          if (*scan < 32 && *scan != 10 && *scan != 13) Printf("fm_puts: Warning, non-CR/LF control char %d in string\n",(unsigned int) *scan);
          scan ++;
        }

        Printf("fm_puts: Calling Font_Paint prior to exiting\n");
      }
    #endif

    if (printing) flags = 0;
    else          flags = blend ? fm_allowblend : 0;

    flags |= (
               (FM_GivenHandle) |
               (FM_Kern)        |

               (os ? FM_OSUnits : 0)
             );

    #ifdef UNIFONT
      _swix(Font_WideFormat, _INR(0,1), h, 12);
    #endif

    return _swix(Font_Paint,
                 _INR(0,7),

                 h,
                 s,
                 flags,
                 x,
                 y,
                 NULL,NULL,0);
  }
}

/*************************************************/
/* fm_putsl()                                    */
/*                                               */
/* As fm_puts above, but takes an extra          */
/* parameter after the string pointer which says */
/* how many characters of the string should be   */
/* plotted.                                      */
/*                                               */
/* This will *write a character into the string* */
/* during operation, so the string must be owned */
/* by the caller and not in ROM.                 */
/*                                               */
/* Parameters: As fm_puts above, but after the   */
/*             pointer to the string to output,  */
/*             pass the number of characters in  */
/*             the string that will be plotted.  */
/*************************************************/

_kernel_oserror * fm_putsl(fm_face handle, int x, int y, char * s, int chars, int os, int blend)
{
  char              c;
  _kernel_oserror * e = NULL;

  /* If chars doesn't point past the end of the */
  /* string, then forcibly terminate it and     */
  /* call fm_puts. Restore the character that   */
  /* the terminator wrote over whther or not    */
  /* there is an error.                         */

  if (s[chars] != '\0')
  {
    c        = s[chars];
    s[chars] = '\0';

    e = fm_puts(handle,x,y,s,os,blend);

    s[chars] = c;
  }

  /* If the number of chars is longer than the */
  /* string, plot as much as there is of it.   */

  else e = fm_puts(handle,x,y,s,os,blend);

  return e;
}

/*************************************************/
/* fm_write_descriptor()                         */
/*                                               */
/* Writes the descriptor string for a typeface   */
/* into a given buffer.                          */
/*                                               */
/* Parameters: Pointer to the typeface name;     */
/*                                               */
/*             Pointer to the buffer.            */
/*                                               */
/* Assumes:    That the buffer is big enough.    */
/*************************************************/

_kernel_oserror * fm_write_descriptor(char * name, char * buffer)
{
  fm_typeface * f;

  /* Try to find the typeface */

  f = fm_find_typeface(name);

  /* If the typeface isn't found, give an error */

  if (!f)
  {
    erb.errnum = Utils_Error_Custom_Fatal;

    StrNCpy0(erb.errmess,
             lookup_token("BadTRef:Internal error - Reference to undefined typeface in %0.",
                          0,
                          "fm_write_descriptor"));
    return &erb;
  }

  /* Else fill in the buffer */

  sprintf(buffer,
          "%s=%s:%s:%s:%s;%s",
          f->name,
          f->fontnames[0],
          f->fontnames[1],
          f->fontnames[2],
          f->fontnames[3],
          f->alternative);

  return NULL;
}

/*************************************************/
/* fm_write_name()                               */
/*                                               */
/* Writes the RISC OS font name for a given      */
/* typeface variant to a given buffer            */
/*                                               */
/* Parameters: Typeface number from the fm_faces */
/*             array;                            */
/*                                               */
/*             Pointer to the buffer;            */
/*                                               */
/*             1 for italics, else 0;            */
/*                                               */
/*             1 for bold, else 0.               */
/*                                               */
/* Assumes:    That the buffer is big enough.    */
/*************************************************/

_kernel_oserror * fm_write_name(int number, char * buffer, int italic, int bold)
{
  fm_typeface * f;
  int           n;
  char        * name;

  if (number < 0 || number >= sizeof(fm_faces))
  {
    #ifdef TRACE

      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Illegal typeface number %d in fm_write_name.",
              number);

      return &erb;

    #endif

    return NULL;
  }
  else name = fm_faces[number];

  /* Index the correct font name using the bold and italic flags */

  n = (italic ? 1 : 0) | (bold ? 2 : 0);

  /* Try to find the typeface */

  f = fm_find_typeface(name);

  /* If the typeface isn't found, give an error */

  if (!f)
  {
    erb.errnum = Utils_Error_Custom_Fatal;

    StrNCpy0(erb.errmess,
             lookup_token("BadTRef:Internal error - Reference to undefined typeface in %0.",
                          0,
                          "fm_write_name"));
    return &erb;
  }

  /* Else fill in the buffer */

  sprintf(buffer,"%s",f->fontnames[n]);

  return NULL;
}

/*************************************************/
/* fm_read_typeface()                            */
/*                                               */
/* Given a typeface name inside an fm_typeface   */
/* structure, the rest of the typeface details   */
/* are filled in. If the typeface name isn't     */
/* found an error will be raised.                */
/*                                               */
/* Parameters: A pointer to the fm_typeface with */
/*             the name to look up inside its    */
/*             'name' field.                     */
/*************************************************/

_kernel_oserror * fm_read_typeface(fm_typeface * face)
{
  fm_typeface * f;

  /* Try to find the named typeface */

  f = fm_find_typeface(face->name);

  /* Raise an error if it can't be found */

  if (!f)
  {
    erb.errnum = Utils_Error_Custom_Fatal;

    StrNCpy0(erb.errmess,
             lookup_token("BadTRef:Internal error - Reference to undefined typeface in %0.",
                          0,
                          "fm_read_typeface"));
    return &erb;
  }

  /* Copy the found typeface contents across to the supplied typeface */

  *face = *f;

  return NULL;
}

/*************************************************/
/* fm_destroy_typefaces()                        */
/*                                               */
/* Destroys *all* typeface records, therefore    */
/* emptying the list of typefaces.               */
/*************************************************/

void fm_destroy_typefaces(void)
{
  fm_facelist * f, * c;

  /* Point f to the head of the list */

  f = fm_list;

  /* As long as f is non-null, there is a typeface. */
  /* Remember the typeface address and point f to   */
  /* the next item in the list; then free the       */
  /* typeface structure memory.                     */

  while(f)
  {
    c = f;
    f = f->next;

    #ifdef TRACE
      if (tl & (1u<<12)) Printf("fm_destroy_typefaces: free block %p, which held 'fm_facelist' structure\n",c);
      malloccount -= sizeof(fm_facelist);
      if (tl & (1u<<13)) Printf("** malloccount (fm_destroy_typefaces): \0212%d\0217\n",malloccount);
    #endif

    free(c);
  }

  /* Ensure that the list is flagged as empty. */

  fm_list=NULL;
}

/*************************************************/
/* fm_set_system_font()                          */
/*                                               */
/* Sets the static local flag to say that system */
/* fonts only should be used for font handling.  */
/* This will only affect any fonts claimed with  */
/* e.g. fm_find_font after this function has     */
/* been called.                                  */
/*                                               */
/* Parameters: 1 to use system font, 0 to allow  */
/*             outline fonts.                    */
/*************************************************/

void fm_set_system_font(int systemfont)
{
  fm_systemfont = systemfont;
}

/*************************************************/
/* fm_system_font()                              */
/*                                               */
/* Returns 1 if the font library is currently    */
/* using system font for any new font finds, or  */
/* 0 if outline fonts are allowed. This is       */
/* intended for external callers only (it is     */
/* faster to use the fm_systemfont variable      */
/* directly in internal routines).               */
/*************************************************/

int fm_system_font(void)
{
  return fm_systemfont;
}

/*************************************************/
/* fm_init()                                     */
/*                                               */
/* Initialises the library for use.              */
/*                                               */
/* Parameters: 1 if the library is to only use   */
/*             the system font from the outset,  */
/*             or 0 to allow outline fonts;      */
/*                                               */
/*             The 'base font' size, if going    */
/*             to use the fm_size function to    */
/*             allow an abstracted font size     */
/*             selection method (see fm_size).   */
/*************************************************/

void fm_init(int systemfont, int base_size)
{
  fm_destroy_typefaces();
  fm_set_system_font(systemfont);
  fm_init_sizes(base_size);
}

/*************************************************/
/* fm_init_sizes()                               */
/*                                               */
/* Sets up the size array for FONT SIZE=xxx and  */
/* related attributes, based on the given base   */
/* font size.                                    */
/*                                               */
/* Parameters: The 'base font' size.             */
/*************************************************/

void fm_init_sizes(int base_size)
{
  int size, scaleby;

  /* Set up the size array */

  fm_sizes[0] = base_size; /* Just in case 0 gets given to fm_size by accident - more likely than a large out of range value */

  for (size = 1; size <= 7; size ++)
  {
    scaleby        = size - 3;
    fm_sizes[size] = (int) (base_size * pow(1.2, scaleby));
  }
}

/*************************************************/
/* fm_shutdown()                                 */
/*                                               */
/* Tells the RISC OS Font Manager that all fonts */
/* currently marked as used in fm_handles are    */
/* not needed regardless of the internal usage   */
/* counter therein, and resets those counters to */
/* zero.                                         */
/*************************************************/

void fm_shutdown(void)
{
  int fh;

  for (fh = 0; fh < Limits_OS_FontHandles; fh++)
  {
    if (fm_handles[fh])
    {
      _swix(Font_LoseFont, _IN(0), fh);
      fm_handles[fh] = 0;
    }
  }
}

/*************************************************/
/* fm_get_string_width()                         */
/*                                               */
/* Given a string, and the number of chars to    */
/* consider in that string, work out the width   */
/* of the string. A maximum width can be given,  */
/* and if it is possible to split the string     */
/* (pass the character to split on), the width   */
/* returned will reflect this consideration (but */
/* can still be greater than maxwid, if no split */
/* characters were found for far enough). The    */
/* number of bytes used to work out the final    */
/* returned width is itself returned, though any */
/* trailing spaces are included in this value    */
/* even if they aren't used to get the width.    */
/*                                               */
/* Parameters: The RISC OS font handle to use in */
/*             width calculations;               */
/*                                               */
/*             Pointer to the string to use;     */
/*                                               */
/*             Maximum width to allow if         */
/*             splitting the line;               */
/*                                               */
/*             The maximum number of bytes of    */
/*             string to consider;               */
/*                                               */
/*             The character to split at (such   */
/*             as a space), or -1 for 'don't     */
/*             split';                           */
/*                                               */
/*             Pointer to an int, into which the */
/*             number of characters used to get  */
/*             the returned width is placed. Any */
/*             trailing spaces are skipped past  */
/*             and included in this returned     */
/*             value;                            */
/*                                               */
/*             Pointer to an int, into which the */
/*             calculated width (in millipoints) */
/*             is placed.                        */
/*                                               */
/* Assumes:    The two int pointers may be NULL. */
/*************************************************/

_kernel_oserror * fm_get_string_width(fm_face h, const char * s, int maxwid, int maxbytes,
                                      int split, int * bytes, int * width)
{
  int retwidth = 0;
  int retbytes = 0;

  /* Now have to do some real work. */

  if (h >= 0)
  {
    /* The outline font case */

    _kernel_oserror * e = NULL;
    int               buffer[9];
    int               reached;

    /* For Font_ScanString, negative values of maxwid will  */
    /* produce a positive return as it copes with RTL text. */
    /* We don't want this, so skip the call if maxwid <= 0. */

    #ifdef UNIFONT
      _swix(Font_WideFormat, _INR(0,1), h, 12);
    #endif

    if (maxwid > 0)
    {
      buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0;
      buffer[4] = split;

      e = _swix(Font_ScanString,
                _INR(0,5) | _IN(7) | _OUT(1) | _OUT(3),

                h,
                s,
                FM_GivenLength | FM_GivenBuffer | FM_Kern | FM_GivenHandle,
                maxwid,
                0x1000000,
                buffer,
                maxbytes,

                &reached,
                &retwidth);

      if (!e) retbytes = reached - ((int) s);

//      #ifdef TRACE
//        {
//          int wi, by;
//
//          e = _swix(Font_SetFont,_IN(0),h);
//
//          if (!e) e = _swix(Font_StringWidth,
//                            _INR(1,5) | _OUT(2) | _OUT(5),
//
//                            s,         /* String to find width of                   */
//                            maxwid,    /* Maximum width if splitting is allowed     */
//                            0x1000000, /* Maximum height if splitting is allowed    */
//                            split,     /* Character to split on, or -1 for no split */
//                            maxbytes,  /* Maximum string length                     */
//
//                            &wi,       /* Width of scanned string                   */
//                            &by);      /* Length of scanned string                  */
//
//          if (abs(wi - retwidth) > 2000 || by != retbytes)
//          {
//            Printf("fm_get_string_width: Width/Bytes mismatch in first call...\n");
//            Printf("                     Font_ScanString  -> %d, %d\n", retwidth, retbytes);
//            Printf("                     Font_StringWidth -> %d, %d\n", wi, by);
//          }
//        }
//      #endif
    }

    /* If there was no error, a split character was specified */
    /* but the width is zero, the Font Manager did not find a */
    /* split char before the maximum width given to it was    */
    /* exceeded. We want to be able to spill over in this     */
    /* case, so recall the Font_StringWidth in a non-         */
    /* splitting mode, but only look as far as the first      */
    /* split char (if any) to allow the string to still split */
    /* up. This keeps the width as small as possible, even    */
    /* though individual words are wider than the space we    */
    /* had hoped to fit them into.                            */

    if (!e && !retwidth && split > 0)
    {
      const char * p = s;

      /* Scan only as far as the first split character.         */
      /*                                                        */
      /* Thanks to Tony Cheal for spotting this when doing      */
      /* tables stuff - the original Customer browser sources  */
      /* recognised 'some problem' with Font_StringWidth but    */
      /* didn't then allow any sort of splitting in this part   */
      /* of the code.                                           */

      while (*p && *(p++) != split);

      /* Now call the Font Manager without asking for a split, knowing that */
      /* the string length only runs up to the split character.             */

      _swix(Font_ScanString,
            _INR(0,4) | _IN(7) | _OUT(3),

            h,
            s,
            FM_GivenLength | FM_Kern | FM_GivenHandle,
            0x1000000,
            0x1000000,
            p - s,

            &retwidth);

      retbytes = p - s;

//      #ifdef TRACE
//        {
//          int wi, by;
//
//          _swix(Font_StringWidth,
//                _INR(1,5) | _OUT(2) | _OUT(5),
//
//                s,            /* String to find width of                   */
//                0x1000000,    /* Maximum width if splitting is allowed     */
//                0x1000000,    /* Maximum height if splitting is allowed    */
//                -1,           /* Character to split on, or -1 for no split */
//                p - s,        /* String length                             */
//
//                &wi,          /* Width of scanned string                   */
//                &by);         /* Length of scanned string                  */
//
//          if (abs(wi != retwidth) > 2000 || by != retbytes)
//          {
//            Printf("fm_get_string_width: Width/Bytes mismatch in second call...\n");
//            Printf("                     Font_ScanString  -> %d, %d\n", retwidth, retbytes);
//            Printf("                     Font_StringWidth -> %d, %d\n", wi, by);
//          }
//        }
//      #endif
    }

    /* Exit if there was some error */

    if (e) return e;

    /* Include any trailing spaces in the byte count */

    while (retbytes < maxbytes && s[retbytes] == ' ') retbytes++;
  }
  else
  {
    /* The system font case. */

    int wCurr, wLastSplit, oLastSplit, oCurr;

    /* (Macro defined in FontManage.h). Important that we take */
    /* account of rounding correctly - compare with formula in */
    /* fm_puts().                                              */

    int wChar = (FM_System_Size_X(h) * 10 / (128 * wimpt_dx())) * wimpt_dx() * 400;

    wCurr = wLastSplit = oLastSplit = oCurr = 0;

    /* Whilst the byte counter is less than maxbytes and the width */
    /* calculated so far is less than maxwidth, or we haven't      */
    /* found a split character yet, go through adding              */
    /* the width of a character to the width total for each char   */
    /* of the string. If a split character is met during this, set */
    /* oLastSplit and wLastSplit to the byte counter and thus far  */
    /* calculated width at that point.                             */

    while (
            oCurr < maxbytes &&
            (
              (wCurr <= (unsigned) maxwid) ||
              (split > 0) && !oLastSplit
            )
          )
    {
      #ifdef UNIFONT
        UCS4 ucs;
      #endif

      if ((split > 0) && (s[oCurr] == split))
      {
        oLastSplit = oCurr;
        wLastSplit = wCurr;
      }

      #ifdef UNIFONT
        oCurr += UTF8_to_UCS4(s + oCurr, &ucs);
        wCurr += unifont_widechar(ucs) ? wChar * 2 : wChar;
      #else
        wCurr += wChar;
        oCurr ++;
      #endif
    }

    /* If the current width is greater than the maximum width and there is */
    /* a split point, go back to that last split point.                    */

    if ((wCurr > (unsigned) maxwid) && oLastSplit)
    {
      oCurr = oLastSplit;
      wCurr = wLastSplit;
    }

    /* Include any trailing spaces in the byte count */

    while ((oCurr < maxbytes) && (s[oCurr] == ' ')) oCurr++;

    retbytes = oCurr;
    retwidth = wCurr;
  }

  if (bytes) *bytes = retbytes;
  if (width) *width = retwidth;

  return NULL;
}

/*************************************************/
/* fm_token_font_info()                          */
/*                                               */
/* Looks at a token and returns information on   */
/* the best font to use with it, e.g. bold,      */
/* italic, a typeface number, etc.               */
/*                                               */
/* The returned typeface number is based on the  */
/* array of typeface names defined at the top of */
/* this file (called redraw_faces).              */
/*                                               */
/* Parameters: Pointer to the HStream struct     */
/*             (token) of interest;              */
/*                                               */
/*             Address of an int into which the  */
/*             typeface number is placed;        */
/*                                               */
/*             Address of an int into which the  */
/*             font size to use is returned (in  */
/*             16ths of a point);                */
/*                                               */
/*             Address of an int into which 1 is */
/*             placed if italics should be used  */
/*             (else 0 is returned);             */
/*                                               */
/*             Address of an int into which 1 is */
/*             placed if bold should be used     */
/*             (else 0 is returned).             */
/*************************************************/

void fm_token_font_info(HStream * t, int * facenum, int * size, int * italic, int * bold)
{
  int flags;

  flags = t->style;

  *facenum = 0; /* 0 = Serif */

  *bold    = *italic = 0;

  /* May want to scale the size for certain tag types */

  if (ISSUP(t) || ISSUB(t)) *size = (choices.font_size * 3) / 5;
  else                      *size = choices.font_size;

  /* Scale the size according to the font size specifier */
  /* in the token                                        */

  #ifdef TRACE
    if (t->fontsize < 1 || t->fontsize > 7)
    {
      if (tl & (1u<<10)) Printf("fm_token_font_info: fontsize '%d' out of range\n",t->fontsize);
      t->fontsize = 3;
    }
  #endif

  *size += fm_size(t->fontsize) - choices.font_size;

  /* Set font details according to specific tags */
  /* (or any header, with H_MASK). The macros    */
  /* defined in HTMLLib:tags.h.                  */

  if (flags & (ITALIC | BLOCKQUOTE)) *italic  = 1;
  if (flags & (BOLD   | DT))         *bold    = 1;
  if (flags & (H_MASK | ADDRESS))    *facenum = 1; /* 1 = Sans serif */

  if (flags & (PRE    | TT))         *facenum = 2; /* 2 = Monospaced */

  /* Set bold, italic and size details according  */
  /* to the header level (if the token represents */
  /* header information, that is).                */

  switch (redraw_header(flags))
  {
    case 1: *bold = 1, *size *= 2;              break;
    case 2: *bold = 1, *size = (*size * 8) / 5; break;
    case 3: *bold = 1, *size = (*size * 3) / 2; break;
    case 4: *bold = 1, *size = (*size * 4) / 3; break;
    case 5: *bold = 1, *size = (*size * 8) / 7; break;
    case 6: *bold = 1;                          break;
  }
}

/*************************************************/
/* fm_find_token_font()                          */
/*                                               */
/* Returns an appropriate RISC OS font handle in */
/* which the contents of a given token should be */
/* rendered, optionally recording the usage in a */
/* given browser_data structure.                 */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the font (may be NULL */
/*             for a non-browser specific font   */
/*             claim);                           */
/*                                               */
/*             Pointer to the HStream struct     */
/*             (token) to find the font for;     */
/*                                               */
/*             1 to ignore bold and italic flags */
/*             and just find plain text, else 0. */
/*************************************************/

fm_face fm_find_token_font(browser_data * b, HStream * t, int ignore_styles)
{
  int facenum, size, bold, italic;

  /* Get the recommended font */

  fm_token_font_info(t, &facenum, &size, &italic, &bold);

  if (ignore_styles) facenum = italic = bold = 0;

  /* Return the font handle - note that the typeface name is */
  /* passed to the font managing routines by looking up the  */
  /* typeface number in the redraw_faces array defined at    */
  /* the top of this file, and that 100% aspect ratio is     */
  /* always used due to 'size' being passed in for both the  */
  /* x and y sizes of the font.                              */

  if (facenum == 2) return fm_find_font(b, fm_faces[facenum], (size * choices.tt_aspect) / 100, size, italic, bold);
  else              return fm_find_font(b, fm_faces[facenum], size,                             size, italic, bold);
}