/* otfview.c -- View glyphs of OpenType fonts.

Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010

  National Institute of Advanced Industrial Science and Technology (AIST)

  Registration Number H15PRO167

This file is part of libotf.

Libotf is free software; you can redistribute it and/or modify it

under the terms of the GNU Lesser General Public License as published

by the Free Software Foundation; either version 2.1 of the License, or

(at your option) any later version.

Libotf 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 Lesser General Public

License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library, in a file named COPYING; if not,

write to the Free Software Foundation, Inc., 59 Temple Place, Suite

330, Boston, MA 02111-1307, USA.  */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <unistd.h>

#include <libgen.h>

#include "config.h"

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#endif

#ifdef HAVE_X11_XAW_COMMAND_H

#include <X11/Xatom.h>

#include <X11/Intrinsic.h>

#include <X11/StringDefs.h>

#include <X11/Shell.h>

#include <X11/Xaw/Command.h>

#include <X11/Xaw/Toggle.h>

#include <X11/Xaw/Box.h>

#include <X11/Xaw/Form.h>

#include <X11/Xaw/Viewport.h>

#include <ft2build.h>

#include FT_FREETYPE_H

#include <otf.h>

#define CAST_FROM_XTPOINTER(TYPE, DATA, VAR)	\

  do {						\

    long TYPE temp = (long TYPE) (DATA);	\

    (VAR) = temp;				\

  } while (0)

#define XtAddCallbackWithCast(TYPE, W, PROC, VAR)		\

  do {								\

    long TYPE temp = (long TYPE) (VAR);				\

    XtAddCallback (W, XtNcallback, PROC, (XtPointer) temp);	\

  } while (0)

#define DEFAULT_PIXEL_SIZE 30

int pixel_size;

#define DEFAULT_FONT_NAME "6x13"

XFontStruct *font;

#define FONT_HEIGHT (font->ascent + font->descent)

#define FONT_ASCENT (font->ascent)

#define FONT_DESCENT (font->descent)

#define FONT_WIDTH (font->max_bounds.width)

XtAppContext context;

/* Widget structure.

   +--- frame (form) -------------------------+

   | +--- command_area (box) ---------------+ |

   | | quit dump charmap ...                | |

   | +--------------------------------------+ |

   | +---- navi_area (box) -----------------+ |

   | | FIRST PREV prev range next NEXT LAST | |

   | +--------------------------------------+ |

   | +--- glyph_area (form) ----------------+ |

   | | idxh[0] glyph[0]    ...    glyph[15] | |

   | |   ...                        ...     | |

   | | idxh[7] glyph[112]  ...    glyph[127]| |

   | |         idxl[0]     ...    idxl[15]  | |

   | +--------------------------------------+ |

   | +--- script_area (box) ----------------+ |

   | | script(langsys) DFLT ...             | |

   | +--------------------------------------+ |

   | +---- uvs_area (box) (optional) -------+ |

   | | uvs[?].w ...                         | |

   | +--------------------------------------+ |

   | +--- render_area (form) ---------------+ |

   | | clear del bidi alt_subst             | |

   | | +--- raw (box) --------------------+ | |

   | | | raw_label raw_image              | | |

   | | +----------------------------------+ | |

   | | GSUB all none features...            | |

   | | GPOS all none features...            | |

   | | +--- seq (box) --------------------+ | |

   | | | seq_label seq_image              | | |

   | | +----------------------------------+ | |

   | | +--- code (box) -------------------+ | |

   | | | code_label code_list ...         | | |   

   | | +----------------------------------+ | |

   | +--------------------------------------+ |

   +------------------------------------------+ */

Widget shell, frame;

Widget command_area, quit, dump, *charmap;

Widget navi_area, FIRST, PREV, prev, range, next, NEXT, LAST;

Widget glyph_area, glyph[128], index_label[8];

Widget uvs_area, uvs_label;

Widget render_area, clear, del, bidi, alt_subst, raw, seq, code;

