// Copyright (C) 2004-2025 Artifex Software, Inc.

//

// This file is part of MuPDF.

//

// MuPDF is free software: you can redistribute it and/or modify it under the

// terms of the GNU Affero General Public License as published by the Free

// Software Foundation, either version 3 of the License, or (at your option)

// any later version.

//

// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more

// details.

//

// You should have received a copy of the GNU Affero General Public License

// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>

//

// Alternative licensing terms are available from the licensor.

// For commercial licensing, see <https://www.artifex.com/> or contact

// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,

// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#define SUBSCRIPT_OFFSET 0.2f

#define SUPERSCRIPT_OFFSET -0.2f

#include <ft2build.h>

#include FT_FREETYPE_H

// Text black color when converted from DeviceCMYK to RGB

#define CMYK_BLACK 0x221f1f

static void

scale_run(fz_context *ctx, fz_stext_block *block, float scale)

{

  fz_matrix m = fz_scale(scale, scale);

  fz_stext_line *line;

  fz_stext_char *ch;

  while (block)

  {

    block->bbox = fz_transform_rect(block->bbox, m);

    switch (block->type)

    {

    case FZ_STEXT_BLOCK_TEXT:

      for (line = block->u.t.first_line; line; line = line->next)

      {

        line->bbox = fz_transform_rect(block->bbox, m);

        for (ch = line->first_char; ch; ch = ch->next)

        {

          ch->origin = fz_transform_point(ch->origin, m);

          ch->quad = fz_transform_quad(ch->quad, m);

          ch->size = ch->size * scale;

        }

      }

      break;

    case FZ_STEXT_BLOCK_IMAGE:

      block->u.i.transform = fz_post_scale(block->u.i.transform, scale, scale);

      break;

    case FZ_STEXT_BLOCK_STRUCT:

      if (block->u.s.down)

        scale_run(ctx, block->u.s.down->first_block, scale);

      break;

    }

    block = block->next;

  }

}

static void fz_scale_stext_page(fz_context *ctx, fz_stext_page *page, float scale)

{

  scale_run(ctx, page->first_block, scale);

}

/* HTML output (visual formatting with preserved layout) */

static int

detect_super_script(fz_stext_line *line, fz_stext_char *ch)

{

  if (line->wmode == 0 && line->dir.x == 1 && line->dir.y == 0)

    return ch->origin.y < line->first_char->origin.y - ch->size * 0.1f;

  return 0;

}

static const char *

font_full_name(fz_context *ctx, fz_font *font)

{

  const char *name = fz_font_name(ctx, font);

  const char *s = strchr(name, '+');

  return s ? s + 1 : name;

}

static const char *

html_clean_font_name(const char *fontname)

{

  if (strstr(fontname, "Times"))

    return "Times New Roman";

  if (strstr(fontname, "Arial") || strstr(fontname, "Helvetica"))

  {

    if (strstr(fontname, "Narrow") || strstr(fontname, "Condensed"))

      return "Arial Narrow";

    return "Arial";

  }

  if (strstr(fontname, "Courier"))

    return "Courier";

  return fontname;

}

static void

font_family_name(fz_context *ctx, fz_font *font, char *buf, int size, int is_mono, int is_serif)

{

  const char *name = html_clean_font_name(font_full_name(ctx, font));

  char *s;

  fz_strlcpy(buf, name, size);

  s = strrchr(buf, '-');

  if (s)

    *s = 0;

  if (is_mono)

    fz_strlcat(buf, ",monospace", size);

  else

    fz_strlcat(buf, is_serif ? ",serif" : ",sans-serif", size);

}

static void

fz_print_style_begin_html(fz_context *ctx, fz_output *out, fz_font *font, float size, int sup, int color)

