font.c

   1 #include "imager.h"
   2 #include "imrender.h"
   3
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <fcntl.h>
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10
  11 #ifdef HAVE_LIBT1
  12 #endif
  13
  14
  15 /*
  16 =head1 NAME
  17
  18 font.c - implements font handling functions for t1 and truetype fonts
  19
  20 =head1 SYNOPSIS
  21
  22   i_init_fonts();
  23
  24   #ifdef HAVE_LIBT1
  25   fontnum = i_t1_new(path_to_pfb, path_to_afm);
  26   i_t1_bbox(fontnum, points, "foo", 3, i_img_dim cords[BOUNDING_BOX_COUNT]);
  27   rc = i_t1_destroy(fontnum);
  28   #endif
  29
  30   #ifdef HAVE_LIBTT
  31   handle = i_tt_new(path_to_ttf);
  32   rc = i_tt_bbox(handle, points, "foo", 3, int cords[6], utf8);
  33   i_tt_destroy(handle);
  34
  35   // and much more
  36
  37 =head1 DESCRIPTION
  38
  39 font.c implements font creation, rendering, bounding box functions and
  40 more for Imager.
  41
  42 =head1 FUNCTION REFERENCE
  43
  44 Some of these functions are internal.
  45
  46 =over
  47
  48 =cut
  49
  50 */
  51
  52
  53 /* Truetype font support */
  54 #ifdef HAVE_LIBTT
  55
  56 /* These are enabled by default when configuring Freetype 1.x
  57    I haven't a clue how to reliably detect it at compile time.
  58
  59    We need a compilation probe in Makefile.PL
  60 */
  61 #define FTXPOST 1
  62 #define FTXERR18 1
  63
  64 #include <freetype.h>
  65 #define TT_CHC 5
  66
  67 #ifdef FTXPOST
  68 #include <ftxpost.h>
  69 #endif
  70
  71 #ifdef FTXERR18
  72 #include <ftxerr18.h>
  73 #endif
  74
  75 /* some versions of FT1.x don't seem to define this - it's font defined
  76    so it won't change */
  77 #ifndef TT_MS_LANGID_ENGLISH_GENERAL
  78 #define TT_MS_LANGID_ENGLISH_GENERAL 0x0409
  79 #endif
  80
  81 /* convert a code point into an index in the glyph cache */
  82 #define TT_HASH(x) ((x) & 0xFF)
  83
  84 typedef struct i_glyph_entry_ {
  85   TT_Glyph glyph;
  86   unsigned long ch;
  87 } i_tt_glyph_entry;
  88
  89 #define TT_NOCHAR (~0UL)
  90
  91 struct TT_Instancehandle_ {
  92   TT_Instance instance;
  93   TT_Instance_Metrics imetrics;
  94   TT_Glyph_Metrics gmetrics[256];
  95   i_tt_glyph_entry glyphs[256];
  96   int smooth;
  97   int order;
  98   i_img_dim ptsize;
  99 };
 100
 101 typedef struct TT_Instancehandle_ TT_Instancehandle;
 102
 103 struct TT_Fonthandle_ {
 104   TT_Face face;
 105   TT_Face_Properties properties;
 106   TT_Instancehandle instanceh[TT_CHC];
 107   TT_CharMap char_map;
 108 #ifdef FTXPOST
 109   int loaded_names;
 110   TT_Error load_cond;
 111 #endif
 112 };
 113
 114 /* Defines */
 115
 116 #define USTRCT(x) ((x).z)
 117 #define TT_VALID( handle )  ( ( handle ).z != NULL )
 118
 119 static void i_tt_push_error(TT_Error rc);
 120
 121 /* Prototypes */
 122
 123 static  int i_tt_get_instance( TT_Fonthandle *handle, i_img_dim points, int smooth );
 124 static void i_tt_init_raster_map( TT_Raster_Map* bit, i_img_dim width, i_img_dim height, int smooth );
 125 static void i_tt_done_raster_map( TT_Raster_Map *bit );
 126 static void i_tt_clear_raster_map( TT_Raster_Map* bit );
 127 static void i_tt_blit_or( TT_Raster_Map *dst, TT_Raster_Map *src,i_img_dim x_off, i_img_dim y_off );
 128 static  int i_tt_get_glyph( TT_Fonthandle *handle, int inst, unsigned long j );
 129 static void
 130 i_tt_render_glyph( TT_Glyph glyph, TT_Glyph_Metrics* gmetrics,
 131                    TT_Raster_Map *bit, TT_Raster_Map *small_bit,
 132                    i_img_dim x_off, i_img_dim y_off, int smooth );
 133 static int
 134 i_tt_render_all_glyphs( TT_Fonthandle *handle, int inst, TT_Raster_Map *bit,
 135                         TT_Raster_Map *small_bit, i_img_dim cords[6],
 136                         char const* txt, size_t len, int smooth, int utf8 );
 137 static void i_tt_dump_raster_map2( i_img* im, TT_Raster_Map* bit, i_img_dim xb, i_img_dim yb, const i_color *cl, int smooth );
 138 static void i_tt_dump_raster_map_channel( i_img* im, TT_Raster_Map* bit, i_img_dim xb, i_img_dim yb, int channel, int smooth );
 139 static  int
 140 i_tt_rasterize( TT_Fonthandle *handle, TT_Raster_Map *bit, i_img_dim cords[6],
 141                 double points, char const* txt, size_t len, int smooth, int utf8 );
 142 static undef_int i_tt_bbox_inst( TT_Fonthandle *handle, int inst ,const char *txt, size_t len, i_img_dim cords[6], int utf8 );
 143
 144
 145 /* static globals needed */
 146
 147 static int TT_initialized = 0;
 148 static TT_Engine    engine;
 149 static int  LTT_dpi    = 72; /* FIXME: this ought to be a part of the call interface */
 150 static int  LTT_hinted = 1;  /* FIXME: this too */
 151
 152
 153 /*
 154  * FreeType interface
 155  */
 156
 157
 158 /*
 159 =item init_tt()
 160
 161 Initializes the freetype font rendering engine
 162
 163 =cut
 164 */
 165
 166 static undef_int
 167 i_init_tt(void) {
 168   TT_Error  error;
 169   TT_Byte palette[] = { 0, 64, 127, 191, 255 };
 170
 171   i_clear_error();
 172
 173   mm_log((1,"init_tt()\n"));
 174   error = TT_Init_FreeType( &engine );
 175   if ( error ){
 176     mm_log((1,"Initialization of freetype failed, code = 0x%x\n",
 177             (unsigned)error));
 178     i_tt_push_error(error);
 179     i_push_error(0, "Could not initialize freetype 1.x");
 180     return(1);
 181   }
 182
 183 #ifdef FTXPOST
 184   error = TT_Init_Post_Extension( engine );
 185   if (error) {
 186     mm_log((1, "Initialization of Post extension failed = 0x%x\n",
 187             (unsigned)error));
 188
 189     i_tt_push_error(error);
 190     i_push_error(0, "Could not initialize FT 1.x POST extension");
 191     return 1;
 192   }
 193 #endif
 194
 195   error = TT_Set_Raster_Gray_Palette(engine, palette);
 196   if (error) {
 197     mm_log((1, "Initialization of gray levels failed = 0x%x\n",
 198             (unsigned)error));
 199     i_tt_push_error(error);
 200     i_push_error(0, "Could not initialize FT 1.x POST extension");
 201     return 1;
 202   }
 203
 204   TT_initialized = 1;
 205
 206   return(0);
 207 }
 208
 209
 210 /*
 211 =item i_tt_get_instance(handle, points, smooth)
 212
 213 Finds a points+smooth instance or if one doesn't exist in the cache
 214 allocates room and returns its cache entry
 215
 216    fontname - path to the font to load
 217    handle   - handle to the font.
 218    points   - points of the requested font
 219    smooth   - boolean (True: antialias on, False: antialias is off)
 220
 221 =cut
 222 */
 223
 224 static
 225 int
 226 i_tt_get_instance( TT_Fonthandle *handle, i_img_dim points, int smooth ) {
 227   int i,idx;
 228   TT_Error error;
 229
 230   mm_log((1,"i_tt_get_instance(handle %p, points %" i_DF ", smooth %d)\n",
 231           handle, i_DFc(points), smooth));
 232
 233   if (smooth == -1) { /* Smooth doesn't matter for this search */
 234     for(i=0;i<TT_CHC;i++) {
 235       if (handle->instanceh[i].ptsize==points) {
 236         mm_log((1,"i_tt_get_instance: in cache - (non selective smoothing search) returning %d\n",i));
 237         return i;
 238       }
 239     }
 240     smooth=1; /* We will be adding a font - add it as smooth then */
 241   } else { /* Smooth doesn't matter for this search */
 242     for(i=0;i<TT_CHC;i++) {
 243       if (handle->instanceh[i].ptsize == points
 244           && handle->instanceh[i].smooth == smooth) {
 245         mm_log((1,"i_tt_get_instance: in cache returning %d\n",i));
 246         return i;
 247       }
 248     }
 249   }
 250
 251   /* Found the instance in the cache - return the cache index */
 252
 253   for(idx=0;idx<TT_CHC;idx++) {
 254     if (!(handle->instanceh[idx].order)) break; /* find the lru item */
 255   }
 256
 257   mm_log((1,"i_tt_get_instance: lru item is %d\n",idx));
 258   mm_log((1,"i_tt_get_instance: lru pointer %p\n",
 259           USTRCT(handle->instanceh[idx].instance) ));
 260
 261   if ( USTRCT(handle->instanceh[idx].instance) ) {
 262     mm_log((1,"i_tt_get_instance: freeing lru item from cache %d\n",idx));
 263
 264     /* Free cached glyphs */
 265     for(i=0;i<256;i++)
 266       if ( USTRCT(handle->instanceh[idx].glyphs[i].glyph) )
 267         TT_Done_Glyph( handle->instanceh[idx].glyphs[i].glyph );
 268
 269     for(i=0;i<256;i++) {
 270       handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
 271       USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
 272     }
 273
 274     /* Free instance if needed */
 275     TT_Done_Instance( handle->instanceh[idx].instance );
 276   }
 277
 278   /* create and initialize instance */
 279   /* FIXME: probably a memory leak on fail */
 280
 281   (void) (( error = TT_New_Instance( handle->face, &handle->instanceh[idx].instance ) ) ||
 282           ( error = TT_Set_Instance_Resolutions( handle->instanceh[idx].instance, LTT_dpi, LTT_dpi ) ) ||
 283           ( error = TT_Set_Instance_CharSize( handle->instanceh[idx].instance, points*64 ) ) );
 284
 285   if ( error ) {
 286     mm_log((1, "Could not create and initialize instance: error %x.\n",
 287             (unsigned)error ));
 288     return -1;
 289   }
 290
 291   /* Now that the instance should the inplace we need to lower all of the
 292      ru counts and put `this' one with the highest entry */
 293
 294   for(i=0;i<TT_CHC;i++) handle->instanceh[i].order--;
 295
 296   handle->instanceh[idx].order=TT_CHC-1;
 297   handle->instanceh[idx].ptsize=points;
 298   handle->instanceh[idx].smooth=smooth;
 299   TT_Get_Instance_Metrics( handle->instanceh[idx].instance, &(handle->instanceh[idx].imetrics) );
 300
 301   /* Zero the memory for the glyph storage so they are not thought as
 302      cached if they haven't been cached since this new font was loaded */
 303
 304   for(i=0;i<256;i++) {
 305     handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
 306     USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
 307   }
 308
 309   return idx;
 310 }
 311
 312
 313 /*
 314 =item i_tt_new(fontname)
 315
 316 Creates a new font handle object, finds a character map and initialise the
 317 the font handle's cache
 318
 319    fontname - path to the font to load
 320
 321 =cut
 322 */
 323
 324 TT_Fonthandle*
 325 i_tt_new(const char *fontname) {
 326   TT_Error error;
 327   TT_Fonthandle *handle;
 328   unsigned short i,n;
 329   unsigned short platform,encoding;
 330
 331   if (!TT_initialized && i_init_tt()) {
 332     i_push_error(0, "Could not initialize FT1 engine");
 333     return NULL;
 334   }
 335
 336   i_clear_error();
 337
 338   mm_log((1,"i_tt_new(fontname '%s')\n",fontname));
 339
 340   /* allocate memory for the structure */
 341
 342   handle = mymalloc( sizeof(TT_Fonthandle) ); /* checked 5Nov05 tonyc */
 343
 344   /* load the typeface */
 345   error = TT_Open_Face( engine, fontname, &handle->face );
 346   if ( error ) {
 347     if ( error == TT_Err_Could_Not_Open_File ) {
 348       mm_log((1, "Could not find/open %s.\n", fontname ));
 349     }
 350     else {
 351       mm_log((1, "Error while opening %s, error code = 0x%x.\n",fontname,
 352               (unsigned)error ));
 353     }
 354     i_tt_push_error(error);
 355     return NULL;
 356   }
 357
 358   TT_Get_Face_Properties( handle->face, &(handle->properties) );
 359
 360   /* First, look for a Unicode charmap */
 361   n = handle->properties.num_CharMaps;
 362   USTRCT( handle->char_map )=NULL; /* Invalidate character map */
 363
 364   for ( i = 0; i < n; i++ ) {
 365     TT_Get_CharMap_ID( handle->face, i, &platform, &encoding );
 366     if ( (platform == 3 && encoding == 1 )
 367          || (platform == 0 && encoding == 0 ) ) {
 368       mm_log((2,"i_tt_new - found char map platform %u encoding %u\n",
 369               platform, encoding));
 370       TT_Get_CharMap( handle->face, i, &(handle->char_map) );
 371       break;
 372     }
 373   }
 374   if (!USTRCT(handle->char_map) && n != 0) {
 375     /* just use the first one */
 376     TT_Get_CharMap( handle->face, 0, &(handle->char_map));
 377   }
 378
 379   /* Zero the pointsizes - and ordering */
 380
 381   for(i=0;i<TT_CHC;i++) {
 382     USTRCT(handle->instanceh[i].instance)=NULL;
 383     handle->instanceh[i].order=i;
 384     handle->instanceh[i].ptsize=0;
 385     handle->instanceh[i].smooth=-1;
 386   }
 387
 388 #ifdef FTXPOST
 389   handle->loaded_names = 0;
 390 #endif
 391
 392   mm_log((1,"i_tt_new <- %p\n",handle));
 393   return handle;
 394 }
 395
 396
 397
 398 /*
 399  *Â raster map management
 400  */
 401
 402 /*
 403 =item i_tt_init_raster_map(bit, width, height, smooth)
 404
 405 Allocates internal memory for the bitmap as needed by the parameters (internal)
 406
 407    bit    - bitmap to allocate into
 408    width  - width of the bitmap
 409    height - height of the bitmap
 410    smooth - boolean (True: antialias on, False: antialias is off)
 411
 412 =cut
 413 */
 414
 415 static
 416 void
 417 i_tt_init_raster_map( TT_Raster_Map* bit, i_img_dim width, i_img_dim height, int smooth ) {
 418
 419   mm_log((1,"i_tt_init_raster_map( bit %p, width %" i_DF ", height %" i_DF
 420           ", smooth %d)\n", bit, i_DFc(width), i_DFc(height), smooth));
 421
 422   bit->rows  = height;
 423   bit->width = ( width + 3 ) & -4;
 424   bit->flow  = TT_Flow_Down;
 425
 426   if ( smooth ) {
 427     bit->cols  = bit->width;
 428     bit->size  = bit->rows * bit->width;
 429   } else {
 430     bit->cols  = ( bit->width + 7 ) / 8;    /* convert to # of bytes     */
 431     bit->size  = bit->rows * bit->cols;     /* number of bytes in buffer */
 432   }
 433
 434   /* rows can be 0 for some glyphs, for example ' ' */
 435   if (bit->rows && bit->size / bit->rows != bit->cols) {
 436     i_fatal(0, "Integer overflow calculating bitmap size (%d, %d)\n",
 437             bit->width, bit->rows);
 438   }
 439
 440   mm_log((1,"i_tt_init_raster_map: bit->width %d, bit->cols %d, bit->rows %d, bit->size %ld)\n", bit->width, bit->cols, bit->rows, bit->size ));
 441
 442   bit->bitmap = (void *) mymalloc( bit->size ); /* checked 6Nov05 tonyc */
 443   if ( !bit->bitmap ) i_fatal(0,"Not enough memory to allocate bitmap (%d)!\n",bit->size );
 444 }
 445
 446
 447 /*
 448 =item i_tt_clear_raster_map(bit)
 449
 450 Frees the bitmap data and sets pointer to NULL (internal)
 451
 452    bit - bitmap to free
 453
 454 =cut
 455 */
 456
 457 static
 458 void
 459 i_tt_done_raster_map( TT_Raster_Map *bit ) {
 460   myfree( bit->bitmap );
 461   bit->bitmap = NULL;
 462 }
 463
 464
 465 /*
 466 =item i_tt_clear_raster_map(bit)
 467
 468 Clears the specified bitmap (internal)
 469
 470    bit - bitmap to zero
 471
 472 =cut
 473 */
 474
 475
 476 static
 477 void
 478 i_tt_clear_raster_map( TT_Raster_Map*  bit ) {
 479   memset( bit->bitmap, 0, bit->size );
 480 }
 481
 482
 483 /*
 484 =item i_tt_blit_or(dst, src, x_off, y_off)
 485
 486 function that blits one raster map into another (internal)
 487
 488    dst   - destination bitmap
 489    src   - source bitmap
 490    x_off - x offset into the destination bitmap
 491    y_off - y offset into the destination bitmap
 492
 493 =cut
 494 */
 495
 496 static
 497 void
 498 i_tt_blit_or( TT_Raster_Map *dst, TT_Raster_Map *src,i_img_dim x_off, i_img_dim y_off ) {
 499   i_img_dim  x,  y;
 500   i_img_dim  x1, x2, y1, y2;
 501   unsigned char *s, *d;
 502
 503   x1 = x_off < 0 ? -x_off : 0;
 504   y1 = y_off < 0 ? -y_off : 0;
 505
 506   x2 = (int)dst->cols - x_off;
 507   if ( x2 > src->cols ) x2 = src->cols;
 508
 509   y2 = (int)dst->rows - y_off;
 510   if ( y2 > src->rows ) y2 = src->rows;
 511
 512   if ( x1 >= x2 ) return;
 513
 514   /* do the real work now */
 515
 516   for ( y = y1; y < y2; ++y ) {
 517     s = ( (unsigned char*)src->bitmap ) + y * src->cols + x1;
 518     d = ( (unsigned char*)dst->bitmap ) + ( y + y_off ) * dst->cols + x1 + x_off;
 519
 520     for ( x = x1; x < x2; ++x ) {
 521       if (*s > *d)
 522         *d = *s;
 523       d++;
 524       s++;
 525     }
 526   }
 527 }
 528
 529 /* useful for debugging */
 530 #if 0
 531
 532 static void dump_raster_map(FILE *out, TT_Raster_Map *bit ) {
 533   int x, y;
 534   fprintf(out, "cols %d rows %d  flow %d\n", bit->cols, bit->rows, bit->flow);
 535   for (y = 0; y < bit->rows; ++y) {
 536     fprintf(out, "%2d:", y);
 537     for (x = 0; x < bit->cols; ++x) {
 538       if ((x & 7) == 0 && x) putc(' ', out);
 539       fprintf(out, "%02x", ((unsigned char *)bit->bitmap)[y*bit->cols+x]);
 540     }
 541     putc('\n', out);
 542   }
 543 }
 544
 545 #endif
 546
 547 /*
 548 =item i_tt_get_glyph(handle, inst, j)
 549
 550 Function to see if a glyph exists and if so cache it (internal)
 551
 552    handle - pointer to font handle
 553    inst   - font instance
 554    j      - charcode of glyph
 555
 556 =cut
 557 */
 558
 559 static
 560 int
 561 i_tt_get_glyph( TT_Fonthandle *handle, int inst, unsigned long j) {
 562   unsigned short load_flags, code;
 563   TT_Error error;
 564
 565   mm_log((1, "i_tt_get_glyph(handle %p, inst %d, j %lu (%c))\n",
 566           handle,inst,j, (int)((j >= ' ' && j <= '~') ? j : '.')));
 567
 568   /*mm_log((1, "handle->instanceh[inst].glyphs[j]=0x%08X\n",handle->instanceh[inst].glyphs[j] ));*/
 569
 570   if ( TT_VALID(handle->instanceh[inst].glyphs[TT_HASH(j)].glyph)
 571        && handle->instanceh[inst].glyphs[TT_HASH(j)].ch == j) {
 572     mm_log((1,"i_tt_get_glyph: %lu in cache\n",j));
 573     return 1;
 574   }
 575
 576   if ( TT_VALID(handle->instanceh[inst].glyphs[TT_HASH(j)].glyph) ) {
 577     /* clean up the entry */
 578     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
 579     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
 580     handle->instanceh[inst].glyphs[TT_HASH(j)].ch = TT_NOCHAR;
 581   }
 582
 583   /* Ok - it wasn't cached - try to get it in */
 584   load_flags = TTLOAD_SCALE_GLYPH;
 585   if ( LTT_hinted ) load_flags |= TTLOAD_HINT_GLYPH;
 586
 587   if ( !TT_VALID(handle->char_map) ) {
 588     code = (j - ' ' + 1) < 0 ? 0 : (j - ' ' + 1);
 589     if ( code >= handle->properties.num_Glyphs ) code = 0;
 590   } else code = TT_Char_Index( handle->char_map, j );
 591
 592   if ( (error = TT_New_Glyph( handle->face, &handle->instanceh[inst].glyphs[TT_HASH(j)].glyph)) ) {
 593     mm_log((1, "Cannot allocate and load glyph: error %#x.\n", (unsigned)error ));
 594     i_push_error(error, "TT_New_Glyph()");
 595     return 0;
 596   }
 597   if ( (error = TT_Load_Glyph( handle->instanceh[inst].instance, handle->instanceh[inst].glyphs[TT_HASH(j)].glyph, code, load_flags)) ) {
 598     mm_log((1, "Cannot allocate and load glyph: error %#x.\n", (unsigned)error ));
 599     /* Don't leak */
 600     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
 601     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
 602     i_push_error(error, "TT_Load_Glyph()");
 603     return 0;
 604   }
 605
 606   /* At this point the glyph should be allocated and loaded */
 607   handle->instanceh[inst].glyphs[TT_HASH(j)].ch = j;
 608
 609   /* Next get the glyph metrics */
 610   error = TT_Get_Glyph_Metrics( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph,
 611                                 &handle->instanceh[inst].gmetrics[TT_HASH(j)] );
 612   if (error) {
 613     mm_log((1, "TT_Get_Glyph_Metrics: error %#x.\n", (unsigned)error ));
 614     TT_Done_Glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph );
 615     USTRCT( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph ) = NULL;
 616     handle->instanceh[inst].glyphs[TT_HASH(j)].ch = TT_NOCHAR;
 617     i_push_error(error, "TT_Get_Glyph_Metrics()");
 618     return 0;
 619   }
 620
 621   return 1;
 622 }
 623
 624 /*
 625 =item i_tt_has_chars(handle, text, len, utf8, out)
 626
 627 Check if the given characters are defined by the font.  Note that len
 628 is the number of bytes, not the number of characters (when utf8 is
 629 non-zero).
 630
 631 Returns the number of characters that were checked.
 632
 633 =cut
 634 */
 635
 636 size_t
 637 i_tt_has_chars(TT_Fonthandle *handle, char const *text, size_t len, int utf8,
 638                char *out) {
 639   size_t count = 0;
 640   mm_log((1, "i_tt_has_chars(handle %p, text %p, len %ld, utf8 %d)\n",
 641           handle, text, (long)len, utf8));
 642
 643   while (len) {
 644     unsigned long c;
 645     int index;
 646     if (utf8) {
 647       c = i_utf8_advance(&text, &len);
 648       if (c == ~0UL) {
 649         i_push_error(0, "invalid UTF8 character");
 650         return 0;
 651       }
 652     }
 653     else {
 654       c = (unsigned char)*text++;
 655       --len;
 656     }
 657
 658     if (TT_VALID(handle->char_map)) {
 659       index = TT_Char_Index(handle->char_map, c);
 660     }
 661     else {
 662       index = (c - ' ' + 1) < 0 ? 0 : (c - ' ' + 1);
 663       if (index >= handle->properties.num_Glyphs)
 664         index = 0;
 665     }
 666     *out++ = index != 0;
 667     ++count;
 668   }
 669
 670   return count;
 671 }
 672
 673 /*
 674 =item i_tt_destroy(handle)
 675
 676 Clears the data taken by a font including all cached data such as
 677 pixmaps and glyphs
 678
 679    handle - pointer to font handle
 680
 681 =cut
 682 */
 683
 684 void
 685 i_tt_destroy( TT_Fonthandle *handle) {
 686   TT_Close_Face( handle->face );
 687   myfree( handle );
 688
 689   /* FIXME: Should these be freed automatically by the library?
 690
 691   TT_Done_Instance( instance );
 692   void
 693     i_tt_done_glyphs( void ) {
 694     int  i;
 695
 696     if ( !glyphs ) return;
 697
 698     for ( i = 0; i < 256; ++i ) TT_Done_Glyph( glyphs[i] );
 699     free( glyphs );
 700
 701     glyphs = NULL;
 702   }
 703   */
 704 }
 705
 706
 707 /*
 708  * FreeType Rendering functions
 709  */
 710
 711
 712 /*
 713 =item i_tt_render_glyph(handle, gmetrics, bit, smallbit, x_off, y_off, smooth)
 714
 715 Renders a single glyph into the bit rastermap (internal)
 716
 717    handle   - pointer to font handle
 718    gmetrics - the metrics for the glyph to be rendered
 719    bit      - large bitmap that is the destination for the text
 720    smallbit - small bitmap that is used only if smooth is true
 721    x_off    - x offset of glyph
 722    y_off    - y offset of glyph
 723    smooth   - boolean (True: antialias on, False: antialias is off)
 724
 725 =cut
 726 */
 727
 728 static
 729 void
 730 i_tt_render_glyph( TT_Glyph glyph, TT_Glyph_Metrics* gmetrics, TT_Raster_Map *bit, TT_Raster_Map *small_bit, i_img_dim x_off, i_img_dim y_off, int smooth ) {
 731
 732   mm_log((1,"i_tt_render_glyph(glyph %p, gmetrics %p, bit %p, small_bit %p, x_off %" i_DF ", y_off %" i_DF ", smooth %d)\n",
 733           USTRCT(glyph), gmetrics, bit, small_bit, i_DFc(x_off),
 734           i_DFc(y_off), smooth));
 735
 736   if ( !smooth ) TT_Get_Glyph_Bitmap( glyph, bit, x_off * 64, y_off * 64);
 737   else {
 738     TT_F26Dot6 xmin, ymin, xmax, ymax;
 739
 740     xmin =  gmetrics->bbox.xMin & -64;
 741     ymin =  gmetrics->bbox.yMin & -64;
 742     xmax = (gmetrics->bbox.xMax + 63) & -64;
 743     ymax = (gmetrics->bbox.yMax + 63) & -64;
 744
 745     i_tt_clear_raster_map( small_bit );
 746     TT_Get_Glyph_Pixmap( glyph, small_bit, -xmin, -ymin );
 747     i_tt_blit_or( bit, small_bit, xmin/64 + x_off, -ymin/64 - y_off );
 748   }
 749 }
 750
 751
 752 /*
 753 =item i_tt_render_all_glyphs(handle, inst, bit, small_bit, cords, txt, len, smooth)
 754
 755 calls i_tt_render_glyph to render each glyph into the bit rastermap (internal)
 756
 757    handle   - pointer to font handle
 758    inst     - font instance
 759    bit      - large bitmap that is the destination for the text
 760    smallbit - small bitmap that is used only if smooth is true
 761    txt      - string to render
 762    len      - length of the string to render
 763    smooth   - boolean (True: antialias on, False: antialias is off)
 764
 765 =cut
 766 */
 767
 768 static
 769 int
 770 i_tt_render_all_glyphs( TT_Fonthandle *handle, int inst, TT_Raster_Map *bit,
 771                         TT_Raster_Map *small_bit, i_img_dim cords[6],
 772                         char const* txt, size_t len, int smooth, int utf8 ) {
 773   unsigned long j;
 774   TT_F26Dot6 x,y;
 775
 776   mm_log((1,"i_tt_render_all_glyphs( handle %p, inst %d, bit %p, small_bit %p, txt '%.*s', len %ld, smooth %d, utf8 %d)\n",
 777           handle, inst, bit, small_bit, (int)len, txt, (long)len, smooth, utf8));
 778
 779   /*
 780      y=-( handle->properties.horizontal->Descender * handle->instanceh[inst].imetrics.y_ppem )/(handle->properties.header->Units_Per_EM);
 781   */
 782
 783   x=-cords[0]; /* FIXME: If you font is antialiased this should be expanded by one to allow for aa expansion and the allocation too - do before passing here */
 784   y=-cords[4];
 785
 786   while (len) {
 787     if (utf8) {
 788       j = i_utf8_advance(&txt, &len);
 789       if (j == ~0UL) {
 790         i_push_error(0, "invalid UTF8 character");
 791         return 0;
 792       }
 793     }
 794     else {
 795       j = (unsigned char)*txt++;
 796       --len;
 797     }
 798     if ( !i_tt_get_glyph(handle,inst,j) )
 799       continue;
 800     i_tt_render_glyph( handle->instanceh[inst].glyphs[TT_HASH(j)].glyph,
 801                        &handle->instanceh[inst].gmetrics[TT_HASH(j)], bit,
 802                        small_bit, x, y, smooth );
 803     x += handle->instanceh[inst].gmetrics[TT_HASH(j)].advance / 64;
 804   }
 805
 806   return 1;
 807 }
 808
 809
 810 /*
 811  * Functions to render rasters (single channel images) onto images
 812  */
 813
 814 /*
 815 =item i_tt_dump_raster_map2(im, bit, xb, yb, cl, smooth)
 816
 817 Function to dump a raster onto an image in color used by i_tt_text() (internal).
 818
 819    im     - image to dump raster on
 820    bit    - bitmap that contains the text to be dumped to im
 821    xb, yb - coordinates, left edge and baseline
 822    cl     - color to use for text
 823    smooth - boolean (True: antialias on, False: antialias is off)
 824
 825 =cut
 826 */
 827
 828 static
 829 void
 830 i_tt_dump_raster_map2( i_img* im, TT_Raster_Map* bit, i_img_dim xb, i_img_dim yb, const i_color *cl, int smooth ) {
 831   unsigned char *bmap;
 832   i_img_dim x, y;
 833   mm_log((1,"i_tt_dump_raster_map2(im %p, bit %p, xb %" i_DF ", yb %" i_DF ", cl %p)\n",
 834           im, bit, i_DFc(xb), i_DFc(yb), cl));
 835
 836   bmap = bit->bitmap;
 837
 838   if ( smooth ) {
 839
 840     i_render r;
 841     i_render_init(&r, im, bit->cols);
 842     for(y=0;y<bit->rows;y++) {
 843       i_render_color(&r, xb, yb+y, bit->cols, bmap + y*bit->cols, cl);
 844     }
 845     i_render_done(&r);
 846   } else {
 847     for(y=0;y<bit->rows;y++) {
 848       unsigned mask = 0x80;
 849       unsigned char *p = bmap + y * bit->cols;
 850
 851       for(x = 0; x < bit->width; x++) {
 852         if (*p & mask) {
 853           i_ppix(im, x+xb, y+yb, cl);
 854         }
 855         mask >>= 1;
 856         if (!mask) {
 857           mask = 0x80;
 858           ++p;
 859         }
 860       }
 861     }
 862
 863   }
 864 }
 865
 866
 867 /*
 868 =item i_tt_dump_raster_map_channel(im, bit, xb, yb, channel, smooth)
 869
 870 Function to dump a raster onto a single channel image in color (internal)
 871
 872    im      - image to dump raster on
 873    bit     - bitmap that contains the text to be dumped to im
 874    xb, yb  - coordinates, left edge and baseline
 875    channel - channel to copy to
 876    smooth  - boolean (True: antialias on, False: antialias is off)
 877
 878 =cut
 879 */
 880
 881 static
 882 void
 883 i_tt_dump_raster_map_channel( i_img* im, TT_Raster_Map*  bit, i_img_dim xb, i_img_dim yb, int channel, int smooth ) {
 884   unsigned char *bmap;
 885   i_color val;
 886   int c;
 887   i_img_dim x,y;
 888   int old_mask = im->ch_mask;
 889   im->ch_mask = 1 << channel;
 890
 891   mm_log((1,"i_tt_dump_raster_channel(im %p, bit %p, xb %" i_DF ", yb %" i_DF ", channel %d)\n",
 892           im, bit, i_DFc(xb), i_DFc(yb), channel));
 893
 894   bmap = bit->bitmap;
 895
 896   if ( smooth ) {
 897     for(y=0;y<bit->rows;y++) for(x=0;x<bit->width;x++) {
 898       c = bmap[y*(bit->cols)+x];
 899       val.channel[channel] = c;
 900       i_ppix(im,x+xb,y+yb,&val);
 901     }
 902   } else {
 903     for(y=0;y<bit->rows;y++) {
 904       unsigned mask = 0x80;
 905       unsigned char *p = bmap + y * bit->cols;
 906
 907       for(x=0;x<bit->width;x++) {
 908         val.channel[channel] = (*p & mask) ? 255 : 0;
 909         i_ppix(im,x+xb,y+yb,&val);
 910
 911         mask >>= 1;
 912         if (!mask) {
 913           ++p;
 914           mask = 0x80;
 915         }
 916       }
 917     }
 918   }
 919   im->ch_mask = old_mask;
 920 }
 921
 922
 923 /*
 924 =item i_tt_rasterize(handle, bit, cords, points, txt, len, smooth)
 925
 926 interface for generating single channel raster of text (internal)
 927
 928    handle - pointer to font handle
 929    bit    - the bitmap that is allocated, rendered into and NOT freed
 930    cords  - the bounding box (modified in place)
 931    points - font size to use
 932    txt    - string to render
 933    len    - length of the string to render
 934    smooth - boolean (True: antialias on, False: antialias is off)
 935
 936 =cut
 937 */
 938
 939 static
 940 int
 941 i_tt_rasterize( TT_Fonthandle *handle, TT_Raster_Map *bit, i_img_dim cords[6], double points, char const* txt, size_t len, int smooth, int utf8 ) {
 942   int inst;
 943   i_img_dim width, height;
 944   TT_Raster_Map small_bit;
 945
 946   /* find or install an instance */
 947   if ( (inst=i_tt_get_instance(handle,points,smooth)) < 0) {
 948     mm_log((1,"i_tt_rasterize: get instance failed\n"));
 949     return 0;
 950   }
 951
 952   /* calculate bounding box */
 953   if (!i_tt_bbox_inst( handle, inst, txt, len, cords, utf8 ))
 954     return 0;
 955
 956
 957   width  = cords[2]-cords[0];
 958   height = cords[5]-cords[4];
 959
 960   mm_log((1,"i_tt_rasterize: width=%" i_DF ", height=%" i_DF "\n",
 961           i_DFc(width), i_DFc(height) ));
 962
 963   i_tt_init_raster_map ( bit, width, height, smooth );
 964   i_tt_clear_raster_map( bit );
 965   if ( smooth ) i_tt_init_raster_map( &small_bit, handle->instanceh[inst].imetrics.x_ppem + 32, height, smooth );
 966
 967   if (!i_tt_render_all_glyphs( handle, inst, bit, &small_bit, cords, txt, len,
 968                                smooth, utf8 )) {
 969     if ( smooth )
 970       i_tt_done_raster_map( &small_bit );
 971     return 0;
 972   }
 973
 974   if ( smooth ) i_tt_done_raster_map( &small_bit );
 975   return 1;
 976 }
 977
 978
 979
 980 /*
 981  * Exported text rendering interfaces
 982  */
 983
 984
 985 /*
 986 =item i_tt_cp(handle, im, xb, yb, channel, points, txt, len, smooth, utf8)
 987
 988 Interface to text rendering into a single channel in an image
 989
 990    handle  - pointer to font handle
 991    im      - image to render text on to
 992    xb, yb  - coordinates, left edge and baseline
 993    channel - channel to render into
 994    points  - font size to use
 995    txt     - string to render
 996    len     - length of the string to render
 997    smooth  - boolean (True: antialias on, False: antialias is off)
 998
 999 =cut
1000 */
1001
1002 undef_int
1003 i_tt_cp( TT_Fonthandle *handle, i_img *im, i_img_dim xb, i_img_dim yb, int channel, double points, char const* txt, size_t len, int smooth, int utf8, int align ) {
1004
1005   i_img_dim cords[BOUNDING_BOX_COUNT];
1006   i_img_dim ascent, st_offset, y;
1007   TT_Raster_Map bit;
1008
1009   i_clear_error();
1010   if (! i_tt_rasterize( handle, &bit, cords, points, txt, len, smooth, utf8 ) ) return 0;
1011
1012   ascent=cords[BBOX_ASCENT];
1013   st_offset=cords[BBOX_NEG_WIDTH];
1014   y = align ? yb-ascent : yb;
1015
1016   i_tt_dump_raster_map_channel( im, &bit, xb-st_offset , y, channel, smooth );
1017   i_tt_done_raster_map( &bit );
1018
1019   return 1;
1020 }
1021
1022
1023 /*
1024 =item i_tt_text(handle, im, xb, yb, cl, points, txt, len, smooth, utf8)
1025
1026 Interface to text rendering in a single color onto an image
1027
1028    handle  - pointer to font handle
1029    im      - image to render text on to
1030    xb, yb  - coordinates, left edge and baseline
1031    cl      - color to use for text
1032    points  - font size to use
1033    txt     - string to render
1034    len     - length of the string to render
1035    smooth  - boolean (True: antialias on, False: antialias is off)
1036
1037 =cut
1038 */
1039
1040 undef_int
1041 i_tt_text( TT_Fonthandle *handle, i_img *im, i_img_dim xb, i_img_dim yb, const i_color *cl, double points, char const* txt, size_t len, int smooth, int utf8, int align) {
1042   i_img_dim cords[BOUNDING_BOX_COUNT];
1043   i_img_dim ascent, st_offset, y;
1044   TT_Raster_Map bit;
1045
1046   i_clear_error();
1047
1048   if (! i_tt_rasterize( handle, &bit, cords, points, txt, len, smooth, utf8 ) ) return 0;
1049
1050   ascent=cords[BBOX_ASCENT];
1051   st_offset=cords[BBOX_NEG_WIDTH];
1052   y = align ? yb-ascent : yb;
1053
1054   i_tt_dump_raster_map2( im, &bit, xb+st_offset, y, cl, smooth );
1055   i_tt_done_raster_map( &bit );
1056
1057   return 1;
1058 }
1059
1060
1061 /*
1062 =item i_tt_bbox_inst(handle, inst, txt, len, cords, utf8)
1063
1064 Function to get texts bounding boxes given the instance of the font (internal)
1065
1066    handle - pointer to font handle
1067    inst   -  font instance
1068    txt    -  string to measure
1069    len    -  length of the string to render
1070    cords  - the bounding box (modified in place)
1071
1072 =cut
1073 */
1074
1075 static
1076 undef_int
1077 i_tt_bbox_inst( TT_Fonthandle *handle, int inst ,const char *txt, size_t len, i_img_dim cords[BOUNDING_BOX_COUNT], int utf8 ) {
1078   int upm, casc, cdesc, first;
1079
1080   int start    = 0;
1081   i_img_dim width    = 0;
1082   int gdescent = 0;
1083   int gascent  = 0;
1084   int descent  = 0;
1085   int ascent   = 0;
1086   int rightb   = 0;
1087
1088   unsigned long j;
1089   unsigned char *ustr;
1090   ustr=(unsigned char*)txt;
1091
1092   mm_log((1,"i_tt_box_inst(handle %p,inst %d,txt '%.*s', len %ld, utf8 %d)\n",
1093           handle, inst, (int)len, txt, (long)len, utf8));
1094
1095   upm     = handle->properties.header->Units_Per_EM;
1096   gascent  = ( handle->properties.horizontal->Ascender  * handle->instanceh[inst].imetrics.y_ppem + upm - 1) / upm;
1097   gdescent = ( handle->properties.horizontal->Descender * handle->instanceh[inst].imetrics.y_ppem - upm + 1) / upm;
1098
1099   width   = 0;
1100   start   = 0;
1101
1102   mm_log((1, "i_tt_box_inst: gascent=%d gdescent=%d\n", gascent, gdescent));
1103
1104   first=1;
1105   while (len) {
1106     if (utf8) {
1107       j = i_utf8_advance(&txt, &len);
1108       if (j == ~0UL) {
1109         i_push_error(0, "invalid UTF8 character");
1110         return 0;
1111       }
1112     }
1113     else {
1114       j = (unsigned char)*txt++;
1115       --len;
1116     }
1117     if ( i_tt_get_glyph(handle,inst,j) ) {
1118       TT_Glyph_Metrics *gm = handle->instanceh[inst].gmetrics + TT_HASH(j);
1119       width += gm->advance   / 64;
1120       casc   = (gm->bbox.yMax+63) / 64;
1121       cdesc  = (gm->bbox.yMin-63) / 64;
1122
1123       mm_log((1, "i_tt_box_inst: glyph='%c' casc=%d cdesc=%d\n",
1124               (int)((j >= ' ' && j <= '~') ? j : '.'), casc, cdesc));
1125
1126       if (first) {
1127         start    = gm->bbox.xMin / 64;
1128         ascent   = (gm->bbox.yMax+63) / 64;
1129         descent  = (gm->bbox.yMin-63) / 64;
1130         first = 0;
1131       }
1132       if (!len) { /* if at end of string */
1133         /* the right-side bearing - in case the right-side of a
1134            character goes past the right of the advance width,
1135            as is common for italic fonts
1136         */
1137         rightb = gm->advance - gm->bearingX
1138           - (gm->bbox.xMax - gm->bbox.xMin);
1139         /* fprintf(stderr, "font info last: %d %d %d %d\n",
1140            gm->bbox.xMax, gm->bbox.xMin, gm->advance, rightb); */
1141       }
1142
1143       ascent  = (ascent  >  casc ?  ascent : casc );
1144       descent = (descent < cdesc ? descent : cdesc);
1145     }
1146   }
1147
1148   cords[BBOX_NEG_WIDTH]=start;
1149   cords[BBOX_GLOBAL_DESCENT]=gdescent;
1150   cords[BBOX_POS_WIDTH]=width;
1151   if (rightb < 0)
1152     cords[BBOX_POS_WIDTH] -= rightb / 64;
1153   cords[BBOX_GLOBAL_ASCENT]=gascent;
1154   cords[BBOX_DESCENT]=descent;
1155   cords[BBOX_ASCENT]=ascent;
1156   cords[BBOX_ADVANCE_WIDTH] = width;
1157   cords[BBOX_RIGHT_BEARING] = rightb / 64;
1158
1159   return BBOX_RIGHT_BEARING + 1;
1160 }
1161
1162
1163 /*
1164 =item i_tt_bbox(handle, points, txt, len, cords, utf8)
1165
1166 Interface to get a strings bounding box
1167
1168    handle - pointer to font handle
1169    points - font size to use
1170    txt    - string to render
1171    len    - length of the string to render
1172    cords  - the bounding box (modified in place)
1173
1174 =cut
1175 */
1176
1177 undef_int
1178 i_tt_bbox( TT_Fonthandle *handle, double points,const char *txt,size_t len,i_img_dim cords[6], int utf8) {
1179   int inst;
1180
1181   i_clear_error();
1182   mm_log((1,"i_tt_box(handle %p,points %f,txt '%.*s', len %ld, utf8 %d)\n",
1183           handle, points, (int)len, txt, (long)len, utf8));
1184
1185   if ( (inst=i_tt_get_instance(handle,points,-1)) < 0) {
1186     i_push_errorf(0, "i_tt_get_instance(%g)", points);
1187     mm_log((1,"i_tt_text: get instance failed\n"));
1188     return 0;
1189   }
1190
1191   return i_tt_bbox_inst(handle, inst, txt, len, cords, utf8);
1192 }
1193
1194 /*
1195 =item i_tt_face_name(handle, name_buf, name_buf_size)
1196
1197 Retrieve's the font's postscript name.
1198
1199 This is complicated by the need to handle encodings and so on.
1200
1201 =cut
1202  */
1203 size_t
1204 i_tt_face_name(TT_Fonthandle *handle, char *name_buf, size_t name_buf_size) {
1205   TT_Face_Properties props;
1206   int name_count;
1207   int i;
1208   TT_UShort platform_id, encoding_id, lang_id, name_id;
1209   TT_UShort name_len;
1210   TT_String *name;
1211   int want_index = -1; /* an acceptable but not perfect name */
1212   int score = 0;
1213
1214   i_clear_error();
1215
1216   TT_Get_Face_Properties(handle->face, &props);
1217   name_count = props.num_Names;
1218   for (i = 0; i < name_count; ++i) {
1219     TT_Get_Name_ID(handle->face, i, &platform_id, &encoding_id, &lang_id,
1220                    &name_id);
1221
1222     TT_Get_Name_String(handle->face, i, &name, &name_len);
1223
1224     if (platform_id != TT_PLATFORM_APPLE_UNICODE && name_len
1225         && name_id == TT_NAME_ID_PS_NAME) {
1226       int might_want_index = -1;
1227       int might_score = 0;
1228       if ((platform_id == TT_PLATFORM_MACINTOSH && encoding_id == TT_MAC_ID_ROMAN)
1229           ||
1230           (platform_id == TT_PLATFORM_MICROSOFT && encoding_id == TT_MS_LANGID_ENGLISH_UNITED_STATES)) {
1231         /* exactly what we want */
1232         want_index = i;
1233         break;
1234       }
1235
1236       if (platform_id == TT_PLATFORM_MICROSOFT
1237           && (encoding_id & 0xFF) == TT_MS_LANGID_ENGLISH_GENERAL) {
1238         /* any english is good */
1239         might_want_index = i;
1240         might_score = 9;
1241       }
1242       /* there might be something in between */
1243       else {
1244         /* anything non-unicode is better than nothing */
1245         might_want_index = i;
1246         might_score = 1;
1247       }
1248       if (might_score > score) {
1249         score = might_score;
1250         want_index = might_want_index;
1251       }
1252     }
1253   }
1254
1255   if (want_index != -1) {
1256     TT_Get_Name_String(handle->face, want_index, &name, &name_len);
1257
1258     strncpy(name_buf, name, name_buf_size);
1259     name_buf[name_buf_size-1] = '\0';
1260
1261     return strlen(name) + 1;
1262   }
1263   else {
1264     i_push_error(0, "no face name present");
1265     return 0;
1266   }
1267 }
1268
1269 void i_tt_dump_names(TT_Fonthandle *handle) {
1270   TT_Face_Properties props;
1271   int name_count;
1272   int i;
1273   TT_UShort platform_id, encoding_id, lang_id, name_id;
1274   TT_UShort name_len;
1275   TT_String *name;
1276
1277   TT_Get_Face_Properties(handle->face, &props);
1278   name_count = props.num_Names;
1279   for (i = 0; i < name_count; ++i) {
1280     TT_Get_Name_ID(handle->face, i, &platform_id, &encoding_id, &lang_id,
1281                    &name_id);
1282     TT_Get_Name_String(handle->face, i, &name, &name_len);
1283
1284     printf("# %d: plat %d enc %d lang %d name %d value ", i, platform_id,
1285            encoding_id, lang_id, name_id);
1286     if (platform_id == TT_PLATFORM_APPLE_UNICODE) {
1287       printf("(unicode)\n");
1288     }
1289     else {
1290       printf("'%s'\n", name);
1291     }
1292   }
1293   fflush(stdout);
1294 }
1295
1296 size_t
1297 i_tt_glyph_name(TT_Fonthandle *handle, unsigned long ch, char *name_buf,
1298                  size_t name_buf_size) {
1299 #ifdef FTXPOST
1300   TT_Error rc;
1301   TT_String *psname;
1302   TT_UShort index;
1303
1304   i_clear_error();
1305
1306   if (!handle->loaded_names) {
1307     TT_Post post;
1308     mm_log((1, "Loading PS Names"));
1309     handle->load_cond = TT_Load_PS_Names(handle->face, &post);
1310     ++handle->loaded_names;
1311   }
1312
1313   if (handle->load_cond) {
1314     i_push_errorf(handle->load_cond, "error loading names (%#x)",
1315                   (unsigned)handle->load_cond);
1316     return 0;
1317   }
1318
1319   index = TT_Char_Index(handle->char_map, ch);
1320   if (!index) {
1321     i_push_error(0, "no such character");
1322     return 0;
1323   }
1324
1325   rc = TT_Get_PS_Name(handle->face, index, &psname);
1326
1327   if (rc) {
1328     i_push_error(rc, "error getting name");
1329     return 0;
1330   }
1331
1332   strncpy(name_buf, psname, name_buf_size);
1333   name_buf[name_buf_size-1] = '\0';
1334
1335   return strlen(psname) + 1;
1336 #else
1337   mm_log((1, "FTXPOST extension not enabled\n"));
1338   i_clear_error();
1339   i_push_error(0, "Use of FTXPOST extension disabled");
1340
1341   return 0;
1342 #endif
1343 }
1344
1345 /*
1346 =item i_tt_push_error(code)
1347
1348 Push an error message and code onto the Imager error stack.
1349
1350 =cut
1351 */
1352 static void
1353 i_tt_push_error(TT_Error rc) {
1354 #ifdef FTXERR18
1355   TT_String const *msg = TT_ErrToString18(rc);
1356
1357   i_push_error(rc, msg);
1358 #else
1359   i_push_errorf(rc, "Error code 0x%04x", (unsigned)rc);
1360 #endif
1361 }
1362
1363 #endif /* HAVE_LIBTT */
1364
1365
1366 /*
1367 =back
1368
1369 =head1 AUTHOR
1370
1371 Arnar M. Hrafnkelsson <addi@umich.edu>
1372
1373 =head1 SEE ALSO
1374
1375 Imager(3)
1376
1377 =cut
1378 */