Widget raw_label, raw_image, seq_label, seq_image, code_label, code_list;

unsigned long foreground, background;

typedef struct

{

  OTF_Tag tag;

  int on;

  Widget w;

} FeatureElement;

typedef struct

{

  char *label;

  OTF_GSUB_GPOS *gsub_gpos;

  OTF_LangSys *langsys;

  int num_features;

  FeatureElement *features;

  Widget parent;

} FeatureRec;

FeatureRec gsub, gpos;

/* Currently selected script and langsys.  */

OTF_Tag script_tag, langsys_tag;

int glyph_char[128];

Display *display;

GC gc, gc_set, gc_or, gc_inv;

typedef struct {

  Pixmap pixmap;

  unsigned width, height;

  int x, y;

  int advance;

} BitmapRec;

BitmapRec bitmap[0x110000];

int render_width, render_height;

Pixmap raw_pixmap, seq_pixmap, gsub_pixmap, gpos_pixmap;

Pixmap none_pixmap;

FT_Face face;

struct {

  int platform_id;

  int encoding_id;

  char name[20];

} charmap_rec[10];

int charmap_index;

int reversed;

int do_alternate_subst;

unsigned glyph_width, glyph_height;

int glyph_x, glyph_y;

int glyph_index;

struct {

  int n_glyphs;

  int glyphs[64];

  int codes[64];

} glyph_rec;

OTF_EncodingSubtable14 *sub14 = NULL;

struct {

  Widget w;

  int c;

} uvs[256];

OTF *otf;

char *filename;

int fontindex;

void

create_pixmap (int index)

{

  int err = FT_Load_Glyph (face, index, FT_LOAD_RENDER | FT_LOAD_MONOCHROME);

  XImage ximage;

  Pixmap pixmap;

  if (err)

    {

      bitmap[index].pixmap = none_pixmap;

      return;

    }

  ximage.height = face->glyph->bitmap.rows;

  ximage.width = face->glyph->bitmap.width;

  ximage.depth = 1;

  ximage.bits_per_pixel = 1;

  ximage.xoffset = 0;

  ximage.format = XYPixmap;

  ximage.data = (char *) face->glyph->bitmap.buffer;

  ximage.byte_order = MSBFirst;

  ximage.bitmap_unit = 8;

  ximage.bitmap_bit_order = MSBFirst;

  ximage.bitmap_pad = 8;

  ximage.bytes_per_line = face->glyph->bitmap.pitch;

  XInitImage (&ximage);

  pixmap = XCreatePixmap (display, DefaultRootWindow (display),

			  glyph_width, glyph_height, 1);

  XFillRectangle (display, pixmap, gc, 0, 0, glyph_width, glyph_height);

  XPutImage (display, pixmap, gc, &ximage, 0, 0,

	     glyph_x + face->glyph->bitmap_left,

	     glyph_y - face->glyph->bitmap_top,

	     ximage.width, ximage.height);

  bitmap[index].pixmap = pixmap;

  bitmap[index].width = ximage.width;

  bitmap[index].height = ximage.height;

  bitmap[index].x = face->glyph->bitmap_left;

  bitmap[index].y = - face->glyph->bitmap_top;

  bitmap[index].advance = face->glyph->metrics.horiAdvance >> 6;

}

void

update_glyph_area ()