{

  char family[80];

  int is_bold = fz_font_is_bold(ctx, font);

  int is_italic = fz_font_is_italic(ctx, font);

  int is_serif = fz_font_is_serif(ctx, font);

  int is_mono = fz_font_is_monospaced(ctx, font);

  font_family_name(ctx, font, family, sizeof family, is_mono, is_serif);

  if (sup) fz_write_string(ctx, out, "<sup>");

  if (is_mono) fz_write_string(ctx, out, "<tt>");

  if (is_bold) fz_write_string(ctx, out, "<b>");

  if (is_italic) fz_write_string(ctx, out, "<i>");

  fz_write_printf(ctx, out, "<span style=\"font-family:%s;font-size:%.1fpt", family, size);

  if (color != 0 && color != CMYK_BLACK)

    fz_write_printf(ctx, out, ";color:#%06x", color & 0xffffff);

  fz_write_printf(ctx, out, "\">");

}

static void

fz_print_style_end_html(fz_context *ctx, fz_output *out, fz_font *font, float size, int sup, int color)

{

  int is_mono = fz_font_is_monospaced(ctx, font);

  int is_bold = fz_font_is_bold(ctx,font);

  int is_italic = fz_font_is_italic(ctx, font);

  fz_write_string(ctx, out, "</span>");

  if (is_italic) fz_write_string(ctx, out, "</i>");

  if (is_bold) fz_write_string(ctx, out, "</b>");

  if (is_mono) fz_write_string(ctx, out, "</tt>");

  if (sup) fz_write_string(ctx, out, "</sup>");

}

static void

fz_print_stext_image_as_html(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  fz_matrix ctm = block->u.i.transform;

#define USE_CSS_MATRIX_TRANSFORMS

#ifdef USE_CSS_MATRIX_TRANSFORMS

  /* Matrix maths notes.

   * When we get here ctm maps the unit square to the position in device

   * space occupied by the image.

   *

   * That is to say that mapping the 4 corners of the unit square through

   * the transform, give us the 4 target corners. We extend the corners

   * by adding an extra '1' into them to allow transforms to work. Thus

   * (x,y) maps through ctm = (a b c d e f) as:

   *

   * (x y 1) (a b 0) = (X Y 1)

   *         (c d 0)

   *         (e f 1)

   *

   * To simplify reading of matrix maths, we use the trick where we

   * 'drop' the first matrix down the page. Thus the corners c0=(0,0),

   * c1=(1,0), c2=(1,1), c3=(0,1) map to C0, C1, C2, C3 respectively:

   *

   *         (    a     b 0)

   *         (    c     d 0)

   *         (    e     f 1)

   * (0 0 1) (    e     f 1)

   * (0 1 1) (  c+e   d+f 1)

   * (1 1 1) (a+c+e b+d+f 1)

   * (1 0 1) (  a+e   b+f 1)

   *

   * where C0 = (e,f), C1=(c+e, d+f) C2=(a+c+e, b+d+f), C3=(a+e, b+f)

   *

   * Unfortunately, the CSS matrix transform, does not map the unit square.

   * Rather it does something moderately mad. As far as I can work out, the

   * top left corner of a (0,0) -> (w, h) box is transformed using the .e

   * and .f entries of the matrix. Then the image from within that square

   * is transformed using the centre of that square as the origin.

   *

   * So, an image placed at (0,0) in destination space with 1:1 transform

   * will result in an image a (0,0) as you'd expect. But an image at (0,0)

   * with a scale of 2, will result in 25% of the image off the left of the

   * screen, and 25% off the top.

   *

   * Accordingly, we have to adjust the ctm in several steps.

   */

  /* Move to moving the centre of the image. */

  ctm.e += (ctm.a+ctm.c)/2;

  ctm.f += (ctm.b+ctm.d)/2;

  /* Move from transforming the unit square to w/h */

  ctm.a /= block->u.i.image->w;

  ctm.b /= block->u.i.image->w;

  ctm.c /= block->u.i.image->h;

  ctm.d /= block->u.i.image->h;

  /* Move from points to pixels */

  ctm.a *= 96.0f/72;

  ctm.b *= 96.0f/72;

  ctm.c *= 96.0f/72;

  ctm.d *= 96.0f/72;

  ctm.e *= 96.0f/72;

  ctm.f *= 96.0f/72;

  /* Move to moving the top left of the untransformed image box, cos HTML is bonkers. */

  ctm.e -= block->u.i.image->w/2;

  ctm.f -= block->u.i.image->h/2;

  fz_write_printf(ctx, out, "<img style=\"position:absolute;transform:matrix(%g,%g,%g,%g,%g,%g)\" src=\"",

    ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f);

#else

  /* Alternative version of the code that uses scaleX/Y and rotate

   * instead, but only copes with axis aligned cases. */

  int t;

  int x = block->bbox.x0;

  int y = block->bbox.y0;

  int w = block->bbox.x1 - block->bbox.x0;

  int h = block->bbox.y1 - block->bbox.y0;

  const char *flip = "";

  if (ctm.b == 0 && ctm.c == 0)

  {

    if (ctm.a < 0 && ctm.d < 0)

      flip = "transform: scaleX(-1) scaleY(-1);";

    else if (ctm.a < 0)

    {

      flip = "transform: scaleX(-1);";

    }

    else if (ctm.d < 0)

    {

      flip = "transform: scaleY(-1);";

    }

  } else if (ctm.a == 0 && ctm.d == 0) {

    if (ctm.b < 0 && ctm.c < 0)

    {

      flip = "transform: scaleY(-1) rotate(90deg);";

      x += (w-h)/2;

      y -= (w-h)/2;

      t = w; w = h; h = t;

    }

    else if (ctm.b < 0)

    {

      flip = "transform: scaleX(-1) scaleY(-1) rotate(90deg);";

      x += (w-h)/2;

      y -= (w-h)/2;

      t = w; w = h; h = t;

    }

    else if (ctm.c < 0)

    {

      flip = "transform: scaleX(-1) scaleY(-1) rotate(270deg);";

      x += (w-h)/2;

      y -= (w-h)/2;

      t = w; w = h; h = t;

    }

    else

    {

      flip = "transform: scaleY(-1) rotate(270deg);";

      x += (w-h)/2;

      y -= (w-h)/2;

      t = w; w = h; h = t;

    }

  }

  fz_write_printf(ctx, out, "<img style=\"position:absolute;%stop:%dpt;left:%dpt;width:%dpt;height:%dpt\" src=\"", flip, y, x, w, h);

#endif

  fz_write_image_as_data_uri(ctx, out, block->u.i.image);

  fz_write_string(ctx, out, "\">\n");

}

