?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wineusb.sys: Move event handling to a single thread.
[wine.git] / dlls / gdiplus / font.c
blob036786236066fc4a48862360f4bee61c1d6b80e1
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 * Copyright (C) 2012 Dmitry Timoshkov
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdarg.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "winnls.h"
26 #include "winreg.h"
27 #include "wine/debug.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL (gdiplus);
30
31 #include "objbase.h"
32
33 #include "gdiplus.h"
34 #include "gdiplus_private.h"
35
36 /* PANOSE is 10 bytes in size, need to pack the structure properly */
37 #include "pshpack2.h"
38 typedef struct
39 {
40 USHORT version;
41 SHORT xAvgCharWidth;
42 USHORT usWeightClass;
43 USHORT usWidthClass;
44 SHORT fsType;
45 SHORT ySubscriptXSize;
46 SHORT ySubscriptYSize;
47 SHORT ySubscriptXOffset;
48 SHORT ySubscriptYOffset;
49 SHORT ySuperscriptXSize;
50 SHORT ySuperscriptYSize;
51 SHORT ySuperscriptXOffset;
52 SHORT ySuperscriptYOffset;
53 SHORT yStrikeoutSize;
54 SHORT yStrikeoutPosition;
55 SHORT sFamilyClass;
56 PANOSE panose;
57 ULONG ulUnicodeRange1;
58 ULONG ulUnicodeRange2;
59 ULONG ulUnicodeRange3;
60 ULONG ulUnicodeRange4;
61 CHAR achVendID[4];
62 USHORT fsSelection;
63 USHORT usFirstCharIndex;
64 USHORT usLastCharIndex;
65 /* According to the Apple spec, original version didn't have the below fields,
66 * version numbers were taken from the OpenType spec.
67 */
68 /* version 0 (TrueType 1.5) */
69 USHORT sTypoAscender;
70 USHORT sTypoDescender;
71 USHORT sTypoLineGap;
72 USHORT usWinAscent;
73 USHORT usWinDescent;
74 /* version 1 (TrueType 1.66) */
75 ULONG ulCodePageRange1;
76 ULONG ulCodePageRange2;
77 /* version 2 (OpenType 1.2) */
78 SHORT sxHeight;
79 SHORT sCapHeight;
80 USHORT usDefaultChar;
81 USHORT usBreakChar;
82 USHORT usMaxContext;
83 } TT_OS2_V2;
84
85 typedef struct
86 {
87 ULONG Version;
88 SHORT Ascender;
89 SHORT Descender;
90 SHORT LineGap;
91 USHORT advanceWidthMax;
92 SHORT minLeftSideBearing;
93 SHORT minRightSideBearing;
94 SHORT xMaxExtent;
95 SHORT caretSlopeRise;
96 SHORT caretSlopeRun;
97 SHORT caretOffset;
98 SHORT reserved[4];
99 SHORT metricDataFormat;
100 USHORT numberOfHMetrics;
101 } TT_HHEA;
102 #include "poppack.h"
103
104 #ifdef WORDS_BIGENDIAN
105 #define GET_BE_WORD(x) (x)
106 #define GET_BE_DWORD(x) (x)
107 #else
108 #define GET_BE_WORD(x) MAKEWORD(HIBYTE(x), LOBYTE(x))
109 #define GET_BE_DWORD(x) MAKELONG(GET_BE_WORD(HIWORD(x)), GET_BE_WORD(LOWORD(x)))
110 #endif
111
112 #define MS_MAKE_TAG(ch0, ch1, ch2, ch3) \
113 ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \
114 ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24))
115 #define MS_OS2_TAG MS_MAKE_TAG('O','S','/','2')
116 #define MS_HHEA_TAG MS_MAKE_TAG('h','h','e','a')
117
118 static GpFontCollection installedFontCollection = {0};
119
120 static CRITICAL_SECTION font_cs;
121 static CRITICAL_SECTION_DEBUG critsect_debug =
122 {
123 0, 0, &font_cs,
124 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
125 0, 0, { (DWORD_PTR)(__FILE__ ": font_cs") }
126 };
127 static CRITICAL_SECTION font_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
128
129 /*******************************************************************************
130 * GdipCreateFont [GDIPLUS.@]
131 *
132 * Create a new font based off of a FontFamily
133 *
134 * PARAMS
135 * *fontFamily [I] Family to base the font off of
136 * emSize [I] Size of the font
137 * style [I] Bitwise OR of FontStyle enumeration
138 * unit [I] Unit emSize is measured in
139 * **font [I] the resulting Font object
140 *
141 * RETURNS
142 * SUCCESS: Ok
143 * FAILURE: InvalidParameter if fontfamily or font is NULL.
144 * FAILURE: FontFamilyNotFound if an invalid FontFamily is given
145 *
146 * NOTES
147 * UnitDisplay is unsupported.
148 * emSize is stored separately from lfHeight, to hold the fraction.
149 */
150 GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily,
151 REAL emSize, INT style, Unit unit, GpFont **font)
152 {
153 HFONT hfont;
154 OUTLINETEXTMETRICW otm;
155 LOGFONTW lfw;
156 HDC hdc;
157 GpStatus stat;
158 int ret;
159
160 if (!fontFamily || !font || emSize < 0.0)
161 return InvalidParameter;
162
163 TRACE("%p (%s), %f, %d, %d, %p\n", fontFamily,
164 debugstr_w(fontFamily->FamilyName), emSize, style, unit, font);
165
166 memset(&lfw, 0, sizeof(lfw));
167
168 stat = GdipGetFamilyName(fontFamily, lfw.lfFaceName, LANG_NEUTRAL);
169 if (stat != Ok) return stat;
170
171 lfw.lfHeight = -units_to_pixels(emSize, unit, fontFamily->dpi, FALSE);
172 lfw.lfWeight = style & FontStyleBold ? FW_BOLD : FW_REGULAR;
173 lfw.lfItalic = style & FontStyleItalic;
174 lfw.lfUnderline = style & FontStyleUnderline;
175 lfw.lfStrikeOut = style & FontStyleStrikeout;
176
177 hfont = CreateFontIndirectW(&lfw);
178 hdc = CreateCompatibleDC(0);
179 SelectObject(hdc, hfont);
180 otm.otmSize = sizeof(otm);
181 ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
182 DeleteDC(hdc);
183 DeleteObject(hfont);
184
185 if (!ret) return NotTrueTypeFont;
186
187 *font = heap_alloc_zero(sizeof(GpFont));
188 if (!*font) return OutOfMemory;
189
190 (*font)->unit = unit;
191 (*font)->emSize = emSize;
192 (*font)->otm = otm;
193 GdipCloneFontFamily((GpFontFamily*)fontFamily, &(*font)->family);
194
195 TRACE("<-- %p\n", *font);
196
197 return Ok;
198 }
199
200 /*******************************************************************************
201 * GdipCreateFontFromLogfontW [GDIPLUS.@]
202 */
203 GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc,
204 GDIPCONST LOGFONTW *logfont, GpFont **font)
205 {
206 HFONT hfont, oldfont;
207 OUTLINETEXTMETRICW otm;
208 WCHAR facename[LF_FACESIZE];
209 GpStatus stat;
210 int ret;
211
212 TRACE("(%p, %p, %p)\n", hdc, logfont, font);
213
214 if (!hdc || !logfont || !font)
215 return InvalidParameter;
216
217 hfont = CreateFontIndirectW(logfont);
218 oldfont = SelectObject(hdc, hfont);
219 otm.otmSize = sizeof(otm);
220 ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
221 GetTextFaceW(hdc, LF_FACESIZE, facename);
222 SelectObject(hdc, oldfont);
223 DeleteObject(hfont);
224
225 if (!ret) return NotTrueTypeFont;
226
227 *font = heap_alloc_zero(sizeof(GpFont));
228 if (!*font) return OutOfMemory;
229
230 (*font)->unit = UnitWorld;
231 (*font)->emSize = otm.otmTextMetrics.tmHeight - otm.otmTextMetrics.tmInternalLeading;
232 (*font)->otm = otm;
233
234 stat = GdipCreateFontFamilyFromName(facename, NULL, &(*font)->family);
235 if (stat != Ok)
236 {
237 heap_free(*font);
238 return NotTrueTypeFont;
239 }
240
241 TRACE("<-- %p\n", *font);
242
243 return Ok;
244 }
245
246 /*******************************************************************************
247 * GdipCreateFontFromLogfontA [GDIPLUS.@]
248 */
249 GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc,
250 GDIPCONST LOGFONTA *lfa, GpFont **font)
251 {
252 LOGFONTW lfw;
253
254 TRACE("(%p, %p, %p)\n", hdc, lfa, font);
255
256 if(!lfa || !font)
257 return InvalidParameter;
258
259 memcpy(&lfw, lfa, FIELD_OFFSET(LOGFONTA,lfFaceName) );
260
261 if(!MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw.lfFaceName, LF_FACESIZE))
262 return GenericError;
263
264 return GdipCreateFontFromLogfontW(hdc, &lfw, font);
265 }
266
267 /*******************************************************************************
268 * GdipDeleteFont [GDIPLUS.@]
269 */
270 GpStatus WINGDIPAPI GdipDeleteFont(GpFont* font)
271 {
272 TRACE("(%p)\n", font);
273
274 if(!font)
275 return InvalidParameter;
276
277 GdipDeleteFontFamily(font->family);
278 heap_free(font);
279
280 return Ok;
281 }
282
283 /*******************************************************************************
284 * GdipCreateFontFromDC [GDIPLUS.@]
285 */
286 GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC hdc, GpFont **font)
287 {
288 HFONT hfont;
289 LOGFONTW lfw;
290
291 TRACE("(%p, %p)\n", hdc, font);
292
293 if(!font)
294 return InvalidParameter;
295
296 hfont = GetCurrentObject(hdc, OBJ_FONT);
297 if(!hfont)
298 return GenericError;
299
300 if(!GetObjectW(hfont, sizeof(LOGFONTW), &lfw))
301 return GenericError;
302
303 return GdipCreateFontFromLogfontW(hdc, &lfw, font);
304 }
305
306 /*******************************************************************************
307 * GdipGetFamily [GDIPLUS.@]
308 *
309 * Returns the FontFamily for the specified Font
310 *
311 * PARAMS
312 * font [I] Font to request from
313 * family [O] Resulting FontFamily object
314 *
315 * RETURNS
316 * SUCCESS: Ok
317 * FAILURE: An element of GpStatus
318 */
319 GpStatus WINGDIPAPI GdipGetFamily(GpFont *font, GpFontFamily **family)
320 {
321 TRACE("%p %p\n", font, family);
322
323 if (!(font && family))
324 return InvalidParameter;
325
326 return GdipCloneFontFamily(font->family, family);
327 }
328
329 static REAL get_font_size(const GpFont *font)
330 {
331 return font->emSize;
332 }
333
334 /******************************************************************************
335 * GdipGetFontSize [GDIPLUS.@]
336 *
337 * Returns the size of the font in Units
338 *
339 * PARAMS
340 * *font [I] The font to retrieve size from
341 * *size [O] Pointer to hold retrieved value
342 *
343 * RETURNS
344 * SUCCESS: Ok
345 * FAILURE: InvalidParameter (font or size was NULL)
346 *
347 * NOTES
348 * Size returned is actually emSize -- not internal size used for drawing.
349 */
350 GpStatus WINGDIPAPI GdipGetFontSize(GpFont *font, REAL *size)
351 {
352 TRACE("(%p, %p)\n", font, size);
353
354 if (!(font && size)) return InvalidParameter;
355
356 *size = get_font_size(font);
357 TRACE("%s,%ld => %f\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *size);
358
359 return Ok;
360 }
361
362 static INT get_font_style(const GpFont *font)
363 {
364 INT style;
365
366 if (font->otm.otmTextMetrics.tmWeight > FW_REGULAR)
367 style = FontStyleBold;
368 else
369 style = FontStyleRegular;
370 if (font->otm.otmTextMetrics.tmItalic)
371 style |= FontStyleItalic;
372 if (font->otm.otmTextMetrics.tmUnderlined)
373 style |= FontStyleUnderline;
374 if (font->otm.otmTextMetrics.tmStruckOut)
375 style |= FontStyleStrikeout;
376
377 return style;
378 }
379
380 /*******************************************************************************
381 * GdipGetFontStyle [GDIPLUS.@]
382 *
383 * Gets the font's style, returned in bitwise OR of FontStyle enumeration
384 *
385 * PARAMS
386 * font [I] font to request from
387 * style [O] resulting pointer to a FontStyle enumeration
388 *
389 * RETURNS
390 * SUCCESS: Ok
391 * FAILURE: InvalidParameter
392 */
393 GpStatus WINGDIPAPI GdipGetFontStyle(GpFont *font, INT *style)
394 {
395 TRACE("%p %p\n", font, style);
396
397 if (!(font && style))
398 return InvalidParameter;
399
400 *style = get_font_style(font);
401 TRACE("%s,%ld => %d\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *style);
402
403 return Ok;
404 }
405
406 /*******************************************************************************
407 * GdipGetFontUnit [GDIPLUS.@]
408 *
409 * PARAMS
410 * font [I] Font to retrieve from
411 * unit [O] Return value
412 *
413 * RETURNS
414 * FAILURE: font or unit was NULL
415 * OK: otherwise
416 */
417 GpStatus WINGDIPAPI GdipGetFontUnit(GpFont *font, Unit *unit)
418 {
419 TRACE("(%p, %p)\n", font, unit);
420
421 if (!(font && unit)) return InvalidParameter;
422
423 *unit = font->unit;
424 TRACE("%s,%ld => %d\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *unit);
425
426 return Ok;
427 }
428
429 /*******************************************************************************
430 * GdipGetLogFontA [GDIPLUS.@]
431 */
432 GpStatus WINGDIPAPI GdipGetLogFontA(GpFont *font, GpGraphics *graphics,
433 LOGFONTA *lfa)
434 {
435 GpStatus status;
436 LOGFONTW lfw;
437
438 TRACE("(%p, %p, %p)\n", font, graphics, lfa);
439
440 status = GdipGetLogFontW(font, graphics, &lfw);
441 if(status != Ok)
442 return status;
443
444 memcpy(lfa, &lfw, FIELD_OFFSET(LOGFONTA,lfFaceName) );
445
446 if(!WideCharToMultiByte(CP_ACP, 0, lfw.lfFaceName, -1, lfa->lfFaceName, LF_FACESIZE, NULL, NULL))
447 return GenericError;
448
449 return Ok;
450 }
451
452 /*******************************************************************************
453 * GdipGetLogFontW [GDIPLUS.@]
454 */
455 GpStatus WINGDIPAPI GdipGetLogFontW(GpFont *font, GpGraphics *graphics, LOGFONTW *lf)
456 {
457 REAL angle, rel_height, height;
458 GpMatrix matrix;
459 GpPointF pt[3];
460
461 TRACE("(%p, %p, %p)\n", font, graphics, lf);
462
463 if (!font || !graphics || !lf)
464 return InvalidParameter;
465
466 matrix = graphics->worldtrans;
467
468 if (font->unit == UnitPixel || font->unit == UnitWorld)
469 {
470 height = units_to_pixels(font->emSize, graphics->unit, graphics->yres, graphics->printer_display);
471 if (graphics->unit != UnitDisplay)
472 GdipScaleMatrix(&matrix, graphics->scale, graphics->scale, MatrixOrderAppend);
473 }
474 else
475 {
476 if (graphics->unit == UnitDisplay || graphics->unit == UnitPixel)
477 height = units_to_pixels(font->emSize, font->unit, graphics->xres, graphics->printer_display);
478 else
479 height = units_to_pixels(font->emSize, font->unit, graphics->yres, graphics->printer_display);
480 }
481
482 pt[0].X = 0.0;
483 pt[0].Y = 0.0;
484 pt[1].X = 1.0;
485 pt[1].Y = 0.0;
486 pt[2].X = 0.0;
487 pt[2].Y = 1.0;
488 GdipTransformMatrixPoints(&matrix, pt, 3);
489 angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
490 rel_height = sqrt((pt[2].Y - pt[0].Y) * (pt[2].Y - pt[0].Y)+
491 (pt[2].X - pt[0].X) * (pt[2].X - pt[0].X));
492
493 lf->lfHeight = -gdip_round(height * rel_height);
494 lf->lfWidth = 0;
495 lf->lfEscapement = lf->lfOrientation = gdip_round((angle / M_PI) * 1800.0);
496 if (lf->lfEscapement < 0)
497 {
498 lf->lfEscapement += 3600;
499 lf->lfOrientation += 3600;
500 }
501 lf->lfWeight = font->otm.otmTextMetrics.tmWeight;
502 lf->lfItalic = font->otm.otmTextMetrics.tmItalic ? 1 : 0;
503 lf->lfUnderline = font->otm.otmTextMetrics.tmUnderlined ? 1 : 0;
504 lf->lfStrikeOut = font->otm.otmTextMetrics.tmStruckOut ? 1 : 0;
505 lf->lfCharSet = font->otm.otmTextMetrics.tmCharSet;
506 lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
507 lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
508 lf->lfQuality = DEFAULT_QUALITY;
509 lf->lfPitchAndFamily = 0;
510 lstrcpyW(lf->lfFaceName, font->family->FamilyName);
511
512 TRACE("=> %s,%ld\n", debugstr_w(lf->lfFaceName), lf->lfHeight);
513
514 return Ok;
515 }
516
517 /*******************************************************************************
518 * GdipCloneFont [GDIPLUS.@]
519 */
520 GpStatus WINGDIPAPI GdipCloneFont(GpFont *font, GpFont **cloneFont)
521 {
522 TRACE("(%p, %p)\n", font, cloneFont);
523
524 if(!font || !cloneFont)
525 return InvalidParameter;
526
527 *cloneFont = heap_alloc_zero(sizeof(GpFont));
528 if(!*cloneFont) return OutOfMemory;
529
530 **cloneFont = *font;
531 return Ok;
532 }
533
534 /*******************************************************************************
535 * GdipGetFontHeight [GDIPLUS.@]
536 * PARAMS
537 * font [I] Font to retrieve height from
538 * graphics [I] The current graphics context
539 * height [O] Resulting height
540 * RETURNS
541 * SUCCESS: Ok
542 * FAILURE: Another element of GpStatus
543 *
544 * NOTES
545 * Forwards to GdipGetFontHeightGivenDPI
546 */
547 GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont *font,
548 GDIPCONST GpGraphics *graphics, REAL *height)
549 {
550 REAL dpi;
551 GpStatus stat;
552 REAL font_height;
553
554 TRACE("%p %p %p\n", font, graphics, height);
555
556 if (!font || !height) return InvalidParameter;
557
558 stat = GdipGetFontHeightGivenDPI(font, font->family->dpi, &font_height);
559 if (stat != Ok) return stat;
560
561 if (!graphics)
562 {
563 *height = font_height;
564 TRACE("%s,%ld => %f\n",
565 debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *height);
566 return Ok;
567 }
568
569 stat = GdipGetDpiY((GpGraphics *)graphics, &dpi);
570 if (stat != Ok) return stat;
571
572 *height = pixels_to_units(font_height, graphics->unit, dpi, graphics->printer_display);
573
574 TRACE("%s,%ld(unit %d) => %f\n",
575 debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, graphics->unit, *height);
576 return Ok;
577 }
578
579 /*******************************************************************************
580 * GdipGetFontHeightGivenDPI [GDIPLUS.@]
581 * PARAMS
582 * font [I] Font to retrieve DPI from
583 * dpi [I] DPI to assume
584 * height [O] Return value
585 *
586 * RETURNS
587 * SUCCESS: Ok
588 * FAILURE: InvalidParameter if font or height is NULL
589 *
590 * NOTES
591 * According to MSDN, the result is (lineSpacing)*(fontSize / emHeight)*dpi
592 * (for anything other than unit Pixel)
593 */
594 GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height)
595 {
596 GpStatus stat;
597 INT style;
598 UINT16 line_spacing, em_height;
599 REAL font_size;
600
601 if (!font || !height) return InvalidParameter;
602
603 TRACE("%p (%s), %f, %p\n", font,
604 debugstr_w(font->family->FamilyName), dpi, height);
605
606 font_size = units_to_pixels(get_font_size(font), font->unit, dpi, FALSE);
607 style = get_font_style(font);
608 stat = GdipGetLineSpacing(font->family, style, &line_spacing);
609 if (stat != Ok) return stat;
610 stat = GdipGetEmHeight(font->family, style, &em_height);
611 if (stat != Ok) return stat;
612
613 *height = (REAL)line_spacing * font_size / (REAL)em_height;
614
615 TRACE("%s,%ld => %f\n",
616 debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *height);
617
618 return Ok;
619 }
620
621 /***********************************************************************
622 * Borrowed from GDI32:
623 *
624 * Elf is really an ENUMLOGFONTEXW, and ntm is a NEWTEXTMETRICEXW.
625 * We have to use other types because of the FONTENUMPROCW definition.
626 */
627 static INT CALLBACK is_font_installed_proc(const LOGFONTW *elf,
628 const TEXTMETRICW *ntm, DWORD type, LPARAM lParam)
629 {
630 const ENUMLOGFONTW *elfW = (const ENUMLOGFONTW *)elf;
631 LOGFONTW *lf = (LOGFONTW *)lParam;
632
633 if (type & RASTER_FONTTYPE)
634 return 1;
635
636 *lf = *elf;
637 /* replace substituted font name by a real one */
638 lstrcpynW(lf->lfFaceName, elfW->elfFullName, LF_FACESIZE);
639 return 0;
640 }
641
642 struct font_metrics
643 {
644 WCHAR facename[LF_FACESIZE];
645 UINT16 em_height, ascent, descent, line_spacing; /* in font units */
646 int dpi;
647 };
648
649 static BOOL get_font_metrics(HDC hdc, struct font_metrics *fm)
650 {
651 OUTLINETEXTMETRICW otm;
652 TT_OS2_V2 tt_os2;
653 TT_HHEA tt_hori;
654 LONG size;
655 UINT16 line_gap;
656
657 otm.otmSize = sizeof(otm);
658 if (!GetOutlineTextMetricsW(hdc, otm.otmSize, &otm)) return FALSE;
659
660 fm->em_height = otm.otmEMSquare;
661 fm->dpi = GetDeviceCaps(hdc, LOGPIXELSY);
662
663 memset(&tt_hori, 0, sizeof(tt_hori));
664 if (GetFontData(hdc, MS_HHEA_TAG, 0, &tt_hori, sizeof(tt_hori)) != GDI_ERROR)
665 {
666 fm->ascent = GET_BE_WORD(tt_hori.Ascender);
667 fm->descent = -GET_BE_WORD(tt_hori.Descender);
668 TRACE("hhea: ascent %d, descent %d\n", fm->ascent, fm->descent);
669 line_gap = GET_BE_WORD(tt_hori.LineGap);
670 fm->line_spacing = fm->ascent + fm->descent + line_gap;
671 TRACE("line_gap %u, line_spacing %u\n", line_gap, fm->line_spacing);
672 if (fm->ascent + fm->descent != 0) return TRUE;
673 }
674
675 size = GetFontData(hdc, MS_OS2_TAG, 0, NULL, 0);
676 if (size == GDI_ERROR) return FALSE;
677
678 if (size > sizeof(tt_os2)) size = sizeof(tt_os2);
679
680 memset(&tt_os2, 0, sizeof(tt_os2));
681 if (GetFontData(hdc, MS_OS2_TAG, 0, &tt_os2, size) != size) return FALSE;
682
683 fm->ascent = GET_BE_WORD(tt_os2.usWinAscent);
684 fm->descent = GET_BE_WORD(tt_os2.usWinDescent);
685 TRACE("usWinAscent %u, usWinDescent %u\n", fm->ascent, fm->descent);
686 if (fm->ascent + fm->descent == 0)
687 {
688 fm->ascent = GET_BE_WORD(tt_os2.sTypoAscender);
689 fm->descent = GET_BE_WORD(tt_os2.sTypoDescender);
690 TRACE("sTypoAscender %u, sTypoDescender %u\n", fm->ascent, fm->descent);
691 }
692 line_gap = GET_BE_WORD(tt_os2.sTypoLineGap);
693 fm->line_spacing = fm->ascent + fm->descent + line_gap;
694 TRACE("line_gap %u, line_spacing %u\n", line_gap, fm->line_spacing);
695 return TRUE;
696 }
697
698 /*******************************************************************************
699 * GdipCreateFontFamilyFromName [GDIPLUS.@]
700 *
701 * Creates a font family object based on a supplied name
702 *
703 * PARAMS
704 * name [I] Name of the font
705 * fontCollection [I] What font collection (if any) the font belongs to (may be NULL)
706 * FontFamily [O] Pointer to the resulting FontFamily object
707 *
708 * RETURNS
709 * SUCCESS: Ok
710 * FAILURE: FamilyNotFound if the requested FontFamily does not exist on the system
711 * FAILURE: Invalid parameter if FontFamily or name is NULL
712 *
713 * NOTES
714 * If fontCollection is NULL then the object is not part of any collection
715 *
716 */
717
718 GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name,
719 GpFontCollection *collection,
720 GpFontFamily **family)
721 {
722 HDC hdc;
723 LOGFONTW lf;
724 GpStatus status;
725 int i;
726
727 TRACE("%s, %p %p\n", debugstr_w(name), collection, family);
728
729 if (!name || !family)
730 return InvalidParameter;
731
732 if (!collection)
733 {
734 status = GdipNewInstalledFontCollection(&collection);
735 if (status != Ok) return status;
736 }
737
738 status = FontFamilyNotFound;
739
740 hdc = CreateCompatibleDC(0);
741
742 if (!EnumFontFamiliesW(hdc, name, is_font_installed_proc, (LPARAM)&lf))
743 {
744 for (i = 0; i < collection->count; i++)
745 {
746 if (!wcsicmp(lf.lfFaceName, collection->FontFamilies[i]->FamilyName))
747 {
748 status = GdipCloneFontFamily(collection->FontFamilies[i], family);
749 TRACE("<-- %p\n", *family);
750 break;
751 }
752 }
753 }
754
755 DeleteDC(hdc);
756 return status;
757 }
758
759 /*******************************************************************************
760 * GdipCloneFontFamily [GDIPLUS.@]
761 *
762 * Creates a deep copy of a Font Family object
763 *
764 * PARAMS
765 * FontFamily [I] Font to clone
766 * clonedFontFamily [O] The resulting cloned font
767 *
768 * RETURNS
769 * SUCCESS: Ok
770 */
771 GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily *family, GpFontFamily **clone)
772 {
773 if (!family || !clone)
774 return InvalidParameter;
775
776 TRACE("%p (%s), %p\n", family, debugstr_w(family->FamilyName), clone);
777
778 *clone = family;
779
780 if (!family->installed)
781 InterlockedIncrement(&family->ref);
782
783 return Ok;
784 }
785
786 /*******************************************************************************
787 * GdipGetFamilyName [GDIPLUS.@]
788 *
789 * Returns the family name into name
790 *
791 * PARAMS
792 * *family [I] Family to retrieve from
793 * *name [O] WCHARS of the family name
794 * LANGID [I] charset
795 *
796 * RETURNS
797 * SUCCESS: Ok
798 * FAILURE: InvalidParameter if family is NULL
799 *
800 * NOTES
801 * If name is NULL, XP and Vista crash but not Windows 7+
802 */
803 GpStatus WINGDIPAPI GdipGetFamilyName (GDIPCONST GpFontFamily *family,
804 WCHAR *name, LANGID language)
805 {
806 static int lang_fixme;
807
808 TRACE("%p, %p, %d\n", family, name, language);
809
810 if (family == NULL)
811 return InvalidParameter;
812
813 if (name == NULL)
814 return Ok;
815
816 if (language != LANG_NEUTRAL && !lang_fixme++)
817 FIXME("No support for handling of multiple languages!\n");
818
819 lstrcpynW (name, family->FamilyName, LF_FACESIZE);
820
821 return Ok;
822 }
823
824
825 /*****************************************************************************
826 * GdipDeleteFontFamily [GDIPLUS.@]
827 *
828 * Removes the specified FontFamily
829 *
830 * PARAMS
831 * *FontFamily [I] The family to delete
832 *
833 * RETURNS
834 * SUCCESS: Ok
835 * FAILURE: InvalidParameter if FontFamily is NULL.
836 *
837 */
838 GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily *FontFamily)
839 {
840 if (!FontFamily)
841 return InvalidParameter;
842
843 if (!FontFamily->installed && !InterlockedDecrement(&FontFamily->ref))
844 {
845 heap_free(FontFamily);
846 }
847
848 return Ok;
849 }
850
851 GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily *family,
852 INT style, UINT16* CellAscent)
853 {
854 if (!(family && CellAscent)) return InvalidParameter;
855
856 *CellAscent = family->ascent;
857 TRACE("%s => %u\n", debugstr_w(family->FamilyName), *CellAscent);
858
859 return Ok;
860 }
861
862 GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily *family,
863 INT style, UINT16* CellDescent)
864 {
865 TRACE("(%p, %d, %p)\n", family, style, CellDescent);
866
867 if (!(family && CellDescent)) return InvalidParameter;
868
869 *CellDescent = family->descent;
870 TRACE("%s => %u\n", debugstr_w(family->FamilyName), *CellDescent);
871
872 return Ok;
873 }
874
875 /*******************************************************************************
876 * GdipGetEmHeight [GDIPLUS.@]
877 *
878 * Gets the height of the specified family in EmHeights
879 *
880 * PARAMS
881 * family [I] Family to retrieve from
882 * style [I] (optional) style
883 * EmHeight [O] return value
884 *
885 * RETURNS
886 * SUCCESS: Ok
887 * FAILURE: InvalidParameter
888 */
889 GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily *family, INT style, UINT16* EmHeight)
890 {
891 if (!(family && EmHeight)) return InvalidParameter;
892
893 TRACE("%p (%s), %d, %p\n", family, debugstr_w(family->FamilyName), style, EmHeight);
894
895 *EmHeight = family->em_height;
896 TRACE("%s => %u\n", debugstr_w(family->FamilyName), *EmHeight);
897
898 return Ok;
899 }
900
901
902 /*******************************************************************************
903 * GdipGetLineSpacing [GDIPLUS.@]
904 *
905 * Returns the line spacing in design units
906 *
907 * PARAMS
908 * family [I] Family to retrieve from
909 * style [I] (Optional) font style
910 * LineSpacing [O] Return value
911 *
912 * RETURNS
913 * SUCCESS: Ok
914 * FAILURE: InvalidParameter (family or LineSpacing was NULL)
915 */
916 GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily *family,
917 INT style, UINT16* LineSpacing)
918 {
919 TRACE("%p, %d, %p\n", family, style, LineSpacing);
920
921 if (!(family && LineSpacing))
922 return InvalidParameter;
923
924 if (style) FIXME("ignoring style\n");
925
926 *LineSpacing = family->line_spacing;
927 TRACE("%s => %u\n", debugstr_w(family->FamilyName), *LineSpacing);
928
929 return Ok;
930 }
931
932 static INT CALLBACK font_has_style_proc(const LOGFONTW *elf,
933 const TEXTMETRICW *ntm, DWORD type, LPARAM lParam)
934 {
935 INT fontstyle = FontStyleRegular;
936
937 if (!ntm) return 1;
938
939 if (ntm->tmWeight >= FW_BOLD) fontstyle |= FontStyleBold;
940 if (ntm->tmItalic) fontstyle |= FontStyleItalic;
941 if (ntm->tmUnderlined) fontstyle |= FontStyleUnderline;
942 if (ntm->tmStruckOut) fontstyle |= FontStyleStrikeout;
943
944 return (INT)lParam != fontstyle;
945 }
946
947 GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily* family,
948 INT style, BOOL* IsStyleAvailable)
949 {
950 HDC hdc;
951
952 TRACE("%p %d %p\n", family, style, IsStyleAvailable);
953
954 if (!(family && IsStyleAvailable))
955 return InvalidParameter;
956
957 *IsStyleAvailable = FALSE;
958
959 hdc = CreateCompatibleDC(0);
960
961 if(!EnumFontFamiliesW(hdc, family->FamilyName, font_has_style_proc, (LPARAM)style))
962 *IsStyleAvailable = TRUE;
963
964 DeleteDC(hdc);
965
966 return Ok;
967 }
968
969 /*****************************************************************************
970 * GdipGetGenericFontFamilyMonospace [GDIPLUS.@]
971 *
972 * Obtains a serif family (Courier New on Windows)
973 *
974 * PARAMS
975 * **nativeFamily [I] Where the font will be stored
976 *
977 * RETURNS
978 * InvalidParameter if nativeFamily is NULL.
979 * Ok otherwise.
980 */
981 GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily)
982 {
983 GpStatus stat;
984
985 if (nativeFamily == NULL) return InvalidParameter;
986
987 stat = GdipCreateFontFamilyFromName(L"Courier New", NULL, nativeFamily);
988
989 if (stat == FontFamilyNotFound)
990 stat = GdipCreateFontFamilyFromName(L"Liberation Mono", NULL, nativeFamily);
991
992 if (stat == FontFamilyNotFound)
993 ERR("Missing 'Courier New' font\n");
994
995 return stat;
996 }
997
998 /*****************************************************************************
999 * GdipGetGenericFontFamilySerif [GDIPLUS.@]
1000 *
1001 * Obtains a serif family (Times New Roman on Windows)
1002 *
1003 * PARAMS
1004 * **nativeFamily [I] Where the font will be stored
1005 *
1006 * RETURNS
1007 * InvalidParameter if nativeFamily is NULL.
1008 * Ok otherwise.
1009 */
1010 GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily)
1011 {
1012 GpStatus stat;
1013
1014 TRACE("(%p)\n", nativeFamily);
1015
1016 if (nativeFamily == NULL) return InvalidParameter;
1017
1018 stat = GdipCreateFontFamilyFromName(L"Times New Roman", NULL, nativeFamily);
1019
1020 if (stat == FontFamilyNotFound)
1021 stat = GdipCreateFontFamilyFromName(L"Liberation Serif", NULL, nativeFamily);
1022
1023 if (stat == FontFamilyNotFound)
1024 ERR("Missing 'Times New Roman' font\n");
1025
1026 return stat;
1027 }
1028
1029 /*****************************************************************************
1030 * GdipGetGenericFontFamilySansSerif [GDIPLUS.@]
1031 *
1032 * Obtains a serif family (Microsoft Sans Serif on Windows)
1033 *
1034 * PARAMS
1035 * **nativeFamily [I] Where the font will be stored
1036 *
1037 * RETURNS
1038 * InvalidParameter if nativeFamily is NULL.
1039 * Ok otherwise.
1040 */
1041 GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily)
1042 {
1043 GpStatus stat;
1044
1045 TRACE("(%p)\n", nativeFamily);
1046
1047 if (nativeFamily == NULL) return InvalidParameter;
1048
1049 stat = GdipCreateFontFamilyFromName(L"Microsoft Sans Serif", NULL, nativeFamily);
1050
1051 if (stat == FontFamilyNotFound)
1052 /* FIXME: Microsoft Sans Serif is not installed on Wine. */
1053 stat = GdipCreateFontFamilyFromName(L"Tahoma", NULL, nativeFamily);
1054
1055 return stat;
1056 }
1057
1058 /*****************************************************************************
1059 * GdipNewPrivateFontCollection [GDIPLUS.@]
1060 */
1061 GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection** fontCollection)
1062 {
1063 TRACE("%p\n", fontCollection);
1064
1065 if (!fontCollection)
1066 return InvalidParameter;
1067
1068 *fontCollection = heap_alloc_zero(sizeof(GpFontCollection));
1069 if (!*fontCollection) return OutOfMemory;
1070
1071 (*fontCollection)->FontFamilies = NULL;
1072 (*fontCollection)->count = 0;
1073 (*fontCollection)->allocated = 0;
1074
1075 TRACE("<-- %p\n", *fontCollection);
1076
1077 return Ok;
1078 }
1079
1080 /*****************************************************************************
1081 * GdipDeletePrivateFontCollection [GDIPLUS.@]
1082 */
1083 GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection **fontCollection)
1084 {
1085 INT i;
1086
1087 TRACE("%p\n", fontCollection);
1088
1089 if (!fontCollection)
1090 return InvalidParameter;
1091
1092 for (i = 0; i < (*fontCollection)->count; i++) GdipDeleteFontFamily((*fontCollection)->FontFamilies[i]);
1093 heap_free((*fontCollection)->FontFamilies);
1094 heap_free(*fontCollection);
1095
1096 return Ok;
1097 }
1098
1099 /*****************************************************************************
1100 * GdipPrivateAddFontFile [GDIPLUS.@]
1101 */
1102 GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection *collection, GDIPCONST WCHAR *name)
1103 {
1104 HANDLE file, mapping;
1105 LARGE_INTEGER size;
1106 void *mem;
1107 GpStatus status;
1108
1109 TRACE("%p, %s\n", collection, debugstr_w(name));
1110
1111 if (!collection || !name) return InvalidParameter;
1112
1113 file = CreateFileW(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1114 if (file == INVALID_HANDLE_VALUE) return InvalidParameter;
1115
1116 if (!GetFileSizeEx(file, &size) || size.u.HighPart)
1117 {
1118 CloseHandle(file);
1119 return InvalidParameter;
1120 }
1121
1122 mapping = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
1123 CloseHandle(file);
1124 if (!mapping) return InvalidParameter;
1125
1126 mem = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
1127 CloseHandle(mapping);
1128 if (!mem) return InvalidParameter;
1129
1130 /* GdipPrivateAddMemoryFont creates a copy of the memory block */
1131 status = GdipPrivateAddMemoryFont(collection, mem, size.u.LowPart);
1132 UnmapViewOfFile(mem);
1133
1134 return status;
1135 }
1136
1137 #define TT_PLATFORM_APPLE_UNICODE 0
1138 #define TT_PLATFORM_MACINTOSH 1
1139 #define TT_PLATFORM_MICROSOFT 3
1140
1141 #define TT_APPLE_ID_DEFAULT 0
1142 #define TT_APPLE_ID_ISO_10646 2
1143 #define TT_APPLE_ID_UNICODE_2_0 3
1144
1145 #define TT_MS_ID_SYMBOL_CS 0
1146 #define TT_MS_ID_UNICODE_CS 1
1147
1148 #define TT_MAC_ID_SIMPLIFIED_CHINESE 25
1149
1150 #define NAME_ID_FULL_FONT_NAME 4
1151
1152 typedef struct {
1153 ULONG version;
1154 USHORT tables_no;
1155 USHORT search_range;
1156 USHORT entry_selector;
1157 USHORT range_shift;
1158 } tt_header;
1159
1160 #define TT_HEADER_VERSION_1 0x00010000
1161 #define TT_HEADER_VERSION_CFF 0x4f54544f
1162
1163 typedef struct {
1164 char tag[4]; /* table name */
1165 ULONG check_sum; /* Check sum */
1166 ULONG offset; /* Offset from beginning of file */
1167 ULONG length; /* length of the table in bytes */
1168 } tt_table_directory;
1169
1170 typedef struct {
1171 USHORT format; /* format selector. Always 0 */
1172 USHORT count; /* Name Records count */
1173 USHORT string_offset; /* Offset for strings storage, * from start of the table */
1174 } tt_name_table;
1175
1176 typedef struct {
1177 USHORT platform_id;
1178 USHORT encoding_id;
1179 USHORT language_id;
1180 USHORT name_id;
1181 USHORT length;
1182 USHORT offset; /* from start of storage area */
1183 } tt_name_record;
1184
1185 /* Copied from gdi32/freetype.c */
1186
1187 static const LANGID mac_langid_table[] =
1188 {
1189 MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ENGLISH */
1190 MAKELANGID(LANG_FRENCH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_FRENCH */
1191 MAKELANGID(LANG_GERMAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_GERMAN */
1192 MAKELANGID(LANG_ITALIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ITALIAN */
1193 MAKELANGID(LANG_DUTCH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_DUTCH */
1194 MAKELANGID(LANG_SWEDISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SWEDISH */
1195 MAKELANGID(LANG_SPANISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SPANISH */
1196 MAKELANGID(LANG_DANISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_DANISH */
1197 MAKELANGID(LANG_PORTUGUESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_PORTUGUESE */
1198 MAKELANGID(LANG_NORWEGIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_NORWEGIAN */
1199 MAKELANGID(LANG_HEBREW,SUBLANG_DEFAULT), /* TT_MAC_LANGID_HEBREW */
1200 MAKELANGID(LANG_JAPANESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_JAPANESE */
1201 MAKELANGID(LANG_ARABIC,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ARABIC */
1202 MAKELANGID(LANG_FINNISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_FINNISH */
1203 MAKELANGID(LANG_GREEK,SUBLANG_DEFAULT), /* TT_MAC_LANGID_GREEK */
1204 MAKELANGID(LANG_ICELANDIC,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ICELANDIC */
1205 MAKELANGID(LANG_MALTESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_MALTESE */
1206 MAKELANGID(LANG_TURKISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TURKISH */
1207 MAKELANGID(LANG_CROATIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_CROATIAN */
1208 MAKELANGID(LANG_CHINESE_TRADITIONAL,SUBLANG_DEFAULT), /* TT_MAC_LANGID_CHINESE_TRADITIONAL */
1209 MAKELANGID(LANG_URDU,SUBLANG_DEFAULT), /* TT_MAC_LANGID_URDU */
1210 MAKELANGID(LANG_HINDI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_HINDI */
1211 MAKELANGID(LANG_THAI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_THAI */
1212 MAKELANGID(LANG_KOREAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_KOREAN */
1213 MAKELANGID(LANG_LITHUANIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_LITHUANIAN */
1214 MAKELANGID(LANG_POLISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_POLISH */
1215 MAKELANGID(LANG_HUNGARIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_HUNGARIAN */
1216 MAKELANGID(LANG_ESTONIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ESTONIAN */
1217 MAKELANGID(LANG_LATVIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_LETTISH */
1218 MAKELANGID(LANG_SAMI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SAAMISK */
1219 MAKELANGID(LANG_FAEROESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_FAEROESE */
1220 MAKELANGID(LANG_FARSI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_FARSI */
1221 MAKELANGID(LANG_RUSSIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_RUSSIAN */
1222 MAKELANGID(LANG_CHINESE_SIMPLIFIED,SUBLANG_DEFAULT), /* TT_MAC_LANGID_CHINESE_SIMPLIFIED */
1223 MAKELANGID(LANG_DUTCH,SUBLANG_DUTCH_BELGIAN), /* TT_MAC_LANGID_FLEMISH */
1224 MAKELANGID(LANG_IRISH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_IRISH */
1225 MAKELANGID(LANG_ALBANIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ALBANIAN */
1226 MAKELANGID(LANG_ROMANIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ROMANIAN */
1227 MAKELANGID(LANG_CZECH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_CZECH */
1228 MAKELANGID(LANG_SLOVAK,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SLOVAK */
1229 MAKELANGID(LANG_SLOVENIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SLOVENIAN */
1230 0, /* TT_MAC_LANGID_YIDDISH */
1231 MAKELANGID(LANG_SERBIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SERBIAN */
1232 MAKELANGID(LANG_MACEDONIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_MACEDONIAN */
1233 MAKELANGID(LANG_BULGARIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_BULGARIAN */
1234 MAKELANGID(LANG_UKRAINIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_UKRAINIAN */
1235 MAKELANGID(LANG_BELARUSIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_BYELORUSSIAN */
1236 MAKELANGID(LANG_UZBEK,SUBLANG_DEFAULT), /* TT_MAC_LANGID_UZBEK */
1237 MAKELANGID(LANG_KAZAK,SUBLANG_DEFAULT), /* TT_MAC_LANGID_KAZAKH */
1238 MAKELANGID(LANG_AZERI,SUBLANG_AZERI_CYRILLIC), /* TT_MAC_LANGID_AZERBAIJANI */
1239 0, /* TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT */
1240 MAKELANGID(LANG_ARMENIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ARMENIAN */
1241 MAKELANGID(LANG_GEORGIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_GEORGIAN */
1242 0, /* TT_MAC_LANGID_MOLDAVIAN */
1243 MAKELANGID(LANG_KYRGYZ,SUBLANG_DEFAULT), /* TT_MAC_LANGID_KIRGHIZ */
1244 MAKELANGID(LANG_TAJIK,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TAJIKI */
1245 MAKELANGID(LANG_TURKMEN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TURKMEN */
1246 MAKELANGID(LANG_MONGOLIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_MONGOLIAN */
1247 MAKELANGID(LANG_MONGOLIAN,SUBLANG_MONGOLIAN_CYRILLIC_MONGOLIA), /* TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT */
1248 MAKELANGID(LANG_PASHTO,SUBLANG_DEFAULT), /* TT_MAC_LANGID_PASHTO */
1249 0, /* TT_MAC_LANGID_KURDISH */
1250 MAKELANGID(LANG_KASHMIRI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_KASHMIRI */
1251 MAKELANGID(LANG_SINDHI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SINDHI */
1252 MAKELANGID(LANG_TIBETAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TIBETAN */
1253 MAKELANGID(LANG_NEPALI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_NEPALI */
1254 MAKELANGID(LANG_SANSKRIT,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SANSKRIT */
1255 MAKELANGID(LANG_MARATHI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_MARATHI */
1256 MAKELANGID(LANG_BENGALI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_BENGALI */
1257 MAKELANGID(LANG_ASSAMESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ASSAMESE */
1258 MAKELANGID(LANG_GUJARATI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_GUJARATI */
1259 MAKELANGID(LANG_PUNJABI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_PUNJABI */
1260 MAKELANGID(LANG_ORIYA,SUBLANG_DEFAULT), /* TT_MAC_LANGID_ORIYA */
1261 MAKELANGID(LANG_MALAYALAM,SUBLANG_DEFAULT), /* TT_MAC_LANGID_MALAYALAM */
1262 MAKELANGID(LANG_KANNADA,SUBLANG_DEFAULT), /* TT_MAC_LANGID_KANNADA */
1263 MAKELANGID(LANG_TAMIL,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TAMIL */
1264 MAKELANGID(LANG_TELUGU,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TELUGU */
1265 MAKELANGID(LANG_SINHALESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SINHALESE */
1266 0, /* TT_MAC_LANGID_BURMESE */
1267 MAKELANGID(LANG_KHMER,SUBLANG_DEFAULT), /* TT_MAC_LANGID_KHMER */
1268 MAKELANGID(LANG_LAO,SUBLANG_DEFAULT), /* TT_MAC_LANGID_LAO */
1269 MAKELANGID(LANG_VIETNAMESE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_VIETNAMESE */
1270 MAKELANGID(LANG_INDONESIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_INDONESIAN */
1271 0, /* TT_MAC_LANGID_TAGALOG */
1272 MAKELANGID(LANG_MALAY,SUBLANG_DEFAULT), /* TT_MAC_LANGID_MALAY_ROMAN_SCRIPT */
1273 0, /* TT_MAC_LANGID_MALAY_ARABIC_SCRIPT */
1274 MAKELANGID(LANG_AMHARIC,SUBLANG_DEFAULT), /* TT_MAC_LANGID_AMHARIC */
1275 MAKELANGID(LANG_TIGRIGNA,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TIGRINYA */
1276 0, /* TT_MAC_LANGID_GALLA */
1277 0, /* TT_MAC_LANGID_SOMALI */
1278 MAKELANGID(LANG_SWAHILI,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SWAHILI */
1279 0, /* TT_MAC_LANGID_RUANDA */
1280 0, /* TT_MAC_LANGID_RUNDI */
1281 0, /* TT_MAC_LANGID_CHEWA */
1282 0, /* TT_MAC_LANGID_MALAGASY */
1283 0, /* TT_MAC_LANGID_ESPERANTO */
1284 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 95-111 */
1285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 112-127 */
1286 MAKELANGID(LANG_WELSH,SUBLANG_DEFAULT), /* TT_MAC_LANGID_WELSH */
1287 MAKELANGID(LANG_BASQUE,SUBLANG_DEFAULT), /* TT_MAC_LANGID_BASQUE */
1288 MAKELANGID(LANG_CATALAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_CATALAN */
1289 0, /* TT_MAC_LANGID_LATIN */
1290 MAKELANGID(LANG_QUECHUA,SUBLANG_DEFAULT), /* TT_MAC_LANGID_QUECHUA */
1291 0, /* TT_MAC_LANGID_GUARANI */
1292 0, /* TT_MAC_LANGID_AYMARA */
1293 MAKELANGID(LANG_TATAR,SUBLANG_DEFAULT), /* TT_MAC_LANGID_TATAR */
1294 MAKELANGID(LANG_UIGHUR,SUBLANG_DEFAULT), /* TT_MAC_LANGID_UIGHUR */
1295 0, /* TT_MAC_LANGID_DZONGKHA */
1296 0, /* TT_MAC_LANGID_JAVANESE */
1297 0, /* TT_MAC_LANGID_SUNDANESE */
1298 MAKELANGID(LANG_GALICIAN,SUBLANG_DEFAULT), /* TT_MAC_LANGID_GALICIAN */
1299 MAKELANGID(LANG_AFRIKAANS,SUBLANG_DEFAULT), /* TT_MAC_LANGID_AFRIKAANS */
1300 MAKELANGID(LANG_BRETON,SUBLANG_DEFAULT), /* TT_MAC_LANGID_BRETON */
1301 MAKELANGID(LANG_INUKTITUT,SUBLANG_DEFAULT), /* TT_MAC_LANGID_INUKTITUT */
1302 MAKELANGID(LANG_SCOTTISH_GAELIC,SUBLANG_DEFAULT), /* TT_MAC_LANGID_SCOTTISH_GAELIC */
1303 0, /* TT_MAC_LANGID_MANX_GAELIC */
1304 MAKELANGID(LANG_IRISH,SUBLANG_IRISH_IRELAND), /* TT_MAC_LANGID_IRISH_GAELIC */
1305 0, /* TT_MAC_LANGID_TONGAN */
1306 0, /* TT_MAC_LANGID_GREEK_POLYTONIC */
1307 MAKELANGID(LANG_GREENLANDIC,SUBLANG_DEFAULT), /* TT_MAC_LANGID_GREELANDIC */
1308 MAKELANGID(LANG_AZERI,SUBLANG_AZERI_LATIN), /* TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT */
1309 };
1310
1311 static inline WORD get_mac_code_page( const tt_name_record *name )
1312 {
1313 WORD encoding_id = GET_BE_WORD(name->encoding_id);
1314 if (encoding_id == TT_MAC_ID_SIMPLIFIED_CHINESE) return 10008; /* special case */
1315 return 10000 + encoding_id;
1316 }
1317
1318 static int match_name_table_language( const tt_name_record *name, LANGID lang )
1319 {
1320 LANGID name_lang;
1321
1322 switch (GET_BE_WORD(name->platform_id))
1323 {
1324 case TT_PLATFORM_MICROSOFT:
1325 switch (GET_BE_WORD(name->encoding_id))
1326 {
1327 case TT_MS_ID_UNICODE_CS:
1328 case TT_MS_ID_SYMBOL_CS:
1329 name_lang = GET_BE_WORD(name->language_id);
1330 break;
1331 default:
1332 return 0;
1333 }
1334 break;
1335 case TT_PLATFORM_MACINTOSH:
1336 if (!IsValidCodePage( get_mac_code_page( name ))) return 0;
1337 name_lang = GET_BE_WORD(name->language_id);
1338 if (name_lang >= ARRAY_SIZE(mac_langid_table)) return 0;
1339 name_lang = mac_langid_table[name_lang];
1340 break;
1341 case TT_PLATFORM_APPLE_UNICODE:
1342 switch (GET_BE_WORD(name->encoding_id))
1343 {
1344 case TT_APPLE_ID_DEFAULT:
1345 case TT_APPLE_ID_ISO_10646:
1346 case TT_APPLE_ID_UNICODE_2_0:
1347 name_lang = GET_BE_WORD(name->language_id);
1348 if (name_lang >= ARRAY_SIZE(mac_langid_table)) return 0;
1349 name_lang = mac_langid_table[name_lang];
1350 break;
1351 default:
1352 return 0;
1353 }
1354 break;
1355 default:
1356 return 0;
1357 }
1358 if (name_lang == lang) return 3;
1359 if (PRIMARYLANGID( name_lang ) == PRIMARYLANGID( lang )) return 2;
1360 if (name_lang == MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT )) return 1;
1361 return 0;
1362 }
1363
1364 static WCHAR *copy_name_table_string( const tt_name_record *name, const BYTE *data )
1365 {
1366 WORD name_len = GET_BE_WORD(name->length);
1367 WORD codepage;
1368 WCHAR *ret;
1369 int len;
1370
1371 switch (GET_BE_WORD(name->platform_id))
1372 {
1373 case TT_PLATFORM_APPLE_UNICODE:
1374 case TT_PLATFORM_MICROSOFT:
1375 ret = heap_alloc((name_len / 2 + 1) * sizeof(WCHAR));
1376 for (len = 0; len < name_len / 2; len++)
1377 ret[len] = (data[len * 2] << 8) | data[len * 2 + 1];
1378 ret[len] = 0;
1379 return ret;
1380 case TT_PLATFORM_MACINTOSH:
1381 codepage = get_mac_code_page( name );
1382 len = MultiByteToWideChar( codepage, 0, (char *)data, name_len, NULL, 0 ) + 1;
1383 if (!len)
1384 return NULL;
1385 ret = heap_alloc(len * sizeof(WCHAR));
1386 len = MultiByteToWideChar( codepage, 0, (char *)data, name_len, ret, len - 1 );
1387 ret[len] = 0;
1388 return ret;
1389 }
1390 return NULL;
1391 }
1392
1393 static WCHAR *load_ttf_name_id( const BYTE *mem, DWORD_PTR size, DWORD id )
1394 {
1395 LANGID lang = GetSystemDefaultLangID();
1396 const tt_header *header;
1397 const tt_name_table *name_table;
1398 const tt_name_record *name_record;
1399 DWORD pos, ofs, count;
1400 int i, res, best_lang = 0, best_index = -1;
1401
1402 if (sizeof(tt_header) > size)
1403 return NULL;
1404 header = (const tt_header*)mem;
1405 count = GET_BE_WORD(header->tables_no);
1406
1407 if (GET_BE_DWORD(header->version) != TT_HEADER_VERSION_1 &&
1408 GET_BE_DWORD(header->version) != TT_HEADER_VERSION_CFF)
1409 return NULL;
1410
1411 pos = sizeof(*header);
1412 for (i = 0; i < count; i++)
1413 {
1414 const tt_table_directory *table_directory = (const tt_table_directory*)&mem[pos];
1415 pos += sizeof(*table_directory);
1416 if (memcmp(table_directory->tag, "name", 4) == 0)
1417 {
1418 ofs = GET_BE_DWORD(table_directory->offset);
1419 break;
1420 }
1421 }
1422 if (i >= count)
1423 return NULL;
1424
1425 if (ofs >= size)
1426 return NULL;
1427 pos = ofs + sizeof(*name_table);
1428 if (pos > size)
1429 return NULL;
1430 name_table = (const tt_name_table*)&mem[ofs];
1431 count = GET_BE_WORD(name_table->count);
1432 if (GET_BE_WORD(name_table->string_offset) >= size - ofs) return NULL;
1433 ofs += GET_BE_WORD(name_table->string_offset);
1434 for (i=0; i<count; i++)
1435 {
1436 name_record = (const tt_name_record*)&mem[pos];
1437 pos += sizeof(*name_record);
1438 if (pos > size)
1439 return NULL;
1440
1441 if (GET_BE_WORD(name_record->name_id) != id) continue;
1442 if (GET_BE_WORD(name_record->offset) >= size - ofs) return NULL;
1443 if (GET_BE_WORD(name_record->length) > size - ofs - GET_BE_WORD(name_record->offset)) return NULL;
1444
1445 res = match_name_table_language( name_record, lang );
1446 if (res > best_lang)
1447 {
1448 best_lang = res;
1449 best_index = i;
1450 }
1451 }
1452
1453 if (best_lang)
1454 {
1455 WCHAR *ret;
1456 name_record = (const tt_name_record*)(name_table + 1) + best_index;
1457 ret = copy_name_table_string( name_record, mem+ofs+GET_BE_WORD(name_record->offset) );
1458 TRACE( "name %u found platform %u lang %04x %s\n", GET_BE_WORD(name_record->name_id),
1459 GET_BE_WORD(name_record->platform_id), GET_BE_WORD(name_record->language_id), debugstr_w( ret ));
1460 return ret;
1461 }
1462 return NULL;
1463 }
1464
1465 struct add_font_param
1466 {
1467 GpFontCollection *collection;
1468 BOOL is_system;
1469 GpStatus stat;
1470 HDC hdc;
1471 };
1472
1473 static INT CALLBACK add_font_proc(const LOGFONTW *lfw, const TEXTMETRICW *ntm, DWORD type, LPARAM lParam);
1474
1475 /*****************************************************************************
1476 * GdipPrivateAddMemoryFont [GDIPLUS.@]
1477 */
1478 GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection* fontCollection,
1479 GDIPCONST void* memory, INT length)
1480 {
1481 WCHAR *name;
1482 DWORD count = 0;
1483 HANDLE font;
1484 GpStatus ret = Ok;
1485 TRACE("%p, %p, %d\n", fontCollection, memory, length);
1486
1487 if (!fontCollection || !memory || !length)
1488 return InvalidParameter;
1489
1490 name = load_ttf_name_id(memory, length, NAME_ID_FULL_FONT_NAME);
1491 if (!name)
1492 return OutOfMemory;
1493
1494 font = AddFontMemResourceEx((void*)memory, length, NULL, &count);
1495 TRACE("%s: %p/%lu\n", debugstr_w(name), font, count);
1496 if (!font || !count)
1497 ret = InvalidParameter;
1498 else
1499 {
1500 struct add_font_param param;
1501 LOGFONTW lfw;
1502
1503 param.hdc = CreateCompatibleDC(0);
1504
1505 /* Truncate name if necessary, GDI32 can't deal with long names */
1506 if(lstrlenW(name) > LF_FACESIZE - 1)
1507 name[LF_FACESIZE - 1] = 0;
1508
1509 lfw.lfCharSet = DEFAULT_CHARSET;
1510 lstrcpyW(lfw.lfFaceName, name);
1511 lfw.lfPitchAndFamily = 0;
1512
1513 param.collection = fontCollection;
1514 param.is_system = FALSE;
1515 if (!EnumFontFamiliesExW(param.hdc, &lfw, add_font_proc, (LPARAM)&param, 0))
1516 ret = param.stat;
1517
1518 DeleteDC(param.hdc);
1519 }
1520 heap_free(name);
1521 return ret;
1522 }
1523
1524 /*****************************************************************************
1525 * GdipGetFontCollectionFamilyCount [GDIPLUS.@]
1526 */
1527 GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(
1528 GpFontCollection* fontCollection, INT* numFound)
1529 {
1530 TRACE("%p, %p\n", fontCollection, numFound);
1531
1532 if (!(fontCollection && numFound))
1533 return InvalidParameter;
1534
1535 *numFound = fontCollection->count;
1536 return Ok;
1537 }
1538
1539 /*****************************************************************************
1540 * GdipGetFontCollectionFamilyList [GDIPLUS.@]
1541 */
1542 GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(
1543 GpFontCollection* fontCollection, INT numSought,
1544 GpFontFamily* gpfamilies[], INT* numFound)
1545 {
1546 INT i;
1547
1548 TRACE("%p, %d, %p, %p\n", fontCollection, numSought, gpfamilies, numFound);
1549
1550 if (!(fontCollection && gpfamilies && numFound))
1551 return InvalidParameter;
1552
1553 memset(gpfamilies, 0, sizeof(*gpfamilies) * numSought);
1554
1555 for (i = 0; i < numSought && i < fontCollection->count; i++)
1556 {
1557 /* caller is responsible for cloning these if it keeps references */
1558 gpfamilies[i] = fontCollection->FontFamilies[i];
1559 }
1560
1561 *numFound = i;
1562
1563 return Ok;
1564 }
1565
1566 void free_installed_fonts(void)
1567 {
1568 INT i;
1569
1570 for (i = 0; i < installedFontCollection.count; i++)
1571 heap_free(installedFontCollection.FontFamilies[i]);
1572 heap_free(installedFontCollection.FontFamilies);
1573
1574 installedFontCollection.FontFamilies = NULL;
1575 installedFontCollection.allocated = 0;
1576 }
1577
1578 static INT CALLBACK add_font_proc(const LOGFONTW *lfw, const TEXTMETRICW *ntm,
1579 DWORD type, LPARAM lParam)
1580 {
1581 struct add_font_param *param = (struct add_font_param *)lParam;
1582 GpFontCollection *fonts = param->collection;
1583 GpFontFamily *family;
1584 HFONT hfont, old_hfont;
1585 struct font_metrics fm;
1586 int i;
1587
1588 param->stat = Ok;
1589
1590 if (type == RASTER_FONTTYPE)
1591 return 1;
1592
1593 /* skip rotated fonts */
1594 if (lfw->lfFaceName[0] == '@')
1595 return 1;
1596
1597 if (fonts->count && wcsicmp(lfw->lfFaceName, fonts->FontFamilies[fonts->count-1]->FamilyName) == 0)
1598 return 1;
1599
1600 if (fonts->allocated == fonts->count)
1601 {
1602 INT new_alloc_count = fonts->allocated+50;
1603 GpFontFamily** new_family_list = heap_alloc(new_alloc_count*sizeof(void*));
1604
1605 if (!new_family_list)
1606 {
1607 param->stat = OutOfMemory;
1608 return 0;
1609 }
1610
1611 memcpy(new_family_list, fonts->FontFamilies, fonts->count*sizeof(void*));
1612 heap_free(fonts->FontFamilies);
1613 fonts->FontFamilies = new_family_list;
1614 fonts->allocated = new_alloc_count;
1615 }
1616
1617 family = heap_alloc(sizeof(*family));
1618 if (!family)
1619 {
1620 if (param->is_system)
1621 return 1;
1622
1623 param->stat = OutOfMemory;
1624 return 0;
1625 }
1626
1627 /* skip duplicates */
1628 for (i=0; i<fonts->count; i++)
1629 {
1630 if (wcsicmp(lfw->lfFaceName, fonts->FontFamilies[i]->FamilyName) == 0)
1631 {
1632 heap_free(family);
1633 return 1;
1634 }
1635 }
1636
1637 hfont = CreateFontIndirectW(lfw);
1638 old_hfont = SelectObject(param->hdc, hfont);
1639
1640 if (!get_font_metrics(param->hdc, &fm))
1641 {
1642 SelectObject(param->hdc, old_hfont);
1643 DeleteObject(hfont);
1644
1645 heap_free(family);
1646 param->stat = OutOfMemory;
1647 return 0;
1648 }
1649
1650 SelectObject(param->hdc, old_hfont);
1651 DeleteObject(hfont);
1652
1653 family->em_height = fm.em_height;
1654 family->ascent = fm.ascent;
1655 family->descent = fm.descent;
1656 family->line_spacing = fm.line_spacing;
1657 family->dpi = fm.dpi;
1658 family->installed = param->is_system;
1659 family->ref = 1;
1660
1661 lstrcpyW(family->FamilyName, lfw->lfFaceName);
1662
1663 fonts->FontFamilies[fonts->count++] = family;
1664
1665 return 1;
1666 }
1667
1668 GpStatus WINGDIPAPI GdipNewInstalledFontCollection(
1669 GpFontCollection** fontCollection)
1670 {
1671 TRACE("(%p)\n",fontCollection);
1672
1673 if (!fontCollection)
1674 return InvalidParameter;
1675
1676 EnterCriticalSection( &font_cs );
1677 if (installedFontCollection.count == 0)
1678 {
1679 struct add_font_param param;
1680 LOGFONTW lfw;
1681
1682 param.hdc = CreateCompatibleDC(0);
1683
1684 lfw.lfCharSet = DEFAULT_CHARSET;
1685 lfw.lfFaceName[0] = 0;
1686 lfw.lfPitchAndFamily = 0;
1687
1688 param.collection = &installedFontCollection;
1689 param.is_system = TRUE;
1690 if (!EnumFontFamiliesExW(param.hdc, &lfw, add_font_proc, (LPARAM)&param, 0))
1691 {
1692 free_installed_fonts();
1693 DeleteDC(param.hdc);
1694 LeaveCriticalSection( &font_cs );
1695 return param.stat;
1696 }
1697
1698 DeleteDC(param.hdc);
1699 }
1700 LeaveCriticalSection( &font_cs );
1701
1702 *fontCollection = &installedFontCollection;
1703
1704 return Ok;
1705 }
Windows API implementation