{

  int i;

  Arg arg[2];

  char buf[16];

  int msb;

  for (i = 0; i < 128; i++)

    {

      int index = glyph_index + i;

      if (charmap_index >= 0)

	index = FT_Get_Char_Index (face, (FT_ULong) index);

      if (charmap_index >= 0 && ! index)

	XtSetArg (arg[0], XtNbitmap, none_pixmap);

      else

	{

	  if (! bitmap[index].pixmap)

	    create_pixmap (index);

	  XtSetArg (arg[0], XtNbitmap, bitmap[index].pixmap);

	}

      XtSetValues (glyph[i], arg, 1);

    }

  msb = (glyph_index >> 7) % 2 ? 8 : 0;

  for (i = 0; i < 8; i++)

    {

      char str[3];

      sprintf (str, "%XX", i | msb );

      XtSetArg (arg[0], XtNheight, glyph_height + 5);

      XtSetArg (arg[1], XtNlabel, str);

      XtSetValues (index_label[i], arg, 2);

    }

  if (glyph_index < 0x10000)

    sprintf (buf, "  %04X-%04X  ", glyph_index, glyph_index + 0x7F);

  else

    sprintf (buf, "%06X-%06X", glyph_index, glyph_index + 0x7F);

  XtSetArg (arg[0], XtNlabel, buf);

  XtSetValues (range, arg, 1);

}

void

update_uvs_area (int c)

{

  OTF_GlyphID code[256];

  Arg arg[1];

  int i;

  OTF_get_variation_glyphs (otf, c, code);

  for (i = 0; i < 256; i++)

    if (uvs[i].w)

      {

	if (code[i])

	  XtSetArg (arg[0], XtNsensitive, True);

	else

	  XtSetArg (arg[0], XtNsensitive, False);

	XtSetValues (uvs[i].w, arg, 1);

      }

}

char *

get_features (OTF_FeatureList *list, FeatureRec *rec)

{

  int i, n;

  char *str, *p;

  if (! rec->langsys || ! rec->features)

    return NULL;

  for (i = n = 0; i < rec->langsys->FeatureCount; i++)

    if (rec->features[i].on)

      n++;

  if (n == 0)

    return NULL;

  str = malloc (n * 5);

  for (i = 0, p = str; i < rec->langsys->FeatureCount; i++)

    if (rec->features[i].on)

      {

	OTF_tag_name (rec->features[i].tag, p);

	p[4] = ',';

	p += 5;

      }

  p[-1] = '\0';

  return str;

}

#define DEVICE_DELTA(table, size)					\

  (((table).DeltaValue							\

    && ((size) >= (table).StartSize && (size) <= (table).EndSize))	\

   ? (table).DeltaValue[(size) >= (table).StartSize]			\

   : 0)

void

adjust_anchor (OTF_Anchor *anchor, FT_Face ft_face,

	       OTF_Glyph *g, int *x, int *y)

{

  if (anchor->AnchorFormat == 2)

    {

      FT_Outline *outline;

      int ap = anchor->f.f1.AnchorPoint;

      FT_Load_Glyph (ft_face, (FT_UInt) g->glyph_id, FT_LOAD_MONOCHROME);

      outline = &ft_face->glyph->outline;

      if (ap < outline->n_points)

	{

	  *x = outline->points[ap].x;

	  *y = outline->points[ap].y;

	}

    }

  else if (anchor->AnchorFormat == 3)

    {

      *x += DEVICE_DELTA (anchor->f.f2.XDeviceTable, pixel_size);

      *y += DEVICE_DELTA (anchor->f.f2.YDeviceTable, pixel_size);

    }

}

void

update_seq_area ()