void

fz_print_stext_block_as_html(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  fz_stext_line *line;

  fz_stext_char *ch;

  float x, y, h;

  fz_font *font = NULL;

  float size = 0;

  int sup = 0;

  uint32_t color = 0;

  for (line = block->u.t.first_line; line; line = line->next)

  {

    x = line->bbox.x0;

    y = line->bbox.y0;

    h = line->bbox.y1 - line->bbox.y0;

    if (line->first_char)

    {

      h = line->first_char->size;

      y = line->first_char->origin.y - h * 0.8f;

    }

    fz_write_printf(ctx, out, "<p style=\"top:%.1fpt;left:%.1fpt;line-height:%.1fpt\">", y, x, h);

    font = NULL;

    for (ch = line->first_char; ch; ch = ch->next)

    {

      int ch_sup = detect_super_script(line, ch);

      if (ch->font != font || ch->size != size || ch_sup != sup || ch->argb != color)

      {

        if (font)

          fz_print_style_end_html(ctx, out, font, size, sup, color);

        font = ch->font;

        size = ch->size;

        color = ch->argb;

        sup = ch_sup;

        fz_print_style_begin_html(ctx, out, font, size, sup, color);

      }

      switch (ch->c)

      {

      default:

        if (ch->c >= 32 && ch->c <= 127)

          fz_write_byte(ctx, out, ch->c);

        else

          fz_write_printf(ctx, out, "&#x%x;", ch->c);

        break;

      case '<': fz_write_string(ctx, out, "&lt;"); break;

      case '>': fz_write_string(ctx, out, ">"); break;

      case '&': fz_write_string(ctx, out, "&"); break;

      case '"': fz_write_string(ctx, out, """); break;

      case '\'': fz_write_string(ctx, out, "'"); break;

      }

    }

    if (font)

      fz_print_style_end_html(ctx, out, font, size, sup, color);

    fz_write_string(ctx, out, "</p>\n");

  }

}

static const char *

html_tag_for_struct(fz_stext_struct *s)

{

  const char *raw;

  if (s == NULL)

    return "DIV";

  raw = s->raw;

  if (raw == NULL)

    raw = fz_structure_to_string(s->standard);

  if (!fz_strcasecmp(raw, "blockquote"))

    return "blockquote";

  if (!fz_strcasecmp(raw, "title"))

    return "h1";

  if (!fz_strcasecmp(raw, "sub"))

    return "sub";

  if (!fz_strcasecmp(raw, "p"))

    return "p";

  if (!fz_strcasecmp(raw, "h"))

    return "h1"; /* Pick one! */

  if (!fz_strcasecmp(raw, "h1"))

    return "h1";

  if (!fz_strcasecmp(raw, "h2"))

    return "h2";

  if (!fz_strcasecmp(raw, "h3"))

    return "h3";

  if (!fz_strcasecmp(raw, "h4"))

    return "h4";

  if (!fz_strcasecmp(raw, "h5"))

    return "h5";

  if (!fz_strcasecmp(raw, "h6"))

    return "h6";

  if (!fz_strcasecmp(raw, "list"))

    return "ul";

  if (!fz_strcasecmp(raw, "listitem"))

    return "li";

  if (!fz_strcasecmp(raw, "table"))

    return "table";

  if (!fz_strcasecmp(raw, "tr"))

    return "tr";

  if (!fz_strcasecmp(raw, "th"))

    return "th";

  if (!fz_strcasecmp(raw, "td"))

    return "td";

  if (!fz_strcasecmp(raw, "thead"))

    return "thead";

  if (!fz_strcasecmp(raw, "tbody"))

    return "tbody";

  if (!fz_strcasecmp(raw, "tfoot"))

    return "tfoot";

  if (!fz_strcasecmp(raw, "span"))

    return "span";

  if (!fz_strcasecmp(raw, "code"))

    return "code";

  if (!fz_strcasecmp(raw, "em"))

    return "em";

  if (!fz_strcasecmp(raw, "strong"))

    return "strong";

  return "div";

}

static void

print_blocks_as_html(fz_context *ctx, fz_output *out, fz_stext_block *block);

static void

fz_print_stext_struct_as_html(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  const char *tag;

  if (block->u.s.down == NULL)

    return;

  tag = html_tag_for_struct(block->u.s.down);

  fz_write_printf(ctx, out, "<%s>\n", tag);

  print_blocks_as_html(ctx, out, block->u.s.down->first_block);

  fz_write_printf(ctx, out, "</%s>\n", tag);

}

static void

print_blocks_as_html(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  for (; block; block = block->next)

  {

    if (block->type == FZ_STEXT_BLOCK_IMAGE)

      fz_print_stext_image_as_html(ctx, out, block);

    else if (block->type == FZ_STEXT_BLOCK_TEXT)

      fz_print_stext_block_as_html(ctx, out, block);

    else if (block->type == FZ_STEXT_BLOCK_STRUCT)

      fz_print_stext_struct_as_html(ctx, out, block);

  }

}

void

fz_print_stext_page_as_html(fz_context *ctx, fz_output *out, fz_stext_page *page, int id)

{

  float w = page->mediabox.x1 - page->mediabox.x0;

  float h = page->mediabox.y1 - page->mediabox.y0;

  fz_write_printf(ctx, out, "<div id=\"page%d\" style=\"width:%.1fpt;height:%.1fpt\">\n", id, w, h);

  print_blocks_as_html(ctx, out, page->first_block);

  fz_write_string(ctx, out, "</div>\n");

}

void

fz_print_stext_header_as_html(fz_context *ctx, fz_output *out)

{

  fz_write_string(ctx, out, "<!DOCTYPE html>\n");

  fz_write_string(ctx, out, "<html>\n");

  fz_write_string(ctx, out, "<head>\n");

  fz_write_string(ctx, out, "<style>\n");

  fz_write_string(ctx, out, "body{background-color:slategray}\n");

  fz_write_string(ctx, out, "div{position:relative;background-color:white;margin:1em auto;box-shadow:1px 1px 8px -2px black}\n");

  fz_write_string(ctx, out, "p{position:absolute;white-space:pre;margin:0}\n");

  fz_write_string(ctx, out, "</style>\n");

  fz_write_string(ctx, out, "</head>\n");

  fz_write_string(ctx, out, "<body>\n");

}

void

fz_print_stext_trailer_as_html(fz_context *ctx, fz_output *out)

{

  fz_write_string(ctx, out, "</body>\n");

  fz_write_string(ctx, out, "</html>\n");

}

/* XHTML output (semantic, little layout, suitable for reflow) */

static void

find_table_pos(fz_stext_grid_positions *xs, float x0, float x1, int *ix0, int *ix1)

{

  int i;

  *ix0 = -1;

  *ix1 = -1;

  for (i = 1; i < xs->len; i++)

    if (x0 < xs->list[i].pos)

    {

      *ix0 = i-1;

      break;

    }

  for (; i < xs->len; i++)

    if (x1 < xs->list[i].pos)

    {

      *ix1 = i-1;

      break;

    }

  if (i == xs->len)

    *ix1 = i-1;

}

static void

run_to_xhtml(fz_context *ctx, fz_stext_block *block, fz_output *out);

static void

fz_print_stext_table_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  fz_stext_block *grid, *tr, *td;

  int w, h;

  int x, y;

  uint8_t *cells;

  int malformed = 0;

  for (grid = block; grid != NULL; grid = grid->next)

    if (grid->type == FZ_STEXT_BLOCK_GRID)

      break;

  if (grid == NULL)

  {

    fz_warn(ctx, "Malformed table data");

    return;

  }

  w = grid->u.b.xs->len;

  h = grid->u.b.ys->len;

  cells = fz_calloc(ctx, w, h);

  fz_try(ctx)

  {

    fz_write_printf(ctx, out, "<table>\n");

    y = 0;

    for (tr = grid->next; tr != NULL; tr = tr->next)

    {

      if (tr->type != FZ_STEXT_BLOCK_STRUCT || tr->u.s.down == NULL || tr->u.s.down->standard != FZ_STRUCTURE_TR)

      {

        malformed = 1;

        continue;

      }

      fz_write_printf(ctx, out, "<tr>\n");

      x = 0;

      for (td = tr->u.s.down->first_block; td != NULL; td = td->next)

      {

        int x0, y0, x1, y1;

        if (td->type != FZ_STEXT_BLOCK_STRUCT || td->u.s.down == NULL || td->u.s.down->standard != FZ_STRUCTURE_TD)

        {

          malformed = 1;

          continue;

        }

        find_table_pos(grid->u.b.xs, td->bbox.x0, td->bbox.x1, &x0, &x1);

        find_table_pos(grid->u.b.ys, td->bbox.y0, td->bbox.y1, &y0, &y1);

        if (x0 < 0 || x1 < 0 || x1 >= w)

        {

          malformed = 1;

          x0 = x;

          x1 = x+1;

        }

        if (y0 < 0 || y1 < 0 || y1 >= h)

        {

          malformed = 1;

          y0 = y;

          y1 = y+1;

        }

        if (y < y0)

        {

          malformed = 1;

          continue;

        }

        if (x > x0)

        {

          malformed = 1;

        }

        while (x < x0)

        {

          uint8_t *c = &cells[x + w*y];

          if (*c == 0)

          {

            fz_write_printf(ctx, out, "<td></td>");

            *c = 1;

          }

          x++;

        }

        fz_write_string(ctx, out, "<td");

        if (x1 > x0+1)

          fz_write_printf(ctx, out, " rowspan=%d", x1-x0);

        if (y1 > y0+1)

          fz_write_printf(ctx, out, " colspan=%d", y1-y0);

        fz_write_string(ctx, out, ">\n");

        run_to_xhtml(ctx, td->u.s.down->first_block, out);

        fz_write_printf(ctx, out, "</td>\n");

        for ( ; y0 < y1; y0++)

          for (x = x0; x < x1; x++)

          {

            uint8_t *c = &cells[x + w*y0];

            if (*c != 0)

              malformed = 1;

            *c = 1;

          }

      }

      fz_write_printf(ctx, out, "</tr>\n");

      y++;

    }

    fz_write_printf(ctx, out, "</table>\n");

  }

  fz_always(ctx)

    fz_free(ctx, cells);

  fz_catch(ctx)

    fz_rethrow(ctx);

  if (malformed)

    fz_warn(ctx, "Malformed table data");

}

static void

fz_print_stext_image_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  int w = block->bbox.x1 - block->bbox.x0;

  int h = block->bbox.y1 - block->bbox.y0;

  fz_write_printf(ctx, out, "<p><img width=\"%d\" height=\"%d\" src=\"", w, h);

  fz_write_image_as_data_uri(ctx, out, block->u.i.image);

  fz_write_string(ctx, out, "\"/></p>\n");

}

static void

fz_print_style_begin_xhtml(fz_context *ctx, fz_output *out, fz_font *font, int sup)

{

  int is_mono = fz_font_is_monospaced(ctx, font);

  int is_bold = fz_font_is_bold(ctx, font);

  int is_italic = fz_font_is_italic(ctx, font);

  if (sup)

    fz_write_string(ctx, out, "<sup>");

  if (is_mono)

    fz_write_string(ctx, out, "<tt>");

  if (is_bold)

    fz_write_string(ctx, out, "<b>");

  if (is_italic)

    fz_write_string(ctx, out, "<i>");

}

static void

fz_print_style_end_xhtml(fz_context *ctx, fz_output *out, fz_font *font, int sup)

{

  int is_mono = fz_font_is_monospaced(ctx, font);

  int is_bold = fz_font_is_bold(ctx, font);

  int is_italic = fz_font_is_italic(ctx, font);

  if (is_italic)

    fz_write_string(ctx, out, "</i>");

  if (is_bold)

    fz_write_string(ctx, out, "</b>");

  if (is_mono)

    fz_write_string(ctx, out, "</tt>");

  if (sup)

    fz_write_string(ctx, out, "</sup>");

}

static float avg_font_size_of_line(fz_stext_char *ch)

{

  float size = 0;

  int n = 0;

  if (!ch)

    return 0;

  while (ch)

  {

    size += ch->size;

    ++n;

    ch = ch->next;

  }

  return size / n;

}

static const char *tag_from_font_size(float size)

{

  if (size >= 20) return "h1";

  if (size >= 15) return "h2";

  if (size >= 12) return "h3";

  return "p";

}

static void fz_print_stext_block_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  fz_stext_line *line;

  fz_stext_char *ch;

  fz_font *font = NULL;

  int sup = 0;

  int sp = 1;

  const char *tag = NULL;

  const char *new_tag;

  for (line = block->u.t.first_line; line; line = line->next)

  {

    new_tag = tag_from_font_size(avg_font_size_of_line(line->first_char));

    if (tag != new_tag)

    {

      if (tag)

      {

        if (font)

          fz_print_style_end_xhtml(ctx, out, font, sup);

        fz_write_printf(ctx, out, "</%s>", tag);

      }

      tag = new_tag;

      fz_write_printf(ctx, out, "<%s>", tag);

      if (font)

        fz_print_style_begin_xhtml(ctx, out, font, sup);

    }

    if (!sp)

      fz_write_byte(ctx, out, ' ');

    for (ch = line->first_char; ch; ch = ch->next)

    {

      int ch_sup = detect_super_script(line, ch);

      if (ch->font != font || ch_sup != sup)

      {

        if (font)

          fz_print_style_end_xhtml(ctx, out, font, sup);

        font = ch->font;

        sup = ch_sup;

        fz_print_style_begin_xhtml(ctx, out, font, sup);

      }

      sp = (ch->c == ' ');

      switch (ch->c)

      {

      default:

        if (ch->c >= 32 && ch->c <= 127)

          fz_write_byte(ctx, out, ch->c);

        else

          fz_write_printf(ctx, out, "&#x%x;", ch->c);

        break;

      case '<': fz_write_string(ctx, out, "&lt;"); break;

      case '>': fz_write_string(ctx, out, ">"); break;

      case '&': fz_write_string(ctx, out, "&"); break;

      case '"': fz_write_string(ctx, out, """); break;

      case '\'': fz_write_string(ctx, out, "'"); break;

      }

    }

  }

  if (font)

    fz_print_style_end_xhtml(ctx, out, font, sup);

  fz_write_printf(ctx, out, "</%s>\n", tag);

}

