avoid dead code in i_t1_glyph_names().
[imager.git] / W32 / win32.c
1 #define _WIN32_WINNT 0x500
2 #include "imw32.h"
3 #define STRICT
4 #include <windows.h>
5 #include "imext.h"
6
7 /*
8 =head1 NAME
9
10 win32.c - implements some win32 specific code, specifically Win32 font support.
11
12 =head1 SYNOPSIS
13
14    i_img_dim bbox[6];
15    if (i_wf_bbox(facename, size, text, text_len, bbox)) {
16      // we have the bbox
17    }
18    i_wf_text(face, im, tx, ty, cl, size, text, len, align, aa, utf8);
19    i_wf_cp(face, im, tx, ty, channel, size, text, len, align, aa, utf8)
20
21 =head1 DESCRIPTION
22
23 An Imager interface to font output using the Win32 GDI.
24
25 =over
26
27 =cut
28 */
29
30 #define fixed(x) ((x).value + ((x).fract) / 65536.0)
31
32 static void set_logfont(const char *face, int size, LOGFONT *lf);
33
34 static unsigned char *render_text(const char *face, int size, const char *text, size_t length, int aa,
35                                   SIZE *psz, TEXTMETRIC *tm, size_t *bytes_per_line, i_img_dim *bbox, int utf8);
36 static LPWSTR utf8_to_wide_string(char const *text, int text_len, int *wide_chars);
37 static LPWSTR latin1_to_wide_string(char const *text, int text_len, int *wide_chars);
38
39 /*
40 =item i_wf_bbox(face, size, text, length, bbox, utf8)
41
42 Calculate a bounding box for the text.
43
44 =cut
45 */
46
47 int i_wf_bbox(const char *face, i_img_dim size, const char *text, size_t length,
48               i_img_dim *bbox, int utf8) {
49   LOGFONT lf;
50   HFONT font, oldFont;
51   HDC dc;
52   SIZE sz;
53   TEXTMETRIC tm;
54   ABC first, last;
55   GLYPHMETRICS gm;
56   MAT2 mat;
57   int ascent, descent, max_ascent = -size, min_descent = size;
58   const char *workp;
59   size_t work_len;
60   int got_first_ch = 0;
61   unsigned long first_ch, last_ch;
62
63   i_clear_error();
64
65   mm_log((1, "i_wf_bbox(face %s, size %d, text %p, length %d, bbox %p, utf8 %d)\n", face, size, text, length, bbox, utf8));
66
67   set_logfont(face, size, &lf);
68   font = CreateFontIndirect(&lf);
69   if (!font) 
70     return 0;
71   dc = GetDC(NULL);
72   oldFont = (HFONT)SelectObject(dc, font);
73
74   {
75     char facename[100];
76     if (GetTextFace(dc, sizeof(facename), facename)) {
77       mm_log((1, "  face: %s\n", facename));
78     }
79   }
80
81   workp = text;
82   work_len = length;
83   while (work_len > 0) {
84     unsigned long c;
85     unsigned char cp;
86
87     if (utf8) {
88       c = i_utf8_advance(&workp, &work_len);
89       if (c == ~0UL) {
90         i_push_error(0, "invalid UTF8 character");
91         return 0;
92       }
93     }
94     else {
95       c = (unsigned char)*workp++;
96       --work_len;
97     }
98     if (!got_first_ch) {
99       first_ch = c;
100       ++got_first_ch;
101     }
102     last_ch = c;
103
104     cp = c > '~' ? '.' : c < ' ' ? '.' : c;
105     
106     memset(&mat, 0, sizeof(mat));
107     mat.eM11.value = 1;
108     mat.eM22.value = 1;
109     if (GetGlyphOutline(dc, (UINT)c, GGO_METRICS, &gm, 0, NULL, &mat) != GDI_ERROR) {
110       mm_log((2, "  glyph '%c' (%02x): bbx (%u,%u) org (%d,%d) inc(%d,%d)\n",
111               cp, c, gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmptGlyphOrigin.x,
112                 gm.gmptGlyphOrigin.y, gm.gmCellIncX, gm.gmCellIncY));
113
114       ascent = gm.gmptGlyphOrigin.y;
115       descent = ascent - gm.gmBlackBoxY;
116       if (ascent > max_ascent) max_ascent = ascent;
117       if (descent < min_descent) min_descent = descent;
118     }
119     else {
120         mm_log((1, "  glyph '%c' (%02x): error %d\n", cp, c, GetLastError()));
121     }
122   }
123
124   if (utf8) {
125     int wide_chars;
126     LPWSTR wide_text = utf8_to_wide_string(text, length, &wide_chars);
127
128     if (!wide_text)
129       return 0;
130
131     if (!GetTextExtentPoint32W(dc, wide_text, wide_chars, &sz)
132         || !GetTextMetrics(dc, &tm)) {
133       SelectObject(dc, oldFont);
134       ReleaseDC(NULL, dc);
135       DeleteObject(font);
136       return 0;
137     }
138
139     myfree(wide_text);
140   }
141   else {
142     if (!GetTextExtentPoint32(dc, text, length, &sz)
143         || !GetTextMetrics(dc, &tm)) {
144       SelectObject(dc, oldFont);
145       ReleaseDC(NULL, dc);
146       DeleteObject(font);
147       return 0;
148     }
149   }
150   bbox[BBOX_GLOBAL_DESCENT] = -tm.tmDescent;
151   bbox[BBOX_DESCENT] = min_descent == size ? -tm.tmDescent : min_descent;
152   bbox[BBOX_POS_WIDTH] = sz.cx;
153   bbox[BBOX_ADVANCE_WIDTH] = sz.cx;
154   bbox[BBOX_GLOBAL_ASCENT] = tm.tmAscent;
155   bbox[BBOX_ASCENT] = max_ascent == -size ? tm.tmAscent : max_ascent;
156   
157   if (length
158       && GetCharABCWidths(dc, first_ch, first_ch, &first)
159       && GetCharABCWidths(dc, last_ch, last_ch, &last)) {
160     mm_log((1, "first: %d A: %d  B: %d  C: %d\n", first_ch,
161             first.abcA, first.abcB, first.abcC));
162     mm_log((1, "last: %d A: %d  B: %d  C: %d\n", last_ch,
163             last.abcA, last.abcB, last.abcC));
164     bbox[BBOX_NEG_WIDTH] = first.abcA;
165     bbox[BBOX_RIGHT_BEARING] = last.abcC;
166     if (last.abcC < 0)
167       bbox[BBOX_POS_WIDTH] -= last.abcC;
168   }
169   else {
170     bbox[BBOX_NEG_WIDTH] = 0;
171     bbox[BBOX_RIGHT_BEARING] = 0;
172   }
173
174   SelectObject(dc, oldFont);
175   ReleaseDC(NULL, dc);
176   DeleteObject(font);
177
178   mm_log((1, " bbox=> negw=%" i_DF " glob_desc=%" i_DF " pos_wid=%" i_DF
179           " glob_asc=%" i_DF " desc=%" i_DF " asc=%" i_DF " adv_width=%" i_DF 
180           " rightb=%" i_DF "\n", i_DFc(bbox[0]), i_DFc(bbox[1]), i_DFc(bbox[2]),
181           i_DFc(bbox[3]), i_DFc(bbox[4]), i_DFc(bbox[5]), i_DFc(bbox[6]),
182           i_DFc(bbox[7])));
183
184   return BBOX_RIGHT_BEARING + 1;
185 }
186
187 /*
188 =item i_wf_text(face, im, tx, ty, cl, size, text, len, align, aa)
189
190 Draws the text in the given color.
191
192 =cut
193 */
194
195 int
196 i_wf_text(const char *face, i_img *im, i_img_dim tx, i_img_dim ty, const i_color *cl, i_img_dim size, 
197           const char *text, size_t len, int align, int aa, int utf8) {
198   unsigned char *bits;
199   SIZE sz;
200   size_t line_width;
201   i_img_dim x, y;
202   int ch;
203   TEXTMETRIC tm;
204   int top;
205   i_img_dim bbox[BOUNDING_BOX_COUNT];
206   i_render *r;
207   unsigned char *outp;
208
209   i_clear_error();
210
211   mm_log((1, "i_wf_text(face %s, im %p, tx %" i_DF ", ty %" i_DF ", cl %p, size %" i_DF ", text %p, length %lu, align %d, aa %d,  utf8 %d)\n", face, im, i_DFcp(tx, ty), cl, i_DFc(size), text, (unsigned long)len, align, aa, aa, utf8));
212
213   if (!i_wf_bbox(face, size, text, len, bbox, utf8))
214     return 0;
215
216   bits = render_text(face, size, text, len, aa, &sz, &tm, &line_width, bbox, utf8);
217   if (!bits)
218     return 0;
219
220   tx += bbox[BBOX_NEG_WIDTH];
221   top = ty;
222   if (align) {
223     top -= tm.tmAscent;
224   }
225   else {
226     top -= tm.tmAscent - bbox[BBOX_ASCENT];
227   }
228
229   r = i_render_new(im, sz.cx);
230   outp = bits;
231   for (y = 0; y < sz.cy; ++y) {
232     i_render_color(r, tx, top + sz.cy - y - 1, sz.cx, outp, cl);
233     outp += line_width;
234   }
235   i_render_delete(r);
236   myfree(bits);
237
238   return 1;
239 }
240
241 /*
242 =item i_wf_cp(face, im, tx, ty, channel, size, text, len, align, aa)
243
244 Draws the text in the given channel.
245
246 =cut
247 */
248
249 int
250 i_wf_cp(const char *face, i_img *im, i_img_dim tx, i_img_dim ty, int channel, i_img_dim size, 
251           const char *text, size_t len, int align, int aa, int utf8) {
252   unsigned char *bits;
253   SIZE sz;
254   size_t line_width;
255   i_img_dim x, y;
256   TEXTMETRIC tm;
257   i_img_dim top;
258   i_img_dim bbox[BOUNDING_BOX_COUNT];
259   unsigned char *outp;
260
261   i_clear_error();
262
263   mm_log((1, "i_wf_cp(face %s, im %p, tx %" i_DF ", ty %" i_DF ", channel %d, size %" i_DF ", text %p, length %lu, align %d, aa %d,  utf8 %d)\n", face, im, i_DFcp(tx, ty), channel, i_DFc(size), text, (unsigned long)len, align, aa, aa, utf8));
264
265   if (!i_wf_bbox(face, size, text, len, bbox, utf8))
266     return 0;
267
268   bits = render_text(face, size, text, len, aa, &sz, &tm, &line_width, bbox, utf8);
269   if (!bits)
270     return 0;
271   
272   top = ty;
273   if (align) {
274     top -= tm.tmAscent;
275   }
276   else {
277     top -= tm.tmAscent - bbox[BBOX_ASCENT];
278   }
279
280   outp = bits;
281   for (y = 0; y < sz.cy; ++y) {
282     for (x = 0; x < sz.cx; ++x) {
283       i_color pel;
284       int scale = outp[x];
285       i_gpix(im, tx+x, top+sz.cy-y-1, &pel);
286       pel.channel[channel] = scale;
287       i_ppix(im, tx+x, top+sz.cy-y-1, &pel);
288     }
289     outp += line_width;
290   }
291   myfree(bits);
292
293   return 1;
294 }
295
296 static HMODULE gdi_dll;
297 typedef BOOL (CALLBACK *AddFontResourceExA_t)(LPCSTR, DWORD, PVOID);
298 static AddFontResourceExA_t AddFontResourceExAp;
299 typedef BOOL (CALLBACK *RemoveFontResourceExA_t)(LPCSTR, DWORD, PVOID);
300 static RemoveFontResourceExA_t RemoveFontResourceExAp;
301
302 /*
303 =item i_wf_addfont(char const *filename, char const *resource_file)
304
305 Adds a TTF font file as usable by the application.
306
307 Where possible the font is added as private to the application.
308
309 Under Windows 95/98/ME the font is added globally, since we don't have
310 any choice.  In either case call i_wf_delfont() to remove it.
311
312 =cut
313  */
314 int
315 i_wf_addfont(char const *filename) {
316   i_clear_error();
317
318   mm_log((1, "i_wf_addfont(%s)\n", filename));
319   if (!gdi_dll) {
320     gdi_dll = GetModuleHandle("GDI32");
321     if (gdi_dll) {
322       AddFontResourceExAp = (AddFontResourceExA_t)GetProcAddress(gdi_dll, "AddFontResourceExA");
323       RemoveFontResourceExAp = (RemoveFontResourceExA_t)GetProcAddress(gdi_dll, "RemoveFontResourceExA");
324       mm_log((1, "i_wf_addfont: AddFontResourceExA %p RemoveFontResourceExA %p\n",
325               AddFontResourceExAp, RemoveFontResourceExAp));
326     }
327   }
328
329   if (AddFontResourceExAp && RemoveFontResourceExAp) {
330     mm_log((1, "i_wf_addfont: adding via AddFontResourceEx()\n"));
331     if (AddFontResourceExAp(filename, FR_PRIVATE, 0)) {
332       return 1;
333     }
334   }
335   else {
336     mm_log((1, "i_wf_addfont: adding via AddFontResource()\n"));
337     if (AddFontResource(filename)) {
338       return 1;
339     }
340   }
341
342   mm_log((1, "i_wf_addfont failed: %ld\n", GetLastError()));
343   i_push_errorf(0, "Could not add resource: %ld", GetLastError());
344   return 0;
345 }
346
347 /*
348 =item i_wf_delfont(char const *filename, char const *resource_file)
349
350 Deletes a TTF font file as usable by the application.
351
352 =cut
353  */
354 int
355 i_wf_delfont(char const *filename) {
356   i_clear_error();
357
358   mm_log((1, "i_wf_delfont(%s)\n", filename));
359
360   if (AddFontResourceExAp && RemoveFontResourceExAp) {
361     mm_log((1, "i_wf_delfont: removing via RemoveFontResourceEx()\n"));
362     if (RemoveFontResourceExAp(filename, FR_PRIVATE, 0))
363       return 1;
364   }
365   else {
366     mm_log((1, "i_wf_delfont: adding via RemoveFontResourceEx()\n"));
367     if (RemoveFontResource(filename))
368       return 1;
369   }
370
371   mm_log((1, "i_wf_delfont failed: %ld\n", GetLastError()));
372   i_push_errorf(0, "Could not remove resource: %ld", GetLastError());
373   return 0;
374 }
375
376 /*
377 =back
378
379 =head1 INTERNAL FUNCTIONS
380
381 =over
382
383 =item set_logfont(face, size, lf)
384
385 Fills in a LOGFONT structure with reasonable defaults.
386
387 =cut
388 */
389
390 static void set_logfont(const char *face, int size, LOGFONT *lf) {
391   memset(lf, 0, sizeof(LOGFONT));
392
393   lf->lfHeight = -size; /* character height rather than cell height */
394   lf->lfCharSet = DEFAULT_CHARSET;
395   lf->lfOutPrecision = OUT_TT_PRECIS;
396   lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
397   lf->lfQuality = PROOF_QUALITY;
398   strncpy(lf->lfFaceName, face, sizeof(lf->lfFaceName)-1);
399   /* NUL terminated by the memset at the top */
400 }
401
402 /*
403 =item render_text(face, size, text, length, aa, pbm, psz, tm)
404
405 renders the text to an in-memory RGB bitmap 
406
407 It would be nice to render to greyscale, but Windows doesn't have
408 native greyscale bitmaps.
409
410 =cut
411 */
412 static unsigned char *
413 render_text(const char *face, int size, const char *text, size_t length, int aa,
414             SIZE *psz, TEXTMETRIC *tm, size_t *bytes_per_line, i_img_dim *bbox, int utf8) {
415   BITMAPINFO bmi;
416   BITMAPINFOHEADER *bmih = &bmi.bmiHeader;
417   HDC dc, bmpDc;
418   LOGFONT lf;
419   HFONT font, oldFont;
420   SIZE sz;
421   HBITMAP bm, oldBm;
422   LPVOID bits;
423   int wide_count;
424   LPWSTR wide_text;
425   unsigned char *result;
426
427   dc = GetDC(NULL);
428   set_logfont(face, size, &lf);
429
430 #ifdef ANTIALIASED_QUALITY
431   /* See KB article Q197076
432      "INFO: Controlling Anti-aliased Text via the LOGFONT Structure"
433   */
434   lf.lfQuality = aa ? ANTIALIASED_QUALITY : NONANTIALIASED_QUALITY;
435 #endif
436
437   if (utf8) {
438     wide_text = utf8_to_wide_string(text, length, &wide_count);
439   }
440   else {
441     wide_text = latin1_to_wide_string(text, length, &wide_count);
442   }
443
444   bmpDc = CreateCompatibleDC(dc);
445   if (bmpDc) {
446     font = CreateFontIndirect(&lf);
447     if (font) {
448       oldFont = SelectObject(bmpDc, font);
449
450       GetTextMetrics(bmpDc, tm);
451       sz.cx = bbox[BBOX_ADVANCE_WIDTH] - bbox[BBOX_NEG_WIDTH] + bbox[BBOX_POS_WIDTH];
452       sz.cy = bbox[BBOX_GLOBAL_ASCENT] - bbox[BBOX_GLOBAL_DESCENT];
453       
454       memset(&bmi, 0, sizeof(bmi));
455       bmih->biSize = sizeof(*bmih);
456       bmih->biWidth = sz.cx;
457       bmih->biHeight = sz.cy;
458       bmih->biPlanes = 1;
459       bmih->biBitCount = 24;
460       bmih->biCompression = BI_RGB;
461       bmih->biSizeImage = 0;
462       bmih->biXPelsPerMeter = (LONG)(72 / 2.54 * 100);
463       bmih->biYPelsPerMeter = bmih->biXPelsPerMeter;
464       bmih->biClrUsed = 0;
465       bmih->biClrImportant = 0;
466       
467       bm = CreateDIBSection(dc, &bmi, DIB_RGB_COLORS, &bits, NULL, 0);
468
469       if (bm) {
470         oldBm = SelectObject(bmpDc, bm);
471         SetTextColor(bmpDc, RGB(255, 255, 255));
472         SetBkColor(bmpDc, RGB(0, 0, 0));
473         TextOutW(bmpDc, -bbox[BBOX_NEG_WIDTH], 0, wide_text, wide_count);
474         SelectObject(bmpDc, oldBm);
475       }
476       else {
477         i_push_errorf(0, "Could not create DIB section for render: %ld",
478                       GetLastError());
479         SelectObject(bmpDc, oldFont);
480         DeleteObject(font);
481         DeleteDC(bmpDc);
482         ReleaseDC(NULL, dc);
483         myfree(wide_text);
484         return NULL;
485       }
486       SelectObject(bmpDc, oldFont);
487       DeleteObject(font);
488     }
489     else {
490       myfree(wide_text);
491       i_push_errorf(0, "Could not create logical font: %ld",
492                     GetLastError());
493       DeleteDC(bmpDc);
494       ReleaseDC(NULL, dc);
495       return NULL;
496     }
497     DeleteDC(bmpDc);
498   }
499   else {
500     myfree(wide_text);
501     i_push_errorf(0, "Could not create rendering DC: %ld", GetLastError());
502     ReleaseDC(NULL, dc);
503     return NULL;
504   }
505
506   myfree(wide_text);
507
508   ReleaseDC(NULL, dc);
509
510   *psz = sz;
511
512   /* convert into a map we can just pass to i_render_color() */
513   {
514     i_img_dim x, y;
515     unsigned char *outp, *ucbits;
516     size_t bits_line_width;
517
518     *bytes_per_line = sz.cx;
519     result = mymalloc(sz.cx * sz.cy);
520     outp = result;
521     ucbits = bits;
522     bits_line_width = sz.cx * 3;
523     bits_line_width = (bits_line_width + 3) / 4 * 4;
524
525     for (y = 0; y < sz.cy; ++y) {
526       for (x = 0; x < sz.cx; ++x) {
527         *outp++ = ucbits[3 * x];
528       }
529       ucbits += bits_line_width;
530     }
531   }
532   DeleteObject(bm);
533
534   return result;
535 }
536
537 /*
538 =item utf8_to_wide_string(text, text_len, wide_chars)
539
540 =cut
541 */
542
543 static
544 LPWSTR
545 utf8_to_wide_string(char const *text, int text_len, int *wide_chars) {
546   int wide_count = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, text_len, NULL, 0);
547   LPWSTR result;
548
549   if (wide_count < 0) {
550     i_push_errorf(0, "Could not convert utf8: %ld", GetLastError());
551     return NULL;
552   }
553   ++wide_count;
554   result = mymalloc(sizeof(WCHAR) * wide_count);
555   if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, text_len, result, wide_count) < 0) {
556     i_push_errorf(0, "Could not convert utf8: %ld", GetLastError());
557     return NULL;
558   }
559
560   result[wide_count-1] = (WCHAR)'\0';
561   *wide_chars = wide_count - 1;
562
563   return result;
564 }
565
566 static LPWSTR
567 latin1_to_wide_string(char const *text, int text_len, int *wide_chars) {
568   LPWSTR result = mymalloc(sizeof(WCHAR) * (text_len + 1));
569   size_t i;
570
571   for (i = 0; i < text_len; ++i) {
572     result[i] = (unsigned char)text[i];
573   }
574   result[i] = 0;
575   *wide_chars = text_len;
576
577   return result;
578 }
579
580 /*
581 =back
582
583 =head1 BUGS
584
585 Should really use a structure so we can set more attributes.
586
587 Should support UTF8
588
589 =head1 AUTHOR
590
591 Tony Cook <tony@develop-help.com>
592
593 =head1 SEE ALSO
594
595 Imager(3)
596
597 =cut
598 */