{

  int i, x;

  OTF_GlyphString gstring;

  OTF_Glyph *g, *prev, *base, *mark;

  int base_width;

  int len = glyph_rec.n_glyphs;

  Arg arg[1];

  int unitsPerEm = face->units_per_EM;

  OTF_Tag *log = NULL;

  int logsize;

  gstring.size = gstring.used = len;

  gstring.glyphs = malloc (sizeof (OTF_Glyph) * len);

  memset (gstring.glyphs, 0, sizeof (OTF_Glyph) * len);

  for (i = 0; i < len; i++)

    {

      gstring.glyphs[i].c = glyph_rec.codes[i];

      if (charmap_index < 0)

	gstring.glyphs[i].glyph_id = glyph_rec.glyphs[i];

    }

  XFillRectangle (display, seq_pixmap, gc, 0, 0, render_width, render_height);

  XDrawLine (display, seq_pixmap, gc_set, 0, glyph_y, render_width, glyph_y);

  if (otf)

    {

      char *script_name = NULL, *langsys_name = NULL, buf[10];

      char *str;

      if (script_tag)

	{

	  script_name = buf;

	  OTF_tag_name (script_tag, script_name);

	}

      if (langsys_tag)

	{

	  langsys_name = buf + 5;

	  OTF_tag_name (langsys_tag, langsys_name);

	}

      OTF_drive_cmap (otf, &gstring);

      OTF_drive_gdef (otf, &gstring);

      if (otf->gsub)

	{

	  str = get_features (&otf->gsub->FeatureList, &gsub);

	  if (str)

	    {

	      if (do_alternate_subst)

		OTF_drive_gsub_alternate (otf, &gstring,

					  script_name, langsys_name, str);

	      else

		{

		  OTF_drive_gsub_with_log (otf, &gstring,

					   script_name, langsys_name, str);

		  logsize = gstring.used * 2;

		  log = alloca (sizeof (OTF_Tag) * logsize);

		  for (i = 0; i < gstring.used; i++)

		    {

		      int idx = gstring.glyphs[i].positioning_type >> 4;

		      if (idx)

			log[i] = otf->gsub->FeatureList.Feature[idx - 1].FeatureTag;

		      else

			log[i] = 0;

		    }

		}

	      free (str);

	    }

	}

      if (otf->gpos)

	{

	  str = get_features (&otf->gpos->FeatureList, &gpos);

	  if (str)

	    {

	      OTF_drive_gpos_with_log (otf, &gstring,

				       script_name, langsys_name, str);

	      if (log)

		{

		  if (logsize < gstring.used)

		    {

		      OTF_Tag *log2 = alloca (sizeof (OTF_Tag) * gstring.used);

		      memset (log2, 0, sizeof (OTF_Tag) * gstring.used);

		      memcpy (log2, log, sizeof (OTF_Tag) * logsize);

		      logsize = gstring.used;

		      log = log2;

		    }

		}

	      else

		{

		  logsize = gstring.used;

		  log = alloca (sizeof (OTF_Tag) * logsize);

		  memset (log, 0, sizeof (OTF_Tag) * logsize);

		}

	      for (i = 0; i < gstring.used; i++)

		{

		  int idx = gstring.glyphs[i].positioning_type >> 4;

		  if (idx)

		    log[i] = otf->gpos->FeatureList.Feature[idx - 1].FeatureTag;

		}

	      free (str);

	    }

	}

    }

  prev = NULL;

  if (reversed)

    {

      OTF_Glyph temp;

      for (prev = gstring.glyphs, g = gstring.glyphs + gstring.used - 1;

	   prev < g; prev++, g--)

	temp = *prev, *prev = *g, *g = temp;

      for (g = gstring.glyphs; g < gstring.glyphs + gstring.used; g++)

	if (g->GlyphClass == 3)

	  {

	    OTF_Glyph *g0;

	    prev = g++;

	    while (g < gstring.glyphs + gstring.used && g->GlyphClass == 3)

	      g++;

	    for (g0 = g; prev < g0; prev++, g0--)

	      temp = *prev, *prev = *g, *g = temp;

	  }

    }

  mark = base = NULL;

  for (i = 0, x = glyph_x, prev = NULL, g = gstring.glyphs;

       i < gstring.used; i++, prev = g++)

    {

      BitmapRec *bmp = bitmap + gstring.glyphs[i].glyph_id;

      int xoff = 0, yoff = 0;

      int prev_width;

      int advance = bmp->advance;

      if (gstring.glyphs[i].glyph_id && ! bmp->pixmap)

	{

	  create_pixmap (gstring.glyphs[i].glyph_id);

	  if (! bmp->pixmap)

	    continue;

	  advance = bmp->advance;

	}

      if (g->positioning_type & 0xF)

	{

	  while (1)

	    {

	      switch (g->positioning_type & 0xF)

		{

		case 1: case 2:

		  {

		    int format = g->f.f1.format;

		    if (format & OTF_XPlacement)

		      xoff += g->f.f1.value->XPlacement * pixel_size / unitsPerEm;

		    if (format & OTF_XPlaDevice)

		      xoff += DEVICE_DELTA (g->f.f1.value->XPlaDevice, pixel_size);

		    if (format & OTF_YPlacement)

		      yoff += g->f.f1.value->YPlacement * pixel_size / unitsPerEm;

		    if (format & OTF_YPlaDevice)

		      yoff += DEVICE_DELTA (g->f.f1.value->YPlaDevice, pixel_size);

		    if (format & OTF_XAdvance)

		      advance += g->f.f1.value->XAdvance * pixel_size / unitsPerEm;

		    if (format & OTF_XAdvDevice)

		      advance += DEVICE_DELTA (g->f.f1.value->XAdvDevice,

					       pixel_size);

		  }

		  break;

		case 3:

		  /* Not yet supported.  */

		  break;

		case 4: case 5:

		  if (! base)

		    break;

		  prev = base;

		  prev_width = base_width;

		  goto label_adjust_anchor;

		default: 		/* i.e. case 6 */

		  if (! mark)

		    break;

		  prev = mark;

		  prev_width = 0;

		label_adjust_anchor:

		  {

		    int base_x, base_y, mark_x, mark_y;

		    base_x = g->f.f4.base_anchor->XCoordinate * pixel_size / unitsPerEm;

		    base_y = g->f.f4.base_anchor->YCoordinate * pixel_size / unitsPerEm;

		    mark_x = g->f.f4.mark_anchor->XCoordinate * pixel_size / unitsPerEm;

		    mark_y = g->f.f4.mark_anchor->YCoordinate * pixel_size / unitsPerEm;

		    if (g->f.f4.base_anchor->AnchorFormat != 1)

		      adjust_anchor (g->f.f4.base_anchor, face, prev, &base_x, &base_y);

		    if (g->f.f4.mark_anchor->AnchorFormat != 1)

		      adjust_anchor (g->f.f4.mark_anchor, face, g, &mark_x, &mark_y);

		    xoff = (base_x - prev_width) - mark_x;

		    yoff = base_y - mark_y;

		  }

		}

	      if (i + 1 == gstring.used

		  || gstring.glyphs[i + 1].glyph_id

		  || ! (gstring.glyphs[i + 1].positioning_type & 0xF))

		break;

	      i++, g++;

	    }

	}

      XCopyArea (display, bmp->pixmap, seq_pixmap, gc_or,

		 glyph_x + bmp->x, glyph_y + bmp->y, bmp->width, bmp->height,

		 x + bmp->x + xoff, glyph_y + bmp->y - yoff);

      x += advance;

      if (g->GlyphClass == OTF_GlyphClass0)

	base = mark = g, base_width = advance;

      else if (g->GlyphClass == OTF_GlyphClassMark)

	mark = g;

      else

	base = g, base_width = advance;

    }

  XtSetArg (arg[0], XtNbitmap, seq_pixmap);

  XtSetValues (seq_image, arg, 1);

  if (gstring.used > 0)

    {

      int size = render_width / FONT_WIDTH;

      char *buf = alloca (size + 1);

      char name[5];

      sprintf (buf, "%04X", gstring.glyphs[0].glyph_id);

      if (log && log[0])

	{

	  OTF_tag_name (log[0], name);

	  sprintf (buf + 4, " (%s)", name);

	  x = 11;

	}

      else

	x = 4;

      for (i = 1; i < gstring.used && x + 5 < size; i++, x += 5)

	{

	  sprintf (buf + x, " %04X", gstring.glyphs[i].glyph_id);

	  if (log && log[i] && x + 11 < size)

	    {

	      OTF_tag_name (log[i], name);

	      sprintf (buf + x + 5, "(%s)", name);

	      x += 6;

	    }

	}

      while (x < size)

	buf[x++] = ' ';

      buf[x] = '\0';

      XtSetArg (arg[0], XtNlabel, buf);

      XtSetValues (code_list, arg, 1);

    }

  free (gstring.glyphs);

}