static void

fz_print_struct_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_block *block)

{

  const char *tag;

  if (block->u.s.down == NULL)

    return;

  if (block->u.s.down->standard == FZ_STRUCTURE_TABLE)

  {

    fz_print_stext_table_as_xhtml(ctx, out, block->u.s.down->first_block);

    return;

  }

  tag = html_tag_for_struct(block->u.s.down);

  fz_write_printf(ctx, out, "<%s>\n", tag);

  run_to_xhtml(ctx, block->u.s.down->first_block, out);

  fz_write_printf(ctx, out, "</%s>\n", tag);

}

static void

run_to_xhtml(fz_context *ctx, fz_stext_block *block, fz_output *out)

{

  while (block)

  {

    switch(block->type)

    {

    case FZ_STEXT_BLOCK_IMAGE:

      fz_print_stext_image_as_xhtml(ctx, out, block);

      break;

    case FZ_STEXT_BLOCK_TEXT:

      fz_print_stext_block_as_xhtml(ctx, out, block);

      break;

    case FZ_STEXT_BLOCK_STRUCT:

      fz_print_struct_as_xhtml(ctx, out, block);

      break;

    }

    block = block->next;

  }

}

void

fz_print_stext_page_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_page *page, int id)

{

  fz_write_printf(ctx, out, "<div id=\"page%d\">\n", id);

  run_to_xhtml(ctx, page->first_block, out);

  fz_write_string(ctx, out, "</div>\n");

}

