flood_fill() wouldn't fill the right side of a single scan-line fill area.
[imager.git] / freetyp2.c
1 /*
2 =head1 NAME
3
4 freetyp2.c - font support via the FreeType library version 2.
5
6 =head1 SYNOPSIS
7
8   if (!i_ft2_init()) { error }
9   FT2_Fonthandle *font;
10   font = i_ft2_new(name, index);
11   if (!i_ft2_setdpi(font, xdpi, ydpi)) { error }
12   if (!i_ft2_getdpi(font, &xdpi, &ydpi)) { error }
13   double matrix[6];
14   if (!i_ft2_settransform(font, matrix)) { error }
15   int bbox[BOUNDING_BOX_COUNT];
16   if (!i_ft2_bbox(font, cheight, cwidth, text, length, bbox, utf8)) { error }
17   i_img *im = ...;
18   i_color cl;
19   if (!i_ft2_text(font, im, tx, ty, cl, cheight, cwidth, text, length, align,
20                   aa)) { error }
21   if (!i_ft2_cp(font, im, tx, ty, channel, cheight, cwidth, text, length,
22                 align, aa)) { error }
23   i_ft2_destroy(font);
24
25 =head1 DESCRIPTION
26
27 Implements Imager font support using the FreeType2 library.
28
29 The FreeType2 library understands several font file types, including
30 Truetype, Type1 and Windows FNT.
31
32 =over 
33
34 =cut
35 */
36
37 #include "imager.h"
38 #include <stdio.h>
39 #include <ft2build.h>
40 #include FT_FREETYPE_H
41 #ifdef FT_MULTIPLE_MASTERS_H
42 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
43 #define IM_FT2_MM
44 #include FT_MULTIPLE_MASTERS_H
45 #endif
46 #endif
47
48 static void ft2_push_message(int code);
49
50 static int ft2_initialized = 0;
51 static FT_Library library;
52
53 /*
54 =item i_ft2_init(void)
55
56 Initializes the Freetype 2 library.
57
58 Returns true on success, false on failure.
59
60 =cut
61 */
62 int
63 i_ft2_init(void) {
64   FT_Error error;
65
66   i_clear_error();
67   error = FT_Init_FreeType(&library);
68   if (error) {
69     ft2_push_message(error);
70     i_push_error(0, "Initializing Freetype2");
71     return 0;
72   }
73
74   ft2_initialized = 1;
75
76   return 1;
77 }
78
79 struct FT2_Fonthandle {
80   FT_Face face;
81   int xdpi, ydpi;
82   int hint;
83   FT_Encoding encoding;
84
85   /* used to adjust so we can align the draw point to the top-left */
86   double matrix[6];
87
88 #ifdef IM_FT2_MM
89   /* Multiple master data if any */
90   int has_mm;
91   FT_Multi_Master mm;
92 #endif
93 };
94
95 /* the following is used to select a "best" encoding */
96 static struct enc_score {
97   FT_Encoding encoding;
98   int score;
99 } enc_scores[] =
100 {
101   /* the selections here are fairly arbitrary
102      ideally we need to give the user a list of encodings available
103      and a mechanism to choose one */
104   { ft_encoding_unicode,        10 },
105   { ft_encoding_sjis,            8 },
106   { ft_encoding_gb2312,          8 },
107   { ft_encoding_big5,            8 },
108   { ft_encoding_wansung,         8 },
109   { ft_encoding_johab,           8 },  
110   { ft_encoding_latin_2,         6 },
111   { ft_encoding_apple_roman,     6 },
112   { ft_encoding_adobe_standard,  6 },
113   { ft_encoding_adobe_expert,    6 },
114 };
115
116 /*
117 =item i_ft2_new(char *name, int index)
118
119 Creates a new font object, from the file given by I<name>.  I<index>
120 is the index of the font in a file with multiple fonts, where 0 is the
121 first font.
122
123 Return NULL on failure.
124
125 =cut
126 */
127
128 FT2_Fonthandle *
129 i_ft2_new(const char *name, int index) {
130   FT_Error error;
131   FT2_Fonthandle *result;
132   FT_Face face;
133   int i, j;
134   FT_Encoding encoding;
135   int score;
136
137   mm_log((1, "i_ft2_new(name %p, index %d)\n", name, index));
138
139   if (!ft2_initialized && !i_ft2_init())
140     return NULL;
141
142   i_clear_error();
143   error = FT_New_Face(library, name, index, &face);
144   if (error) {
145     ft2_push_message(error);
146     i_push_error(error, "Opening face");
147     mm_log((2, "error opening face '%s': %d\n", name, error));
148     return NULL;
149   }
150
151   encoding = face->num_charmaps ? face->charmaps[0]->encoding : ft_encoding_unicode;
152   score = 0;
153   for (i = 0; i < face->num_charmaps; ++i) {
154     FT_Encoding enc_entry = face->charmaps[i]->encoding;
155     mm_log((2, "i_ft2_new, encoding %lX platform %u encoding %u\n",
156             enc_entry, face->charmaps[i]->platform_id,
157             face->charmaps[i]->encoding_id));
158     for (j = 0; j < sizeof(enc_scores) / sizeof(*enc_scores); ++j) {
159       if (enc_scores[j].encoding == enc_entry && enc_scores[j].score > score) {
160         encoding = enc_entry;
161         score = enc_scores[j].score;
162         break;
163       }
164     }
165   }
166   FT_Select_Charmap(face, encoding);
167   mm_log((2, "i_ft2_new, selected encoding %lX\n", encoding));
168
169   result = mymalloc(sizeof(FT2_Fonthandle));
170   result->face = face;
171   result->xdpi = result->ydpi = 72;
172   result->encoding = encoding;
173
174   /* by default we disable hinting on a call to i_ft2_settransform()
175      if we don't do this, then the hinting can the untransformed text
176      to be a different size to the transformed text.
177      Obviously we have it initially enabled.
178   */
179   result->hint = 1; 
180
181   /* I originally forgot this:   :/ */
182   /*i_ft2_settransform(result, matrix); */
183   result->matrix[0] = 1; result->matrix[1] = 0; result->matrix[2] = 0;
184   result->matrix[3] = 0; result->matrix[4] = 1; result->matrix[5] = 0;
185
186 #ifdef IM_FT2_MM
187  {
188    FT_Multi_Master *mm = &result->mm;
189    int i;
190
191    if ((face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) != 0 
192        && (error = FT_Get_Multi_Master(face, mm)) == 0) {
193      mm_log((2, "MM Font, %d axes, %d designs\n", mm->num_axis, mm->num_designs));
194      for (i = 0; i < mm->num_axis; ++i) {
195        mm_log((2, "  axis %d name %s range %ld - %ld\n", i, mm->axis[i].name,
196                (long)(mm->axis[i].minimum), (long)(mm->axis[i].maximum)));
197      }
198      result->has_mm = 1;
199    }
200    else {
201      mm_log((2, "No multiple masters\n"));
202      result->has_mm = 0;
203    }
204  }
205 #endif
206
207   return result;
208 }
209
210 /*
211 =item i_ft2_destroy(FT2_Fonthandle *handle)
212
213 Destroys a font object, which must have been the return value of
214 i_ft2_new().
215
216 =cut
217 */
218 void
219 i_ft2_destroy(FT2_Fonthandle *handle) {
220   FT_Done_Face(handle->face);
221   myfree(handle);
222 }
223
224 /*
225 =item i_ft2_setdpi(FT2_Fonthandle *handle, int xdpi, int ydpi)
226
227 Sets the resolution in dots per inch at which point sizes scaled, by
228 default xdpi and ydpi are 72, so that 1 point maps to 1 pixel.
229
230 Both xdpi and ydpi should be positive.
231
232 Return true on success.
233
234 =cut
235 */
236 int
237 i_ft2_setdpi(FT2_Fonthandle *handle, int xdpi, int ydpi) {
238   i_clear_error();
239   if (xdpi > 0 && ydpi > 0) {
240     handle->xdpi = xdpi;
241     handle->ydpi = ydpi;
242     return 0;
243   }
244   else {
245     i_push_error(0, "resolutions must be positive");
246     return 0;
247   }
248 }
249
250 /*
251 =item i_ft2_getdpi(FT2_Fonthandle *handle, int *xdpi, int *ydpi)
252
253 Retrieves the current horizontal and vertical resolutions at which
254 point sizes are scaled.
255
256 =cut
257 */
258 int
259 i_ft2_getdpi(FT2_Fonthandle *handle, int *xdpi, int *ydpi) {
260   *xdpi = handle->xdpi;
261   *ydpi = handle->ydpi;
262
263   return 1;
264 }
265
266 /*
267 =item i_ft2_settransform(FT2_FontHandle *handle, double *matrix)
268
269 Sets a transormation matrix for output.
270
271 This should be a 2 x 3 matrix like:
272
273  matrix[0]   matrix[1]   matrix[2]
274  matrix[3]   matrix[4]   matrix[5]
275
276 =cut
277 */
278 int
279 i_ft2_settransform(FT2_Fonthandle *handle, const double *matrix) {
280   FT_Matrix m;
281   FT_Vector v;
282   int i;
283
284   m.xx = matrix[0] * 65536;
285   m.xy = matrix[1] * 65536;
286   v.x  = matrix[2]; /* this could be pels of 26.6 fixed - not sure */
287   m.yx = matrix[3] * 65536;
288   m.yy = matrix[4] * 65536;
289   v.y  = matrix[5]; /* see just above */
290
291   FT_Set_Transform(handle->face, &m, &v);
292
293   for (i = 0; i < 6; ++i)
294     handle->matrix[i] = matrix[i];
295   handle->hint = 0;
296
297   return 1;
298 }
299
300 /*
301 =item i_ft2_sethinting(FT2_Fonthandle *handle, int hinting)
302
303 If hinting is non-zero then glyph hinting is enabled, otherwise disabled.
304
305 i_ft2_settransform() disables hinting to prevent distortions in
306 gradual text transformations.
307
308 =cut
309 */
310 int i_ft2_sethinting(FT2_Fonthandle *handle, int hinting) {
311   handle->hint = hinting;
312   return 1;
313 }
314
315 /*
316 =item i_ft2_bbox(FT2_Fonthandle *handle, double cheight, double cwidth, char *text, size_t len, int *bbox)
317
318 Retrieves bounding box information for the font at the given 
319 character width and height.  This ignores the transformation matrix.
320
321 Returns non-zero on success.
322
323 =cut
324 */
325 int
326 i_ft2_bbox(FT2_Fonthandle *handle, double cheight, double cwidth, 
327            char const *text, size_t len, int *bbox, int utf8) {
328   FT_Error error;
329   int width;
330   int index;
331   int first;
332   int ascent = 0, descent = 0;
333   int glyph_ascent, glyph_descent;
334   FT_Glyph_Metrics *gm;
335   int start = 0;
336   int loadFlags = FT_LOAD_DEFAULT;
337   int rightb = 0;
338
339   mm_log((1, "i_ft2_bbox(handle %p, cheight %f, cwidth %f, text %p, len %d, bbox %p)\n",
340           handle, cheight, cwidth, text, len, bbox));
341
342   error = FT_Set_Char_Size(handle->face, cwidth*64, cheight*64, 
343                            handle->xdpi, handle->ydpi);
344   if (error) {
345     ft2_push_message(error);
346     i_push_error(0, "setting size");
347   }
348
349   if (!handle->hint)
350     loadFlags |= FT_LOAD_NO_HINTING;
351
352   first = 1;
353   width = 0;
354   while (len) {
355     unsigned long c;
356     if (utf8) {
357       c = i_utf8_advance(&text, &len);
358       if (c == ~0UL) {
359         i_push_error(0, "invalid UTF8 character");
360         return 0;
361       }
362     }
363     else {
364       c = (unsigned char)*text++;
365       --len;
366     }
367
368     index = FT_Get_Char_Index(handle->face, c);
369     error = FT_Load_Glyph(handle->face, index, loadFlags);
370     if (error) {
371       ft2_push_message(error);
372       i_push_errorf(0, "loading glyph for character \\x%02x (glyph 0x%04X)", 
373                     c, index);
374       return 0;
375     }
376     gm = &handle->face->glyph->metrics;
377     glyph_ascent = gm->horiBearingY / 64;
378     glyph_descent = glyph_ascent - gm->height/64;
379     if (first) {
380       start = gm->horiBearingX / 64;
381       /* handles -ve values properly */
382       ascent = glyph_ascent;
383       descent = glyph_descent;
384       first = 0;
385     }
386
387     if (glyph_ascent > ascent)
388       ascent = glyph_ascent;
389     if (glyph_descent < descent)
390       descent = glyph_descent;
391
392     width += gm->horiAdvance / 64;
393
394     if (len == 0) {
395       /* last character 
396        handle the case where the right the of the character overlaps the 
397        right*/
398       rightb = (gm->horiAdvance - gm->horiBearingX - gm->width)/64;
399       /*if (rightb > 0)
400         rightb = 0;*/
401     }
402   }
403
404   bbox[BBOX_NEG_WIDTH] = start;
405   bbox[BBOX_GLOBAL_DESCENT] = handle->face->size->metrics.descender / 64;
406   bbox[BBOX_POS_WIDTH] = width;
407   if (rightb < 0)
408     bbox[BBOX_POS_WIDTH] -= rightb;
409   bbox[BBOX_GLOBAL_ASCENT] = handle->face->size->metrics.ascender / 64;
410   bbox[BBOX_DESCENT] = descent;
411   bbox[BBOX_ASCENT] = ascent;
412   bbox[BBOX_ADVANCE_WIDTH] = width;
413   bbox[BBOX_RIGHT_BEARING] = rightb;
414   mm_log((1, " bbox=> negw=%d glob_desc=%d pos_wid=%d glob_asc=%d desc=%d asc=%d adv_width=%d rightb=%d\n", bbox[0], bbox[1], bbox[2], bbox[3], bbox[4], bbox[5], bbox[6], bbox[7]));
415
416   return BBOX_RIGHT_BEARING + 1;
417 }
418
419 /*
420 =item transform_box(FT2_FontHandle *handle, int bbox[4])
421
422 bbox contains coorinates of a the top-left and bottom-right of a bounding 
423 box relative to a point.
424
425 This is then transformed and the values in bbox[4] are the top-left
426 and bottom-right of the new bounding box.
427
428 This is meant to provide the bounding box of a transformed character
429 box.  The problem is that if the character was round and is rotated,
430 the real bounding box isn't going to be much different from the
431 original, but this function will return a _bigger_ bounding box.  I
432 suppose I could work my way through the glyph outline, but that's
433 too much hard work.
434
435 =cut
436 */
437 void ft2_transform_box(FT2_Fonthandle *handle, int bbox[4]) {
438   double work[8];
439   double *matrix = handle->matrix;
440   
441   work[0] = matrix[0] * bbox[0] + matrix[1] * bbox[1];
442   work[1] = matrix[3] * bbox[0] + matrix[4] * bbox[1];
443   work[2] = matrix[0] * bbox[2] + matrix[1] * bbox[1];
444   work[3] = matrix[3] * bbox[2] + matrix[4] * bbox[1];
445   work[4] = matrix[0] * bbox[0] + matrix[1] * bbox[3];
446   work[5] = matrix[3] * bbox[0] + matrix[4] * bbox[3];
447   work[6] = matrix[0] * bbox[2] + matrix[1] * bbox[3];
448   work[7] = matrix[3] * bbox[2] + matrix[4] * bbox[3];
449
450   bbox[0] = floor(i_min(i_min(work[0], work[2]),i_min(work[4], work[6])));
451   bbox[1] = floor(i_min(i_min(work[1], work[3]),i_min(work[5], work[7])));
452   bbox[2] = ceil(i_max(i_max(work[0], work[2]),i_max(work[4], work[6])));
453   bbox[3] = ceil(i_max(i_max(work[1], work[3]),i_max(work[5], work[7])));
454 }
455
456 /*
457 =item expand_bounds(int bbox[4], int bbox2[4]) 
458
459 Treating bbox[] and bbox2[] as 2 bounding boxes, produces a new
460 bounding box in bbox[] that encloses both.
461
462 =cut
463 */
464 static void expand_bounds(int bbox[4], int bbox2[4]) {
465   bbox[0] = i_min(bbox[0], bbox2[0]);
466   bbox[1] = i_min(bbox[1], bbox2[1]);
467   bbox[2] = i_max(bbox[2], bbox2[2]);
468   bbox[3] = i_max(bbox[3], bbox2[3]);
469 }
470
471 /*
472 =item i_ft2_bbox_r(FT2_Fonthandle *handle, double cheight, double cwidth, char *text, size_t len, int vlayout, int utf8, int *bbox)
473
474 Retrieves bounding box information for the font at the given 
475 character width and height.
476
477 This version finds the rectangular bounding box of the glyphs, with
478 the text as transformed by the transformation matrix.  As with
479 i_ft2_bbox (bbox[0], bbox[1]) will the the offset from the start of
480 the topline to the top-left of the bounding box.  Unlike i_ft2_bbox()
481 this could be near the bottom left corner of the box.
482
483 (bbox[4], bbox[5]) is the offset to the start of the baseline.
484 (bbox[6], bbox[7]) is the offset from the start of the baseline to the
485 end of the baseline.
486
487 Returns non-zero on success.
488
489 =cut
490 */
491 int
492 i_ft2_bbox_r(FT2_Fonthandle *handle, double cheight, double cwidth, 
493            char const *text, size_t len, int vlayout, int utf8, int *bbox) {
494   FT_Error error;
495   int width;
496   int index;
497   int first;
498   int ascent = 0, descent = 0;
499   int glyph_ascent, glyph_descent;
500   FT_Glyph_Metrics *gm;
501   int work[4];
502   int bounds[4];
503   double x = 0, y = 0;
504   int i;
505   FT_GlyphSlot slot;
506   int loadFlags = FT_LOAD_DEFAULT;
507
508   if (vlayout)
509     loadFlags |= FT_LOAD_VERTICAL_LAYOUT;
510   if (!handle->hint)
511     loadFlags |= FT_LOAD_NO_HINTING;
512
513   error = FT_Set_Char_Size(handle->face, cwidth*64, cheight*64, 
514                            handle->xdpi, handle->ydpi);
515   if (error) {
516     ft2_push_message(error);
517     i_push_error(0, "setting size");
518   }
519
520   first = 1;
521   width = 0;
522   while (len) {
523     unsigned long c;
524     if (utf8) {
525       c = i_utf8_advance(&text, &len);
526       if (c == ~0UL) {
527         i_push_error(0, "invalid UTF8 character");
528         return 0;
529       }
530     }
531     else {
532       c = (unsigned char)*text++;
533       --len;
534     }
535
536     index = FT_Get_Char_Index(handle->face, c);
537     error = FT_Load_Glyph(handle->face, index, loadFlags);
538     if (error) {
539       ft2_push_message(error);
540       i_push_errorf(0, "loading glyph for character \\x%02x (glyph 0x%04X)", 
541                     c, index);
542       return 0;
543     }
544     slot = handle->face->glyph; 
545     gm = &slot->metrics;
546
547     /* these probably don't mean much for vertical layouts */
548     glyph_ascent = gm->horiBearingY / 64;
549     glyph_descent = glyph_ascent - gm->height/64;
550     if (vlayout) {
551       work[0] = gm->vertBearingX;
552       work[1] = gm->vertBearingY;
553     }
554     else {
555       work[0] = gm->horiBearingX;
556       work[1] = gm->horiBearingY;
557     }
558     work[2] = gm->width  + work[0];
559     work[3] = work[1] - gm->height;
560     if (first) {
561       bbox[4] = work[0] * handle->matrix[0] + work[1] * handle->matrix[1] + handle->matrix[2];
562       bbox[5] = work[0] * handle->matrix[3] + work[1] * handle->matrix[4] + handle->matrix[5];
563       bbox[4] = bbox[4] < 0 ? -(-bbox[4] + 32)/64 : (bbox[4] + 32) / 64;
564       bbox[5] /= 64;
565     }
566     ft2_transform_box(handle, work);
567     for (i = 0; i < 4; ++i)
568       work[i] /= 64;
569     work[0] += x;
570     work[1] += y;
571     work[2] += x;
572     work[3] += y;
573     if (first) {
574       for (i = 0; i < 4; ++i)
575         bounds[i] = work[i];
576       ascent = glyph_ascent;
577       descent = glyph_descent;
578       first = 0;
579     }
580     else {
581       expand_bounds(bounds, work);
582     }
583     x += slot->advance.x / 64;
584     y += slot->advance.y / 64;
585
586     if (glyph_ascent > ascent)
587       ascent = glyph_ascent;
588     if (glyph_descent > descent)
589       descent = glyph_descent;
590
591     if (len == 0) {
592       /* last character 
593        handle the case where the right the of the character overlaps the 
594        right*/
595       /*int rightb = gm->horiAdvance - gm->horiBearingX - gm->width;
596       if (rightb < 0)
597       width -= rightb / 64;*/
598     }
599   }
600
601   /* at this point bounds contains the bounds relative to the CP,
602      and x, y hold the final position relative to the CP */
603   /*bounds[0] -= x;
604   bounds[1] -= y;
605   bounds[2] -= x;
606   bounds[3] -= y;*/
607
608   bbox[0] = bounds[0];
609   bbox[1] = -bounds[3];
610   bbox[2] = bounds[2];
611   bbox[3] = -bounds[1];
612   bbox[6] = x;
613   bbox[7] = -y;
614
615   return 1;
616 }
617
618 static int
619 make_bmp_map(FT_Bitmap *bitmap, unsigned char *map);
620
621 /*
622 =item i_ft2_text(FT2_Fonthandle *handle, i_img *im, int tx, int ty, i_color *cl, double cheight, double cwidth, char *text, size_t len, int align, int aa)
623
624 Renders I<text> to (I<tx>, I<ty>) in I<im> using color I<cl> at the given 
625 I<cheight> and I<cwidth>.
626
627 If align is 0, then the text is rendered with the top-left of the
628 first character at (I<tx>, I<ty>).  If align is non-zero then the text
629 is rendered with (I<tx>, I<ty>) aligned with the base-line of the
630 characters.
631
632 If aa is non-zero then the text is anti-aliased.
633
634 Returns non-zero on success.
635
636 =cut
637 */
638 int
639 i_ft2_text(FT2_Fonthandle *handle, i_img *im, int tx, int ty, const i_color *cl,
640            double cheight, double cwidth, char const *text, size_t len,
641            int align, int aa, int vlayout, int utf8) {
642   FT_Error error;
643   int index;
644   FT_Glyph_Metrics *gm;
645   int bbox[BOUNDING_BOX_COUNT];
646   FT_GlyphSlot slot;
647   int x, y;
648   unsigned char *bmp;
649   unsigned char map[256];
650   char last_mode = ft_pixel_mode_none; 
651   int last_grays = -1;
652   int loadFlags = FT_LOAD_DEFAULT;
653   i_render render;
654
655   mm_log((1, "i_ft2_text(handle %p, im %p, tx %d, ty %d, cl %p, cheight %f, cwidth %f, text %p, len %d, align %d, aa %d)\n",
656           handle, im, tx, ty, cl, cheight, cwidth, text, align, aa));
657
658   if (vlayout) {
659     if (!FT_HAS_VERTICAL(handle->face)) {
660       i_push_error(0, "face has no vertical metrics");
661       return 0;
662     }
663     loadFlags |= FT_LOAD_VERTICAL_LAYOUT;
664   }
665   if (!handle->hint)
666     loadFlags |= FT_LOAD_NO_HINTING;
667
668   /* set the base-line based on the string ascent */
669   if (!i_ft2_bbox(handle, cheight, cwidth, text, len, bbox, utf8))
670     return 0;
671
672   if (aa)
673     i_render_init(&render, im, bbox[BBOX_POS_WIDTH] - bbox[BBOX_NEG_WIDTH]);
674
675   if (!align) {
676     /* this may need adjustment */
677     tx -= bbox[0] * handle->matrix[0] + bbox[5] * handle->matrix[1] + handle->matrix[2];
678     ty += bbox[0] * handle->matrix[3] + bbox[5] * handle->matrix[4] + handle->matrix[5];
679   }
680   while (len) {
681     unsigned long c;
682     if (utf8) {
683       c = i_utf8_advance(&text, &len);
684       if (c == ~0UL) {
685         i_push_error(0, "invalid UTF8 character");
686         return 0;
687       }
688     }
689     else {
690       c = (unsigned char)*text++;
691       --len;
692     }
693     
694     index = FT_Get_Char_Index(handle->face, c);
695     error = FT_Load_Glyph(handle->face, index, loadFlags);
696     if (error) {
697       ft2_push_message(error);
698       i_push_errorf(0, "loading glyph for character \\x%02x (glyph 0x%04X)", 
699                     c, index);
700       if (aa)
701         i_render_done(&render);
702       return 0;
703     }
704     slot = handle->face->glyph;
705     gm = &slot->metrics;
706
707     if (gm->width) {
708       error = FT_Render_Glyph(slot, aa ? ft_render_mode_normal : ft_render_mode_mono);
709       if (error) {
710         ft2_push_message(error);
711         i_push_errorf(0, "rendering glyph 0x%04X (character \\x%02X)");
712       if (aa)
713         i_render_done(&render);
714         return 0;
715       }
716       if (slot->bitmap.pixel_mode == ft_pixel_mode_mono) {
717         bmp = slot->bitmap.buffer;
718         for (y = 0; y < slot->bitmap.rows; ++y) {
719           int pos = 0;
720           int bit = 0x80;
721           for (x = 0; x < slot->bitmap.width; ++x) {
722             if (bmp[pos] & bit)
723               i_ppix(im, tx+x+slot->bitmap_left, ty+y-slot->bitmap_top, cl);
724             
725             bit >>= 1;
726             if (bit == 0) {
727               bit = 0x80;
728               ++pos;
729             }
730           }
731           bmp += slot->bitmap.pitch;
732         }
733       }
734       else {
735         /* grey scale or something we can treat as greyscale */
736         /* we create a map to convert from the bitmap values to 0-255 */
737         if (last_mode != slot->bitmap.pixel_mode 
738             || last_grays != slot->bitmap.num_grays) {
739           if (!make_bmp_map(&slot->bitmap, map))
740             return 0;
741           last_mode = slot->bitmap.pixel_mode;
742           last_grays = slot->bitmap.num_grays;
743         }
744
745         bmp = slot->bitmap.buffer;
746         for (y = 0; y < slot->bitmap.rows; ++y) {
747           if (last_mode == ft_pixel_mode_grays &&
748               last_grays != 255) {
749             for (x = 0; x < slot->bitmap.width; ++x) 
750               bmp[x] = map[bmp[x]];
751           }
752           i_render_color(&render, tx + slot->bitmap_left, ty-slot->bitmap_top+y,
753                          slot->bitmap.width, bmp, cl);
754           bmp += slot->bitmap.pitch;
755         }
756       }
757     }
758
759     tx += slot->advance.x / 64;
760     ty -= slot->advance.y / 64;
761   }
762
763   if (aa)
764     i_render_done(&render);
765
766   return 1;
767 }
768
769 /*
770 =item i_ft2_cp(FT2_Fonthandle *handle, i_img *im, int tx, int ty, int channel, double cheight, double cwidth, char *text, size_t len, int align, int aa)
771
772 Renders I<text> to (I<tx>, I<ty>) in I<im> to I<channel> at the given 
773 I<cheight> and I<cwidth>.
774
775 If align is 0, then the text is rendered with the top-left of the
776 first character at (I<tx>, I<ty>).  If align is non-zero then the text
777 is rendered with (I<tx>, I<ty>) aligned with the base-line of the
778 characters.
779
780 If aa is non-zero then the text is anti-aliased.
781
782 Returns non-zero on success.
783
784 =cut
785 */
786
787 int
788 i_ft2_cp(FT2_Fonthandle *handle, i_img *im, int tx, int ty, int channel,
789          double cheight, double cwidth, char const *text, size_t len, int align,
790          int aa, int vlayout, int utf8) {
791   int bbox[8];
792   i_img *work;
793   i_color cl, cl2;
794   int x, y;
795
796   mm_log((1, "i_ft2_cp(handle %p, im %p, tx %d, ty %d, channel %d, cheight %f, cwidth %f, text %p, len %d, ...)\n", 
797           handle, im, tx, ty, channel, cheight, cwidth, text, len));
798
799   if (vlayout && !FT_HAS_VERTICAL(handle->face)) {
800     i_push_error(0, "face has no vertical metrics");
801     return 0;
802   }
803
804   if (!i_ft2_bbox_r(handle, cheight, cwidth, text, len, vlayout, utf8, bbox))
805     return 0;
806
807   work = i_img_empty_ch(NULL, bbox[2]-bbox[0]+1, bbox[3]-bbox[1]+1, 1);
808   cl.channel[0] = 255;
809   if (!i_ft2_text(handle, work, -bbox[0], -bbox[1], &cl, cheight, cwidth, 
810                   text, len, 1, aa, vlayout, utf8))
811     return 0;
812
813   if (!align) {
814     tx -= bbox[4];
815     ty += bbox[5];
816   }
817   
818   /* render to the specified channel */
819   /* this will be sped up ... */
820   for (y = 0; y < work->ysize; ++y) {
821     for (x = 0; x < work->xsize; ++x) {
822       i_gpix(work, x, y, &cl);
823       i_gpix(im, tx + x + bbox[0], ty + y + bbox[1], &cl2);
824       cl2.channel[channel] = cl.channel[0];
825       i_ppix(im, tx + x + bbox[0], ty + y + bbox[1], &cl2);
826     }
827   }
828   i_img_destroy(work);
829   return 1;
830 }
831
832 /*
833 =item i_ft2_has_chars(handle, char *text, size_t len, int utf8, char *out)
834
835 Check if the given characters are defined by the font.
836
837 Returns the number of characters that were checked.
838
839 =cut
840 */
841 int i_ft2_has_chars(FT2_Fonthandle *handle, char const *text, size_t len, 
842                     int utf8, char *out) {
843   int count = 0;
844   mm_log((1, "i_ft2_has_chars(handle %p, text %p, len %d, utf8 %d)\n", 
845           handle, text, len, utf8));
846
847   while (len) {
848     unsigned long c;
849     int index;
850     if (utf8) {
851       c = i_utf8_advance(&text, &len);
852       if (c == ~0UL) {
853         i_push_error(0, "invalid UTF8 character");
854         return 0;
855       }
856     }
857     else {
858       c = (unsigned char)*text++;
859       --len;
860     }
861     
862     index = FT_Get_Char_Index(handle->face, c);
863     *out++ = index != 0;
864     ++count;
865   }
866
867   return count;
868 }
869
870 /* uses a method described in fterrors.h to build an error translation
871    function
872 */
873 #undef __FTERRORS_H__
874 #define FT_ERRORDEF(e, v, s) case v: i_push_error(code, s); return;
875 #define FT_ERROR_START_LIST 
876 #define FT_ERROR_END_LIST 
877
878 /*
879 =back
880
881 =head2 Internal Functions
882
883 These functions are used in the implementation of freetyp2.c and should not
884 (usually cannot) be called from outside it.
885
886 =over
887
888 =item ft2_push_message(int code)
889
890 Pushes an error message corresponding to code onto the error stack.
891
892 =cut
893 */
894 static void ft2_push_message(int code) {
895   char unknown[40];
896
897   switch (code) {
898 #include FT_ERRORS_H
899   }
900
901   sprintf(unknown, "Unknown Freetype2 error code 0x%04X\n", code);
902   i_push_error(code, unknown);
903 }
904
905 /*
906 =item make_bmp_map(FT_Bitmap *bitmap, unsigned char *map)
907
908 Creates a map to convert grey levels from the glyphs bitmap into
909 values scaled 0..255.
910
911 =cut
912 */
913 static int
914 make_bmp_map(FT_Bitmap *bitmap, unsigned char *map) {
915   int scale;
916   int i;
917
918   switch (bitmap->pixel_mode) {
919   case ft_pixel_mode_grays:
920     scale = bitmap->num_grays;
921     break;
922     
923   default:
924     i_push_errorf(0, "I can't handle pixel mode %d", bitmap->pixel_mode);
925     return 0;
926   }
927
928   /* build the table */
929   for (i = 0; i < scale; ++i)
930     map[i] = i * 255 / (bitmap->num_grays - 1);
931
932   return 1;
933 }
934
935 /* FREETYPE_PATCH was introduced in 2.0.6, we don't want a false 
936    positive on 2.0.0 to 2.0.4, so we accept a false negative in 2.0.5 */
937 #ifndef FREETYPE_PATCH
938 #define FREETYPE_PATCH 4
939 #endif
940
941 /* FT_Get_Postscript_Name() was introduced in FT2.0.5 */
942 #define IM_HAS_FACE_NAME (FREETYPE_MINOR > 0 || FREETYPE_PATCH >= 5)
943 /* #define IM_HAS_FACE_NAME 0 */ 
944
945 /*
946 =item i_ft2_face_name(handle, name_buf, name_buf_size)
947
948 Fills the given buffer with the Postscript Face name of the font,
949 if there is one.
950
951 =cut
952 */
953
954 int
955 i_ft2_face_name(FT2_Fonthandle *handle, char *name_buf, size_t name_buf_size) {
956 #if IM_HAS_FACE_NAME
957   char const *name = FT_Get_Postscript_Name(handle->face);
958
959   i_clear_error();
960
961   if (name) {
962     strncpy(name_buf, name, name_buf_size);
963     name_buf[name_buf_size-1] = '\0';
964
965     return strlen(name) + 1;
966   }
967   else {
968     i_push_error(0, "no face name available");
969     *name_buf = '\0';
970
971     return 0;
972   }
973 #else
974   i_clear_error();
975   i_push_error(0, "Freetype 2.0.6 or later required");
976   *name_buf = '\0';
977
978   return 0;
979 #endif
980 }
981
982 int
983 i_ft2_can_face_name(void) {
984   return IM_HAS_FACE_NAME;
985 }
986
987 /* FT_Has_PS_Glyph_Names() was introduced in FT2.1.1 */
988 /* well, I assume FREETYPE_MAJOR is 2, since we're here */
989 #if FREETYPE_MINOR < 1 || (FREETYPE_MINOR == 1 && FREETYPE_PATCH < 1)
990 #define FT_Has_PS_Glyph_Names(face) (FT_HAS_GLYPH_NAMES(face))
991 #endif
992
993 int
994 i_ft2_glyph_name(FT2_Fonthandle *handle, unsigned long ch, char *name_buf, 
995                  size_t name_buf_size, int reliable_only) {
996 #ifdef FT_CONFIG_OPTION_NO_GLYPH_NAMES
997   i_clear_error();
998   *name_buf = '\0';
999   i_push_error(0, "FT2 configured without glyph name support");
1000
1001   return 0;
1002 #else
1003   FT_UInt index;
1004
1005   i_clear_error();
1006
1007   if (!FT_HAS_GLYPH_NAMES(handle->face)) {
1008     i_push_error(0, "no glyph names in font");
1009     *name_buf = '\0';
1010     return 0;
1011   }
1012   if (reliable_only && !FT_Has_PS_Glyph_Names(handle->face)) {
1013     i_push_error(0, "no reliable glyph names in font - set reliable_only to 0 to try anyway");
1014     *name_buf = '\0';
1015     return 0;
1016   }
1017
1018   index = FT_Get_Char_Index(handle->face, ch);
1019   
1020   if (index) {
1021     FT_Error error = FT_Get_Glyph_Name(handle->face, index, name_buf, 
1022                                        name_buf_size);
1023     if (error) {
1024       ft2_push_message(error);
1025       *name_buf = '\0';
1026       return 0;
1027     }
1028     if (*name_buf) {
1029       return strlen(name_buf) + 1;
1030     }
1031     else {
1032       return 0;
1033     }
1034   }
1035   else {
1036     i_push_error(0, "no glyph for that character");
1037     *name_buf = 0;
1038     return 0;
1039   }
1040 #endif
1041 }
1042
1043 int
1044 i_ft2_can_do_glyph_names(void) {
1045 #ifdef FT_CONFIG_OPTION_NO_GLYPH_NAMES
1046   return 0;
1047 #else
1048   return 1;
1049 #endif
1050 }
1051
1052 int 
1053 i_ft2_face_has_glyph_names(FT2_Fonthandle *handle) {
1054 #ifdef FT_CONFIG_OPTION_NO_GLYPH_NAMES
1055   return 0;
1056 #else
1057   return FT_Has_PS_Glyph_Names(handle->face);
1058 #endif
1059 }
1060
1061 int
1062 i_ft2_is_multiple_master(FT2_Fonthandle *handle) {
1063   i_clear_error();
1064 #ifdef IM_FT2_MM
1065   return handle->has_mm;
1066 #else
1067   return 0;
1068 #endif
1069 }
1070
1071 int
1072 i_ft2_get_multiple_masters(FT2_Fonthandle *handle, i_font_mm *mm) {
1073 #ifdef IM_FT2_MM
1074   int i;
1075   FT_Multi_Master *mms = &handle->mm;
1076
1077   i_clear_error();
1078   if (!handle->has_mm) {
1079     i_push_error(0, "Font has no multiple masters");
1080     return 0;
1081   }
1082   mm->num_axis = mms->num_axis;
1083   mm->num_designs = mms->num_designs;
1084   for (i = 0; i < mms->num_axis; ++i) {
1085     mm->axis[i].name = mms->axis[i].name;
1086     mm->axis[i].minimum = mms->axis[i].minimum;
1087     mm->axis[i].maximum = mms->axis[i].maximum;
1088   }
1089
1090   return 1;
1091 #else
1092   i_clear_error();
1093   i_push_error(0, "Multiple master functions unavailable");
1094   return 0;
1095 #endif
1096 }
1097
1098 int
1099 i_ft2_set_mm_coords(FT2_Fonthandle *handle, int coord_count, const long *coords) {
1100 #ifdef IM_FT2_MM
1101   int i;
1102   FT_Long ftcoords[T1_MAX_MM_AXIS];
1103   FT_Error error;
1104
1105   i_clear_error();
1106   if (!handle->has_mm) {
1107     i_push_error(0, "Font has no multiple masters");
1108     return 0;
1109   }
1110   if (coord_count != handle->mm.num_axis) {
1111     i_push_error(0, "Number of MM coords doesn't match MM axis count");
1112     return 0;
1113   }
1114   for (i = 0; i < coord_count; ++i)
1115     ftcoords[i] = coords[i];
1116
1117   error = FT_Set_MM_Design_Coordinates(handle->face, coord_count, ftcoords);
1118   if (error) {
1119     ft2_push_message(error);
1120     return 0;
1121   }
1122   
1123   return 1;
1124 #else 
1125   i_clear_error();
1126   i_push_error(0, "Multiple master functions unavailable");
1127
1128   return 0;
1129 #endif
1130 }
1131
1132 /*
1133 =back
1134
1135 =head1 AUTHOR
1136
1137 Tony Cook <tony@develop-help.com>, with a fair amount of help from
1138 reading the code in font.c.
1139
1140 =head1 SEE ALSO
1141
1142 font.c, Imager::Font(3), Imager(3)
1143
1144 http://www.freetype.org/
1145
1146 =cut
1147 */
1148