void

update_render_area ()

{

  int i;

  int x;

  Arg arg[1];

  XFillRectangle (display, raw_pixmap, gc, 0, 0, render_width, render_height);

  for (i = 0, x = glyph_x; i < glyph_rec.n_glyphs; i++)

    {

      if (glyph_rec.glyphs[i] >= 0)

	{

	  BitmapRec *bmp = bitmap + glyph_rec.glyphs[i];

	  char buf[5];

	  XCopyArea (display, bmp->pixmap, raw_pixmap, gc,

		     0, 0, glyph_width, glyph_height,

		     (glyph_width + 4) * i + 1, 1);

	  XDrawRectangle (display, raw_pixmap, gc_set,

			  (glyph_width + 4) * i, 0,

			  glyph_width + 1, glyph_height + 1);

	  XDrawLine (display, raw_pixmap, gc_set,

		     (glyph_width + 4) * i + 1 + glyph_x, 1,

		     (glyph_width + 4) * i + 1 + glyph_x, glyph_height + 1);

	  XDrawLine (display, raw_pixmap, gc_set,

		     (glyph_width + 4) * i + 1 + glyph_x + bmp->advance, 1,

		     (glyph_width + 4) * i + 1 + glyph_x + bmp->advance,

		     glyph_height + 1);

	  sprintf (buf, "%04X", glyph_rec.codes[i]);

	  XDrawString (display, raw_pixmap, gc_inv, 

		       (glyph_width + 4) * i + 1

		       + (glyph_width - XTextWidth (font, buf, 4)) / 2,

		       glyph_height + 2 + FONT_HEIGHT, buf, 4);

	}

      else

	{

	  /* Variation Selector */

	  int idx = - glyph_rec.glyphs[i];

	  char buf[4];

	  sprintf (buf, "%03d", idx);

	  XDrawRectangle (display, raw_pixmap, gc_set,

			  (glyph_width + 4) * i, 0,

			  glyph_width + 1, glyph_height + 1);

	  XDrawString (display, raw_pixmap, gc_set,

		       (glyph_width + 4) * i + 1

		       + (glyph_width - XTextWidth (font, "VS", 2)) / 2,

		       1 + glyph_height / 2, "VS", 2);

	  XDrawString (display, raw_pixmap, gc_set,

		       (glyph_width + 4) * i + 1

		       + (glyph_width - XTextWidth (font, buf, 3)) / 2,

		       1 + glyph_height / 2 + FONT_ASCENT, buf, 3);

	}

    }

  XtSetArg (arg[0], XtNbitmap, raw_pixmap);

  XtSetValues (raw_image, arg, 1);

  update_seq_area ();

}