void

fz_print_stext_header_as_xhtml(fz_context *ctx, fz_output *out)

{

  fz_write_string(ctx, out, "<?xml version=\"1.0\"?>\n");

  fz_write_string(ctx, out, "<!DOCTYPE html");

  fz_write_string(ctx, out, " PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"");

  fz_write_string(ctx, out, " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");

  fz_write_string(ctx, out, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n");

  fz_write_string(ctx, out, "<head>\n");

  fz_write_string(ctx, out, "<style>\n");

  fz_write_string(ctx, out, "p{white-space:pre-wrap}\n");

  fz_write_string(ctx, out, "</style>\n");

  fz_write_string(ctx, out, "</head>\n");

  fz_write_string(ctx, out, "<body>\n");

}

void

fz_print_stext_trailer_as_xhtml(fz_context *ctx, fz_output *out)

{

  fz_write_string(ctx, out, "</body>\n");

  fz_write_string(ctx, out, "</html>\n");

}

/* Detailed XML dump of the entire structured text data */

static void

xml_write_char(fz_context *ctx, fz_output *out, int c)

{

  switch (c)

  {

  case '<': fz_write_string(ctx, out, "&lt;"); break;

  case '>': fz_write_string(ctx, out, ">"); break;

  case '&': fz_write_string(ctx, out, "&"); break;

  case '"': fz_write_string(ctx, out, """); break;

  case '\'': fz_write_string(ctx, out, "'"); break;

  default:

    if (c >= 32 && c <= 127)

      fz_write_printf(ctx, out, "%c", c);

    else

      fz_write_printf(ctx, out, "&#x%x;", c);

    break;

  }

}

static void

as_xml(fz_context *ctx, fz_stext_block *block, fz_output *out)

{

  fz_stext_line *line;

  fz_stext_char *ch;

  int i;

  while (block)

  {

    switch (block->type)

    {

    case FZ_STEXT_BLOCK_TEXT:

      fz_write_printf(ctx, out, "<block bbox=\"%g %g %g %g\"",

          block->bbox.x0, block->bbox.y0, block->bbox.x1, block->bbox.y1);

      if (block->u.t.flags == FZ_STEXT_TEXT_JUSTIFY_UNKNOWN)

        fz_write_printf(ctx, out, " justify=\"unknown\"");

      if (block->u.t.flags == FZ_STEXT_TEXT_JUSTIFY_LEFT)

        fz_write_printf(ctx, out, " justify=\"left\"");

      if (block->u.t.flags == FZ_STEXT_TEXT_JUSTIFY_CENTRE)

        fz_write_printf(ctx, out, " justify=\"centre\"");

      if (block->u.t.flags == FZ_STEXT_TEXT_JUSTIFY_RIGHT)