void

QuitProc (Widget w, XtPointer client_data, XtPointer call_data)

{

  XtAppSetExitFlag (XtWidgetToApplicationContext (w));

}

void

DumpProc (Widget w, XtPointer client_data, XtPointer call_data)

{

  int g_width, g_height;

  float g_x, g_y;

  /* unit in points (1/72 inch); to fit in both US-letter and A4 */

  static int xoff = 30, yoff = 30;

  static int unit = 30;

  static int margin = 2;

  static int title_height = 20, label_height = 10;

  int total_width = (unit + margin * 2) * 16;

  int total_height = (unit + margin * 2 + label_height) * 16 + title_height;

  /* pixel size (dots) */

  int size = 128;

  int i, j, k, l;

  char *name = alloca (strlen (filename) + 10);

  FILE *fp;

  int index = (glyph_index / 0x100) * 0x100;

  float scale;

  g_width = face->bbox.xMax - face->bbox.xMin;

  g_height = face->bbox.yMax - face->bbox.yMin;

  if (g_width > g_height)

    {

      scale = g_width * size;

      g_x = face->bbox.xMin * unit / g_width;

      g_y = face->bbox.yMin * unit / g_width;

    }

  else

    {

      scale = g_height * size;

      g_x = face->bbox.xMin * unit / g_height;

      g_y = face->bbox.yMin * unit / g_height;

    }

  scale /= face->units_per_EM;

  FT_Set_Pixel_Sizes (face, 0, size);

  sprintf (name, "%s-%04X.ps", face->family_name, index);

  printf ("Writing %s ... ", name);

  fflush (stdout);

  fp = fopen (name, "w");

  fprintf (fp, "%s\n", "%!PS-Adobe-2.0 EPSF-2.0");

  fprintf (fp, "%s\n", "%%Creater: otfview");

  fprintf (fp, "%s %s(%s)-%04X\n", "%%Title:",

	   face->family_name, face->style_name, index);

  fprintf (fp, "%s\n", "%%Pages: 1");

  fprintf (fp, "%s %d %d %d %d\n", "%%BoundingBox:",

	   xoff, yoff, xoff + total_width, yoff + total_height);

  fprintf (fp, "%s\n", "%%EndComments");

  fprintf (fp, "%s\n", "%%BeginProlog");

  fprintf (fp, "/W %d def\n", unit + margin * 2);

  fprintf (fp, "/H %d def\n", unit + margin * 2 + label_height);

  fprintf (fp, "/STR 10 string def\n");

  fprintf (fp, "/DrawIndex {\n");

  fprintf (fp, "  I 16 lt { (000) show } { I 256 lt { (00) show } { I 4096 lt { (0) show} if } ifelse } ifelse I 16 STR cvrs show\n");

  fprintf (fp, "} def\n");

  fprintf (fp, "/DrawTitle {\n");

  fprintf (fp, "  /Courier findfont 20 scalefont setfont\n");

  fprintf (fp, "  %d %d 4 add moveto\n", xoff + total_width / 2,

	   yoff + total_height - title_height + 2);

  fprintf (fp, "  (%s(%s)-%04X) dup stringwidth pop 2 div neg 0 rmoveto show\n",

	   face->family_name, face->style_name, index);

  fprintf (fp, "} def\n");

  fprintf (fp, "/DrawFrame { gsave %d %d translate 0 setlinewidth\n",

	   xoff, yoff);

  fprintf (fp, "  /Courier findfont 10 scalefont setfont\n");

  fprintf (fp, "  /I %d def\n", index);

  fprintf (fp, "  0 1 16 { W mul 0 moveto 0 H 16 mul rlineto stroke } for\n");

  fprintf (fp, "  0 1 16 { H mul 0 exch moveto W 16 mul 0 rlineto stroke } for\n");

  fprintf (fp, "  0 1 15 { H mul %d add 0 exch moveto W 16 mul 0 rlineto stroke } for\n", label_height);

  fprintf (fp, "  15 -1 0 { gsave H mul 0 exch translate 0 0 moveto\n");

  fprintf (fp, "    0 1 15 { gsave W mul 0 moveto\n");

  fprintf (fp, "      4 2 rmoveto DrawIndex /I I 1 add def grestore} for\n");

  fprintf (fp, "    grestore } for grestore } def\n");

  fprintf (fp, "%s\n", "%%EndProlog");

  fprintf (fp, "DrawTitle DrawFrame\n");

  for (i = 0; i < 16; i++)

    for (j = 0; j < 16; j++, index++)

      {

	int idx;

	if (charmap_index >= 0) 

	  idx = FT_Get_Char_Index (face, (FT_ULong) index);

	else

	  idx = index;

	if (idx > 0

	    && FT_Load_Glyph (face, idx, FT_LOAD_RENDER | FT_LOAD_MONOCHROME) == 0

	    && face->glyph->bitmap.rows > 0

	    && face->glyph->bitmap.width > 0)

	  {

	    unsigned char *p = face->glyph->bitmap.buffer;

	    int width = (face->glyph->bitmap.width - 1) / 8 + 1;

	    fprintf (fp, "gsave %f %f translate %d %d scale 0 0 moveto\n",

		     xoff + (unit + margin * 2) * j + margin - g_x,

		     yoff + (unit + label_height + margin * 2) * (15 - i) + label_height + margin - g_y,

		     unit, unit);

	    fprintf (fp, "%d %d true [%f 0 0 %f %d %d]\n",

		     width * 8, face->glyph->bitmap.rows,

		     scale, -scale, -face->glyph->bitmap_left,

		     face->glyph->bitmap_top);

	    fprintf (fp, "{< ");

	    for (k = 0; k < face->glyph->bitmap.rows;

		 k++, p += face->glyph->bitmap.pitch)

	      {

		for (l = 0; l < width; l++)

		  fprintf (fp, "%02X", p[l]);

		fprintf (fp, "\n");

	      }

	    fprintf (fp, ">} imagemask grestore\n");

	  }

	else

	  {

	    int boxsize = unit + margin * 2;

	    fprintf (fp, "gsave 0 setlinewidth %d %d translate\n",

		     xoff + boxsize * j,

		     yoff + (boxsize + label_height) * (15 - i) + label_height);

	    fprintf (fp, "0 0 moveto %d %d lineto stroke\n",

		     boxsize, boxsize);

	    fprintf (fp, "0 %d moveto %d 0 lineto stroke grestore\n",

		     boxsize, boxsize);

	  }

      }

  fprintf (fp, "showpage\n");

  fclose (fp);

  printf ("done\n");

  FT_Set_Pixel_Sizes (face, 0, (int) pixel_size);

}

void

GlyphProc (Widget w, XtPointer client_data, XtPointer call_data)

{

  int old_glyph_index = glyph_index;

  int data;

  CAST_FROM_XTPOINTER (int, client_data, data);

  if (data == -3 && glyph_index > 0)

    glyph_index = 0;

  else if (data == -2 && glyph_index > 0)

    glyph_index = (glyph_index - 1) & 0x1FF000;

  else if (data == -1 && glyph_index > 0)

    glyph_index -= 0x80;

  else if (data == 1 && glyph_index < 0x10FF80)

    glyph_index += 0x80;

  else if (data == 2 && glyph_index < 0x10F000)

    glyph_index = (glyph_index + 0x1000) & 0x1FF000;

  else if (data == 3 && glyph_index < 0x10F000)

    glyph_index = 0x10FF80;

  if (glyph_index != old_glyph_index)

    update_glyph_area ();

}

void

CharmapProc (Widget w, XtPointer client_data, XtPointer call_data)

{

  int data;

  CAST_FROM_XTPOINTER (int, client_data, data);

  if (charmap_index == data)

    return;

  charmap_index = data;

  if (charmap_index >= 0)

    FT_Set_Charmap (face, face->charmaps[charmap_index]);

  update_glyph_area ();

}

void

UVSProc (Widget w, XtPointer client_data, XtPointer call_data)

{

  unsigned idx;

  int selector;

  OTF_VariationSelectorRecord *record;

  int i;

  CAST_FROM_XTPOINTER (unsigned, client_data, idx);

  selector = uvs[idx].c;

  if (glyph_rec.n_glyphs >= 64)

    return;

  for (i = 0; i < sub14->nRecords; i++)

    {

      record = sub14->Records + i;

      if (record->varSelector == selector)

	break;

    }

  if (i < sub14->nRecords)

    {

      if (glyph_rec.n_glyphs > 0

	  && glyph_rec.glyphs[glyph_rec.n_glyphs - 1] < 0)

	glyph_rec.n_glyphs--;

      glyph_rec.codes[glyph_rec.n_glyphs] = selector;

      glyph_rec.glyphs[glyph_rec.n_glyphs++] = - idx - 1;

      update_render_area ();