[WIN32K:NTGDI] Fix more uses of RtlCreateUnicodeString. CORE-14271
[reactos.git] / win32ss / gdi / ntgdi / freetype.c
1 /*
2 * PROJECT: ReactOS win32 kernel mode subsystem
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: win32ss/gdi/ntgdi/freetype.c
5 * PURPOSE: FreeType font engine interface
6 * PROGRAMMERS: Copyright 2001 Huw D M Davies for CodeWeavers.
7 * Copyright 2006 Dmitry Timoshkov for CodeWeavers.
8 * Copyright 2016-2017 Katayama Hirofumi MZ.
9 */
10
11 /** Includes ******************************************************************/
12
13 #include <win32k.h>
14
15 #include FT_GLYPH_H
16 #include FT_TYPE1_TABLES_H
17 #include FT_TRUETYPE_TABLES_H
18 #include FT_TRUETYPE_TAGS_H
19 #include FT_TRIGONOMETRY_H
20 #include FT_BITMAP_H
21 #include FT_OUTLINE_H
22 #include FT_WINFONTS_H
23 #include FT_SFNT_NAMES_H
24 #include FT_SYNTHESIS_H
25 #include FT_TRUETYPE_IDS_H
26
27 #ifndef FT_INTERNAL_INTERNAL_H
28 #define FT_INTERNAL_INTERNAL_H <freetype/internal/internal.h>
29 #include FT_INTERNAL_INTERNAL_H
30 #endif
31 #include FT_INTERNAL_TRUETYPE_TYPES_H
32
33 #include <gdi/eng/floatobj.h>
34 #include "font.h"
35
36 #define NDEBUG
37 #include <debug.h>
38
39 /* TPMF_FIXED_PITCH is confusing; brain-dead api */
40 #ifndef _TMPF_VARIABLE_PITCH
41 #define _TMPF_VARIABLE_PITCH TMPF_FIXED_PITCH
42 #endif
43
44 extern const MATRIX gmxWorldToDeviceDefault;
45 extern const MATRIX gmxWorldToPageDefault;
46
47 /* HACK!! Fix XFORMOBJ then use 1:16 / 16:1 */
48 #define gmxWorldToDeviceDefault gmxWorldToPageDefault
49
50 FT_Library library;
51
52 /* special font names */
53 static const UNICODE_STRING MarlettW = RTL_CONSTANT_STRING(L"Marlett");
54
55 /* registry */
56 static UNICODE_STRING FontRegPath =
57 RTL_CONSTANT_STRING(L"\\REGISTRY\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts");
58
59
60 /* The FreeType library is not thread safe, so we have
61 to serialize access to it */
62 static PFAST_MUTEX FreeTypeLock;
63
64 static LIST_ENTRY FontListHead;
65 static PFAST_MUTEX FontListLock;
66 static BOOL RenderingEnabled = TRUE;
67
68 #define IntLockGlobalFonts \
69 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(FontListLock)
70
71 #define IntUnLockGlobalFonts \
72 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(FontListLock)
73
74 #define ASSERT_GLOBALFONTS_LOCK_HELD() \
75 ASSERT(FontListLock->Owner == KeGetCurrentThread())
76
77 #define IntLockFreeType \
78 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(FreeTypeLock)
79
80 #define IntUnLockFreeType \
81 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(FreeTypeLock)
82
83 #define ASSERT_FREETYPE_LOCK_HELD() \
84 ASSERT(FreeTypeLock->Owner == KeGetCurrentThread())
85
86 #define ASSERT_FREETYPE_LOCK_NOT_HELD() \
87 ASSERT(FreeTypeLock->Owner != KeGetCurrentThread())
88
89 #define MAX_FONT_CACHE 256
90
91 static LIST_ENTRY FontCacheListHead;
92 static UINT FontCacheNumEntries;
93
94 static PWCHAR ElfScripts[32] = /* These are in the order of the fsCsb[0] bits */
95 {
96 L"Western", /* 00 */
97 L"Central_European",
98 L"Cyrillic",
99 L"Greek",
100 L"Turkish",
101 L"Hebrew",
102 L"Arabic",
103 L"Baltic",
104 L"Vietnamese", /* 08 */
105 NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 15 */
106 L"Thai",
107 L"Japanese",
108 L"CHINESE_GB2312",
109 L"Hangul",
110 L"CHINESE_BIG5",
111 L"Hangul(Johab)",
112 NULL, NULL, /* 23 */
113 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
114 L"Symbol" /* 31 */
115 };
116
117 /*
118 * For TranslateCharsetInfo
119 */
120 #define CP_SYMBOL 42
121 #define MAXTCIINDEX 32
122 static const CHARSETINFO FontTci[MAXTCIINDEX] =
123 {
124 /* ANSI */
125 { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} },
126 { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} },
127 { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} },
128 { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} },
129 { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} },
130 { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} },
131 { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} },
132 { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} },
133 { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} },
134 /* reserved by ANSI */
135 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
136 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
137 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
138 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
139 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
140 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
141 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
142 /* ANSI and OEM */
143 { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} },
144 { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} },
145 { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} },
146 { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} },
147 { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} },
148 { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} },
149 /* Reserved for alternate ANSI and OEM */
150 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
151 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
152 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
153 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
154 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
155 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
156 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
157 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
158 /* Reserved for system */
159 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
160 { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} }
161 };
162
163 /* list head */
164 static RTL_STATIC_LIST_HEAD(FontSubstListHead);
165
166 static void
167 SharedMem_AddRef(PSHARED_MEM Ptr)
168 {
169 ASSERT_FREETYPE_LOCK_HELD();
170
171 ++Ptr->RefCount;
172 }
173
174 static void
175 SharedFaceCache_Init(PSHARED_FACE_CACHE Cache)
176 {
177 Cache->OutlineRequiredSize = 0;
178 RtlInitUnicodeString(&Cache->FontFamily, NULL);
179 RtlInitUnicodeString(&Cache->FullName, NULL);
180 }
181
182 static PSHARED_FACE
183 SharedFace_Create(FT_Face Face, PSHARED_MEM Memory)
184 {
185 PSHARED_FACE Ptr;
186 Ptr = ExAllocatePoolWithTag(PagedPool, sizeof(SHARED_FACE), TAG_FONT);
187 if (Ptr)
188 {
189 Ptr->Face = Face;
190 Ptr->RefCount = 1;
191 Ptr->Memory = Memory;
192 SharedFaceCache_Init(&Ptr->EnglishUS);
193 SharedFaceCache_Init(&Ptr->UserLanguage);
194
195 SharedMem_AddRef(Memory);
196 DPRINT("Creating SharedFace for %s\n", Face->family_name);
197 }
198 return Ptr;
199 }
200
201 static PSHARED_MEM
202 SharedMem_Create(PBYTE Buffer, ULONG BufferSize, BOOL IsMapping)
203 {
204 PSHARED_MEM Ptr;
205 Ptr = ExAllocatePoolWithTag(PagedPool, sizeof(SHARED_MEM), TAG_FONT);
206 if (Ptr)
207 {
208 Ptr->Buffer = Buffer;
209 Ptr->BufferSize = BufferSize;
210 Ptr->RefCount = 1;
211 Ptr->IsMapping = IsMapping;
212 DPRINT("Creating SharedMem for %p (%i, %p)\n", Buffer, IsMapping, Ptr);
213 }
214 return Ptr;
215 }
216
217 static void
218 SharedFace_AddRef(PSHARED_FACE Ptr)
219 {
220 ASSERT_FREETYPE_LOCK_HELD();
221
222 ++Ptr->RefCount;
223 }
224
225 static void
226 RemoveCachedEntry(PFONT_CACHE_ENTRY Entry)
227 {
228 ASSERT_FREETYPE_LOCK_HELD();
229
230 FT_Done_Glyph((FT_Glyph)Entry->BitmapGlyph);
231 RemoveEntryList(&Entry->ListEntry);
232 ExFreePoolWithTag(Entry, TAG_FONT);
233 FontCacheNumEntries--;
234 ASSERT(FontCacheNumEntries <= MAX_FONT_CACHE);
235 }
236
237 static void
238 RemoveCacheEntries(FT_Face Face)
239 {
240 PLIST_ENTRY CurrentEntry;
241 PFONT_CACHE_ENTRY FontEntry;
242
243 ASSERT_FREETYPE_LOCK_HELD();
244
245 CurrentEntry = FontCacheListHead.Flink;
246 while (CurrentEntry != &FontCacheListHead)
247 {
248 FontEntry = CONTAINING_RECORD(CurrentEntry, FONT_CACHE_ENTRY, ListEntry);
249 CurrentEntry = CurrentEntry->Flink;
250
251 if (FontEntry->Face == Face)
252 {
253 RemoveCachedEntry(FontEntry);
254 }
255 }
256 }
257
258 static void SharedMem_Release(PSHARED_MEM Ptr)
259 {
260 ASSERT_FREETYPE_LOCK_HELD();
261 ASSERT(Ptr->RefCount > 0);
262
263 if (Ptr->RefCount <= 0)
264 return;
265
266 --Ptr->RefCount;
267 if (Ptr->RefCount == 0)
268 {
269 DPRINT("Releasing SharedMem for %p (%i, %p)\n", Ptr->Buffer, Ptr->IsMapping, Ptr);
270 if (Ptr->IsMapping)
271 MmUnmapViewInSystemSpace(Ptr->Buffer);
272 else
273 ExFreePoolWithTag(Ptr->Buffer, TAG_FONT);
274 ExFreePoolWithTag(Ptr, TAG_FONT);
275 }
276 }
277
278 static void
279 SharedFaceCache_Release(PSHARED_FACE_CACHE Cache)
280 {
281 RtlFreeUnicodeString(&Cache->FontFamily);
282 RtlFreeUnicodeString(&Cache->FullName);
283 }
284
285 static void
286 SharedFace_Release(PSHARED_FACE Ptr)
287 {
288 IntLockFreeType;
289 ASSERT(Ptr->RefCount > 0);
290
291 if (Ptr->RefCount <= 0)
292 return;
293
294 --Ptr->RefCount;
295 if (Ptr->RefCount == 0)
296 {
297 DPRINT("Releasing SharedFace for %s\n", Ptr->Face->family_name);
298 RemoveCacheEntries(Ptr->Face);
299 FT_Done_Face(Ptr->Face);
300 SharedMem_Release(Ptr->Memory);
301 SharedFaceCache_Release(&Ptr->EnglishUS);
302 SharedFaceCache_Release(&Ptr->UserLanguage);
303 ExFreePoolWithTag(Ptr, TAG_FONT);
304 }
305 IntUnLockFreeType;
306 }
307
308
309 /*
310 * IntLoadFontSubstList --- loads the list of font substitutes
311 */
312 BOOL FASTCALL
313 IntLoadFontSubstList(PLIST_ENTRY pHead)
314 {
315 NTSTATUS Status;
316 HANDLE KeyHandle;
317 OBJECT_ATTRIBUTES ObjectAttributes;
318 KEY_FULL_INFORMATION KeyFullInfo;
319 ULONG i, Length;
320 UNICODE_STRING FromW, ToW;
321 BYTE InfoBuffer[128];
322 PKEY_VALUE_FULL_INFORMATION pInfo;
323 BYTE CharSets[FONTSUBST_FROM_AND_TO];
324 LPWSTR pch;
325 PFONTSUBST_ENTRY pEntry;
326 BOOLEAN Success;
327
328 /* the FontSubstitutes registry key */
329 static UNICODE_STRING FontSubstKey =
330 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\"
331 L"Microsoft\\Windows NT\\CurrentVersion\\"
332 L"FontSubstitutes");
333
334 /* open registry key */
335 InitializeObjectAttributes(&ObjectAttributes, &FontSubstKey,
336 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
337 NULL, NULL);
338 Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
339 if (!NT_SUCCESS(Status))
340 {
341 DPRINT("ZwOpenKey failed: 0x%08X\n", Status);
342 return FALSE; /* failure */
343 }
344
345 /* query count of values */
346 Status = ZwQueryKey(KeyHandle, KeyFullInformation,
347 &KeyFullInfo, sizeof(KeyFullInfo), &Length);
348 if (!NT_SUCCESS(Status))
349 {
350 DPRINT("ZwQueryKey failed: 0x%08X\n", Status);
351 ZwClose(KeyHandle);
352 return FALSE; /* failure */
353 }
354
355 /* for each value */
356 for (i = 0; i < KeyFullInfo.Values; ++i)
357 {
358 /* get value name */
359 Status = ZwEnumerateValueKey(KeyHandle, i, KeyValueFullInformation,
360 InfoBuffer, sizeof(InfoBuffer), &Length);
361 if (!NT_SUCCESS(Status))
362 {
363 DPRINT("ZwEnumerateValueKey failed: 0x%08X\n", Status);
364 break; /* failure */
365 }
366
367 /* create FromW string */
368 pInfo = (PKEY_VALUE_FULL_INFORMATION)InfoBuffer;
369 Length = pInfo->NameLength / sizeof(WCHAR);
370 pInfo->Name[Length] = UNICODE_NULL; /* truncate */
371 Success = RtlCreateUnicodeString(&FromW, pInfo->Name);
372 if (!Success)
373 {
374 Status = STATUS_INSUFFICIENT_RESOURCES;
375 DPRINT("RtlCreateUnicodeString failed\n");
376 break; /* failure */
377 }
378
379 /* query value */
380 Status = ZwQueryValueKey(KeyHandle, &FromW, KeyValueFullInformation,
381 InfoBuffer, sizeof(InfoBuffer), &Length);
382 pInfo = (PKEY_VALUE_FULL_INFORMATION)InfoBuffer;
383 if (!NT_SUCCESS(Status) || !pInfo->DataLength)
384 {
385 DPRINT("ZwQueryValueKey failed: 0x%08X\n", Status);
386 RtlFreeUnicodeString(&FromW);
387 break; /* failure */
388 }
389
390 /* create ToW string */
391 pch = (LPWSTR)((PUCHAR)pInfo + pInfo->DataOffset);
392 Length = pInfo->DataLength / sizeof(WCHAR);
393 pch[Length] = UNICODE_NULL; /* truncate */
394 Success = RtlCreateUnicodeString(&ToW, pch);
395 if (!Success)
396 {
397 Status = STATUS_INSUFFICIENT_RESOURCES;
398 DPRINT("RtlCreateUnicodeString failed\n");
399 RtlFreeUnicodeString(&FromW);
400 break; /* failure */
401 }
402
403 /* does charset exist? (from) */
404 CharSets[FONTSUBST_FROM] = DEFAULT_CHARSET;
405 pch = wcsrchr(FromW.Buffer, L',');
406 if (pch)
407 {
408 /* truncate */
409 *pch = UNICODE_NULL;
410 FromW.Length = (pch - FromW.Buffer) * sizeof(WCHAR);
411 /* parse charset number */
412 CharSets[FONTSUBST_FROM] = (BYTE)_wtoi(pch + 1);
413 }
414
415 /* does charset exist? (to) */
416 CharSets[FONTSUBST_TO] = DEFAULT_CHARSET;
417 pch = wcsrchr(ToW.Buffer, L',');
418 if (pch)
419 {
420 /* truncate */
421 *pch = UNICODE_NULL;
422 ToW.Length = (pch - ToW.Buffer) * sizeof(WCHAR);
423 /* parse charset number */
424 CharSets[FONTSUBST_TO] = (BYTE)_wtoi(pch + 1);
425 }
426
427 /* allocate an entry */
428 pEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONTSUBST_ENTRY), TAG_FONT);
429 if (pEntry == NULL)
430 {
431 DPRINT("ExAllocatePoolWithTag failed\n");
432 RtlFreeUnicodeString(&FromW);
433 RtlFreeUnicodeString(&ToW);
434 break; /* failure */
435 }
436
437 /* store to *pEntry */
438 pEntry->FontNames[FONTSUBST_FROM] = FromW;
439 pEntry->FontNames[FONTSUBST_TO] = ToW;
440 pEntry->CharSets[FONTSUBST_FROM] = CharSets[FONTSUBST_FROM];
441 pEntry->CharSets[FONTSUBST_TO] = CharSets[FONTSUBST_TO];
442
443 /* insert pEntry to *pHead */
444 InsertTailList(pHead, &pEntry->ListEntry);
445 }
446
447 /* close now */
448 ZwClose(KeyHandle);
449
450 return NT_SUCCESS(Status);
451 }
452
453 BOOL FASTCALL
454 InitFontSupport(VOID)
455 {
456 ULONG ulError;
457
458 InitializeListHead(&FontListHead);
459 InitializeListHead(&FontCacheListHead);
460 FontCacheNumEntries = 0;
461 /* Fast Mutexes must be allocated from non paged pool */
462 FontListLock = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), TAG_INTERNAL_SYNC);
463 if (FontListLock == NULL)
464 {
465 return FALSE;
466 }
467
468 ExInitializeFastMutex(FontListLock);
469 FreeTypeLock = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), TAG_INTERNAL_SYNC);
470 if (FreeTypeLock == NULL)
471 {
472 return FALSE;
473 }
474 ExInitializeFastMutex(FreeTypeLock);
475
476 ulError = FT_Init_FreeType(&library);
477 if (ulError)
478 {
479 DPRINT1("FT_Init_FreeType failed with error code 0x%x\n", ulError);
480 return FALSE;
481 }
482
483 IntLoadSystemFonts();
484 IntLoadFontSubstList(&FontSubstListHead);
485
486 return TRUE;
487 }
488
489 VOID
490 FtSetCoordinateTransform(
491 FT_Face face,
492 PMATRIX pmx)
493 {
494 FT_Matrix ftmatrix;
495 FLOATOBJ efTemp;
496
497 /* Create a freetype matrix, by converting to 16.16 fixpoint format */
498 efTemp = pmx->efM11;
499 FLOATOBJ_MulLong(&efTemp, 0x00010000);
500 ftmatrix.xx = FLOATOBJ_GetLong(&efTemp);
501
502 efTemp = pmx->efM12;
503 FLOATOBJ_MulLong(&efTemp, 0x00010000);
504 ftmatrix.xy = FLOATOBJ_GetLong(&efTemp);
505
506 efTemp = pmx->efM21;
507 FLOATOBJ_MulLong(&efTemp, 0x00010000);
508 ftmatrix.yx = FLOATOBJ_GetLong(&efTemp);
509
510 efTemp = pmx->efM22;
511 FLOATOBJ_MulLong(&efTemp, 0x00010000);
512 ftmatrix.yy = FLOATOBJ_GetLong(&efTemp);
513
514 /* Set the transformation matrix */
515 FT_Set_Transform(face, &ftmatrix, 0);
516 }
517
518 static BOOL
519 SubstituteFontByList(PLIST_ENTRY pHead,
520 PUNICODE_STRING pOutputName,
521 PUNICODE_STRING pInputName,
522 BYTE RequestedCharSet,
523 BYTE CharSetMap[FONTSUBST_FROM_AND_TO])
524 {
525 PLIST_ENTRY pListEntry;
526 PFONTSUBST_ENTRY pSubstEntry;
527 BYTE CharSets[FONTSUBST_FROM_AND_TO];
528
529 CharSetMap[FONTSUBST_FROM] = DEFAULT_CHARSET;
530 CharSetMap[FONTSUBST_TO] = RequestedCharSet;
531
532 /* for each list entry */
533 for (pListEntry = pHead->Flink;
534 pListEntry != pHead;
535 pListEntry = pListEntry->Flink)
536 {
537 pSubstEntry =
538 (PFONTSUBST_ENTRY)CONTAINING_RECORD(pListEntry, FONT_ENTRY, ListEntry);
539
540 CharSets[FONTSUBST_FROM] = pSubstEntry->CharSets[FONTSUBST_FROM];
541
542 if (CharSets[FONTSUBST_FROM] != DEFAULT_CHARSET &&
543 CharSets[FONTSUBST_FROM] != RequestedCharSet)
544 {
545 continue; /* not matched */
546 }
547
548 /* does charset number exist? (to) */
549 if (pSubstEntry->CharSets[FONTSUBST_TO] != DEFAULT_CHARSET)
550 {
551 CharSets[FONTSUBST_TO] = pSubstEntry->CharSets[FONTSUBST_TO];
552 }
553 else
554 {
555 CharSets[FONTSUBST_TO] = RequestedCharSet;
556 }
557
558 /* does font name match? */
559 if (!RtlEqualUnicodeString(&pSubstEntry->FontNames[FONTSUBST_FROM],
560 pInputName, TRUE))
561 {
562 continue; /* not matched */
563 }
564
565 /* update *pOutputName */
566 *pOutputName = pSubstEntry->FontNames[FONTSUBST_TO];
567
568 if (CharSetMap[FONTSUBST_FROM] == DEFAULT_CHARSET)
569 {
570 /* update CharSetMap */
571 CharSetMap[FONTSUBST_FROM] = CharSets[FONTSUBST_FROM];
572 CharSetMap[FONTSUBST_TO] = CharSets[FONTSUBST_TO];
573 }
574 return TRUE; /* success */
575 }
576
577 return FALSE;
578 }
579
580 static BOOL
581 SubstituteFontRecurse(LOGFONTW* pLogFont)
582 {
583 UINT RecurseCount = 5;
584 UNICODE_STRING OutputNameW = { 0 };
585 BYTE CharSetMap[FONTSUBST_FROM_AND_TO];
586 BOOL Found;
587 UNICODE_STRING InputNameW;
588
589 if (pLogFont->lfFaceName[0] == UNICODE_NULL)
590 return FALSE;
591
592 RtlInitUnicodeString(&InputNameW, pLogFont->lfFaceName);
593
594 while (RecurseCount-- > 0)
595 {
596 Found = SubstituteFontByList(&FontSubstListHead,
597 &OutputNameW, &InputNameW,
598 pLogFont->lfCharSet, CharSetMap);
599 if (!Found)
600 break;
601
602 RtlStringCchCopyW(pLogFont->lfFaceName, LF_FACESIZE, OutputNameW.Buffer);
603
604 if (CharSetMap[FONTSUBST_FROM] == DEFAULT_CHARSET ||
605 CharSetMap[FONTSUBST_FROM] == pLogFont->lfCharSet)
606 {
607 pLogFont->lfCharSet = CharSetMap[FONTSUBST_TO];
608 }
609 }
610
611 return TRUE; /* success */
612 }
613
614 /*
615 * IntLoadSystemFonts
616 *
617 * Search the system font directory and adds each font found.
618 */
619 VOID FASTCALL
620 IntLoadSystemFonts(VOID)
621 {
622 OBJECT_ATTRIBUTES ObjectAttributes;
623 UNICODE_STRING Directory, FileName, TempString;
624 IO_STATUS_BLOCK Iosb;
625 HANDLE hDirectory;
626 BYTE *DirInfoBuffer;
627 PFILE_DIRECTORY_INFORMATION DirInfo;
628 BOOLEAN bRestartScan = TRUE;
629 NTSTATUS Status;
630 INT i;
631 static UNICODE_STRING SearchPatterns[] =
632 {
633 RTL_CONSTANT_STRING(L"*.ttf"),
634 RTL_CONSTANT_STRING(L"*.ttc"),
635 RTL_CONSTANT_STRING(L"*.otf"),
636 RTL_CONSTANT_STRING(L"*.otc"),
637 RTL_CONSTANT_STRING(L"*.fon"),
638 RTL_CONSTANT_STRING(L"*.fnt")
639 };
640
641 RtlInitUnicodeString(&Directory, L"\\SystemRoot\\Fonts\\");
642
643 InitializeObjectAttributes(
644 &ObjectAttributes,
645 &Directory,
646 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
647 NULL,
648 NULL);
649
650 Status = ZwOpenFile(
651 &hDirectory,
652 SYNCHRONIZE | FILE_LIST_DIRECTORY,
653 &ObjectAttributes,
654 &Iosb,
655 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
656 FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE);
657
658 if (NT_SUCCESS(Status))
659 {
660 for (i = 0; i < _countof(SearchPatterns); ++i)
661 {
662 DirInfoBuffer = ExAllocatePoolWithTag(PagedPool, 0x4000, TAG_FONT);
663 if (DirInfoBuffer == NULL)
664 {
665 ZwClose(hDirectory);
666 return;
667 }
668
669 FileName.Buffer = ExAllocatePoolWithTag(PagedPool, MAX_PATH * sizeof(WCHAR), TAG_FONT);
670 if (FileName.Buffer == NULL)
671 {
672 ExFreePoolWithTag(DirInfoBuffer, TAG_FONT);
673 ZwClose(hDirectory);
674 return;
675 }
676 FileName.Length = 0;
677 FileName.MaximumLength = MAX_PATH * sizeof(WCHAR);
678
679 while (1)
680 {
681 Status = ZwQueryDirectoryFile(
682 hDirectory,
683 NULL,
684 NULL,
685 NULL,
686 &Iosb,
687 DirInfoBuffer,
688 0x4000,
689 FileDirectoryInformation,
690 FALSE,
691 &SearchPatterns[i],
692 bRestartScan);
693
694 if (!NT_SUCCESS(Status) || Status == STATUS_NO_MORE_FILES)
695 {
696 break;
697 }
698
699 DirInfo = (PFILE_DIRECTORY_INFORMATION)DirInfoBuffer;
700 while (1)
701 {
702 TempString.Buffer = DirInfo->FileName;
703 TempString.Length =
704 TempString.MaximumLength = DirInfo->FileNameLength;
705 RtlCopyUnicodeString(&FileName, &Directory);
706 RtlAppendUnicodeStringToString(&FileName, &TempString);
707 IntGdiAddFontResource(&FileName, 0);
708 if (DirInfo->NextEntryOffset == 0)
709 break;
710 DirInfo = (PFILE_DIRECTORY_INFORMATION)((ULONG_PTR)DirInfo + DirInfo->NextEntryOffset);
711 }
712
713 bRestartScan = FALSE;
714 }
715
716 ExFreePoolWithTag(FileName.Buffer, TAG_FONT);
717 ExFreePoolWithTag(DirInfoBuffer, TAG_FONT);
718 }
719 ZwClose(hDirectory);
720 }
721 }
722
723 static BYTE
724 ItalicFromStyle(const char *style_name)
725 {
726 if (style_name == NULL || style_name[0] == 0)
727 return FALSE;
728 if (strstr(style_name, "Italic") != NULL)
729 return TRUE;
730 if (strstr(style_name, "Oblique") != NULL)
731 return TRUE;
732 return FALSE;
733 }
734
735 static LONG
736 WeightFromStyle(const char *style_name)
737 {
738 if (style_name == NULL || style_name[0] == 0)
739 return FW_NORMAL;
740 if (strstr(style_name, "Regular") != NULL)
741 return FW_REGULAR;
742 if (strstr(style_name, "Normal") != NULL)
743 return FW_NORMAL;
744 if (strstr(style_name, "SemiBold") != NULL)
745 return FW_SEMIBOLD;
746 if (strstr(style_name, "UltraBold") != NULL)
747 return FW_ULTRABOLD;
748 if (strstr(style_name, "DemiBold") != NULL)
749 return FW_DEMIBOLD;
750 if (strstr(style_name, "ExtraBold") != NULL)
751 return FW_EXTRABOLD;
752 if (strstr(style_name, "Bold") != NULL)
753 return FW_BOLD;
754 if (strstr(style_name, "UltraLight") != NULL)
755 return FW_ULTRALIGHT;
756 if (strstr(style_name, "ExtraLight") != NULL)
757 return FW_EXTRALIGHT;
758 if (strstr(style_name, "Light") != NULL)
759 return FW_LIGHT;
760 if (strstr(style_name, "Hairline") != NULL)
761 return 50;
762 if (strstr(style_name, "Book") != NULL)
763 return 350;
764 if (strstr(style_name, "ExtraBlack") != NULL)
765 return 950;
766 if (strstr(style_name, "UltraBlack") != NULL)
767 return 1000;
768 if (strstr(style_name, "Black") != NULL)
769 return FW_BLACK;
770 if (strstr(style_name, "Medium") != NULL)
771 return FW_MEDIUM;
772 if (strstr(style_name, "Thin") != NULL)
773 return FW_THIN;
774 if (strstr(style_name, "Heavy") != NULL)
775 return FW_HEAVY;
776 return FW_NORMAL;
777 }
778
779 static INT FASTCALL
780 IntGdiLoadFontsFromMemory(PGDI_LOAD_FONT pLoadFont,
781 PSHARED_FACE SharedFace, FT_Long FontIndex, INT CharSetIndex)
782 {
783 FT_Error Error;
784 PFONT_ENTRY Entry;
785 FONT_ENTRY_MEM* PrivateEntry = NULL;
786 FONTGDI * FontGDI;
787 NTSTATUS Status;
788 FT_Face Face;
789 ANSI_STRING AnsiFaceName;
790 FT_WinFNT_HeaderRec WinFNT;
791 INT FaceCount = 0, CharSetCount = 0;
792 PUNICODE_STRING pFileName = pLoadFont->pFileName;
793 DWORD Characteristics = pLoadFont->Characteristics;
794 PUNICODE_STRING pValueName = &pLoadFont->RegValueName;
795 TT_OS2 * pOS2;
796 INT BitIndex;
797 FT_UShort os2_version;
798 FT_ULong os2_ulCodePageRange1;
799 FT_UShort os2_usWeightClass;
800
801 if (SharedFace == NULL && CharSetIndex == -1)
802 {
803 /* load a face from memory */
804 IntLockFreeType;
805 Error = FT_New_Memory_Face(
806 library,
807 pLoadFont->Memory->Buffer,
808 pLoadFont->Memory->BufferSize,
809 ((FontIndex != -1) ? FontIndex : 0),
810 &Face);
811
812 if (!Error)
813 SharedFace = SharedFace_Create(Face, pLoadFont->Memory);
814
815 IntUnLockFreeType;
816
817 if (!Error && FT_IS_SFNT(Face))
818 pLoadFont->IsTrueType = TRUE;
819
820 if (Error || SharedFace == NULL)
821 {
822 if (SharedFace)
823 SharedFace_Release(SharedFace);
824
825 if (Error == FT_Err_Unknown_File_Format)
826 DPRINT1("Unknown font file format\n");
827 else
828 DPRINT1("Error reading font (error code: %d)\n", Error);
829 return 0; /* failure */
830 }
831 }
832 else
833 {
834 Face = SharedFace->Face;
835 IntLockFreeType;
836 SharedFace_AddRef(SharedFace);
837 IntUnLockFreeType;
838 }
839
840 /* allocate a FONT_ENTRY */
841 Entry = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_ENTRY), TAG_FONT);
842 if (!Entry)
843 {
844 SharedFace_Release(SharedFace);
845 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
846 return 0; /* failure */
847 }
848
849 /* allocate a FONTGDI */
850 FontGDI = EngAllocMem(FL_ZERO_MEMORY, sizeof(FONTGDI), GDITAG_RFONT);
851 if (!FontGDI)
852 {
853 SharedFace_Release(SharedFace);
854 ExFreePoolWithTag(Entry, TAG_FONT);
855 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
856 return 0; /* failure */
857 }
858
859 /* set file name */
860 if (pFileName)
861 {
862 FontGDI->Filename = ExAllocatePoolWithTag(PagedPool,
863 pFileName->Length + sizeof(UNICODE_NULL),
864 GDITAG_PFF);
865 if (FontGDI->Filename == NULL)
866 {
867 EngFreeMem(FontGDI);
868 SharedFace_Release(SharedFace);
869 ExFreePoolWithTag(Entry, TAG_FONT);
870 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
871 return 0; /* failure */
872 }
873 RtlCopyMemory(FontGDI->Filename, pFileName->Buffer, pFileName->Length);
874 FontGDI->Filename[pFileName->Length / sizeof(WCHAR)] = UNICODE_NULL;
875 }
876 else
877 {
878 FontGDI->Filename = NULL;
879
880 PrivateEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_ENTRY_MEM), TAG_FONT);
881 if (!PrivateEntry)
882 {
883 if (FontGDI->Filename)
884 ExFreePoolWithTag(FontGDI->Filename, GDITAG_PFF);
885 EngFreeMem(FontGDI);
886 SharedFace_Release(SharedFace);
887 ExFreePoolWithTag(Entry, TAG_FONT);
888 return 0;
889 }
890
891 PrivateEntry->Entry = Entry;
892 if (pLoadFont->PrivateEntry)
893 {
894 InsertTailList(&pLoadFont->PrivateEntry->ListEntry, &PrivateEntry->ListEntry);
895 }
896 else
897 {
898 InitializeListHead(&PrivateEntry->ListEntry);
899 pLoadFont->PrivateEntry = PrivateEntry;
900 }
901 }
902
903 /* set face */
904 FontGDI->SharedFace = SharedFace;
905 FontGDI->CharSet = ANSI_CHARSET;
906 FontGDI->OriginalItalic = ItalicFromStyle(Face->style_name);
907 FontGDI->RequestItalic = FALSE;
908 FontGDI->OriginalWeight = WeightFromStyle(Face->style_name);
909 FontGDI->RequestWeight = FW_NORMAL;
910
911 RtlInitAnsiString(&AnsiFaceName, Face->family_name);
912 Status = RtlAnsiStringToUnicodeString(&Entry->FaceName, &AnsiFaceName, TRUE);
913 if (!NT_SUCCESS(Status))
914 {
915 if (PrivateEntry)
916 {
917 if (pLoadFont->PrivateEntry == PrivateEntry)
918 {
919 pLoadFont->PrivateEntry = NULL;
920 }
921 else
922 {
923 RemoveEntryList(&PrivateEntry->ListEntry);
924 }
925 ExFreePoolWithTag(PrivateEntry, TAG_FONT);
926 }
927 if (FontGDI->Filename)
928 ExFreePoolWithTag(FontGDI->Filename, GDITAG_PFF);
929 EngFreeMem(FontGDI);
930 SharedFace_Release(SharedFace);
931 ExFreePoolWithTag(Entry, TAG_FONT);
932 return 0;
933 }
934
935 os2_version = 0;
936 IntLockFreeType;
937 pOS2 = (TT_OS2 *)FT_Get_Sfnt_Table(Face, FT_SFNT_OS2);
938 if (pOS2)
939 {
940 os2_version = pOS2->version;
941 os2_ulCodePageRange1 = pOS2->ulCodePageRange1;
942 os2_usWeightClass = pOS2->usWeightClass;
943 }
944 IntUnLockFreeType;
945
946 if (pOS2 && os2_version >= 1)
947 {
948 /* get charset and weight from OS/2 header */
949
950 /* Make sure we do not use this pointer anymore */
951 pOS2 = NULL;
952
953 for (BitIndex = 0; BitIndex < MAXTCIINDEX; ++BitIndex)
954 {
955 if (os2_ulCodePageRange1 & (1 << BitIndex))
956 {
957 if (FontTci[BitIndex].ciCharset == DEFAULT_CHARSET)
958 continue;
959
960 if ((CharSetIndex == -1 && CharSetCount == 0) ||
961 CharSetIndex == CharSetCount)
962 {
963 FontGDI->CharSet = FontTci[BitIndex].ciCharset;
964 }
965
966 ++CharSetCount;
967 }
968 }
969
970 /* set actual weight */
971 FontGDI->OriginalWeight = os2_usWeightClass;
972 }
973 else
974 {
975 /* get charset from WinFNT header */
976 IntLockFreeType;
977 Error = FT_Get_WinFNT_Header(Face, &WinFNT);
978 if (!Error)
979 {
980 FontGDI->CharSet = WinFNT.charset;
981 }
982 IntUnLockFreeType;
983 }
984
985 /* FIXME: CharSet is invalid on Marlett */
986 if (RtlEqualUnicodeString(&Entry->FaceName, &MarlettW, TRUE))
987 {
988 FontGDI->CharSet = SYMBOL_CHARSET;
989 }
990
991 ++FaceCount;
992 DPRINT("Font loaded: %s (%s)\n", Face->family_name, Face->style_name);
993 DPRINT("Num glyphs: %d\n", Face->num_glyphs);
994 DPRINT("CharSet: %d\n", FontGDI->CharSet);
995
996 /* Add this font resource to the font table */
997 Entry->Font = FontGDI;
998 Entry->NotEnum = (Characteristics & FR_NOT_ENUM);
999
1000 if (Characteristics & FR_PRIVATE)
1001 {
1002 /* private font */
1003 PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
1004 IntLockProcessPrivateFonts(Win32Process);
1005 InsertTailList(&Win32Process->PrivateFontListHead, &Entry->ListEntry);
1006 IntUnLockProcessPrivateFonts(Win32Process);
1007 }
1008 else
1009 {
1010 /* global font */
1011 IntLockGlobalFonts;
1012 InsertTailList(&FontListHead, &Entry->ListEntry);
1013 IntUnLockGlobalFonts;
1014 }
1015
1016 if (FontIndex == -1)
1017 {
1018 if (FT_IS_SFNT(Face))
1019 {
1020 TT_Face TrueType = (TT_Face)Face;
1021 if (TrueType->ttc_header.count > 1)
1022 {
1023 FT_Long i;
1024 for (i = 1; i < TrueType->ttc_header.count; ++i)
1025 {
1026 FaceCount += IntGdiLoadFontsFromMemory(pLoadFont, NULL, i, -1);
1027 }
1028 }
1029 }
1030 FontIndex = 0;
1031 }
1032
1033 if (CharSetIndex == -1)
1034 {
1035 INT i;
1036
1037 if (pLoadFont->RegValueName.Length == 0)
1038 {
1039 RtlCreateUnicodeString(pValueName, Entry->FaceName.Buffer);
1040 }
1041 else
1042 {
1043 UNICODE_STRING NewString;
1044 USHORT Length = pValueName->Length + 3 * sizeof(WCHAR) + Entry->FaceName.Length;
1045 NewString.Length = 0;
1046 NewString.MaximumLength = Length + sizeof(WCHAR);
1047 NewString.Buffer = ExAllocatePoolWithTag(PagedPool,
1048 NewString.MaximumLength,
1049 TAG_USTR);
1050 NewString.Buffer[0] = UNICODE_NULL;
1051
1052 RtlAppendUnicodeStringToString(&NewString, pValueName);
1053 RtlAppendUnicodeToString(&NewString, L" & ");
1054 RtlAppendUnicodeStringToString(&NewString, &Entry->FaceName);
1055
1056 RtlFreeUnicodeString(pValueName);
1057 *pValueName = NewString;
1058 }
1059
1060 for (i = 1; i < CharSetCount; ++i)
1061 {
1062 /* Do not count charsets towards 'faces' loaded */
1063 IntGdiLoadFontsFromMemory(pLoadFont, SharedFace, FontIndex, i);
1064 }
1065 }
1066
1067 return FaceCount; /* number of loaded faces */
1068 }
1069
1070 /*
1071 * IntGdiAddFontResource
1072 *
1073 * Adds the font resource from the specified file to the system.
1074 */
1075
1076 INT FASTCALL
1077 IntGdiAddFontResource(PUNICODE_STRING FileName, DWORD Characteristics)
1078 {
1079 NTSTATUS Status;
1080 HANDLE FileHandle;
1081 PVOID Buffer = NULL;
1082 IO_STATUS_BLOCK Iosb;
1083 PVOID SectionObject;
1084 ULONG ViewSize = 0;
1085 LARGE_INTEGER SectionSize;
1086 OBJECT_ATTRIBUTES ObjectAttributes;
1087 GDI_LOAD_FONT LoadFont;
1088 INT FontCount;
1089 HANDLE KeyHandle;
1090 static const UNICODE_STRING TrueTypePostfix = RTL_CONSTANT_STRING(L" (TrueType)");
1091
1092 /* Open the font file */
1093 InitializeObjectAttributes(&ObjectAttributes, FileName, 0, NULL, NULL);
1094 Status = ZwOpenFile(
1095 &FileHandle,
1096 FILE_GENERIC_READ | SYNCHRONIZE,
1097 &ObjectAttributes,
1098 &Iosb,
1099 FILE_SHARE_READ,
1100 FILE_SYNCHRONOUS_IO_NONALERT);
1101 if (!NT_SUCCESS(Status))
1102 {
1103 DPRINT("Could not load font file: %wZ\n", FileName);
1104 return 0;
1105 }
1106
1107 SectionSize.QuadPart = 0LL;
1108 Status = MmCreateSection(&SectionObject, SECTION_ALL_ACCESS,
1109 NULL, &SectionSize, PAGE_READONLY,
1110 SEC_COMMIT, FileHandle, NULL);
1111 if (!NT_SUCCESS(Status))
1112 {
1113 DPRINT("Could not map file: %wZ\n", FileName);
1114 ZwClose(FileHandle);
1115 return 0;
1116 }
1117 ZwClose(FileHandle);
1118
1119 Status = MmMapViewInSystemSpace(SectionObject, &Buffer, &ViewSize);
1120 if (!NT_SUCCESS(Status))
1121 {
1122 DPRINT("Could not map file: %wZ\n", FileName);
1123 ObDereferenceObject(SectionObject);
1124 return 0;
1125 }
1126
1127 LoadFont.pFileName = FileName;
1128 LoadFont.Memory = SharedMem_Create(Buffer, ViewSize, TRUE);
1129 LoadFont.Characteristics = Characteristics;
1130 RtlInitUnicodeString(&LoadFont.RegValueName, NULL);
1131 LoadFont.IsTrueType = FALSE;
1132 LoadFont.PrivateEntry = NULL;
1133 FontCount = IntGdiLoadFontsFromMemory(&LoadFont, NULL, -1, -1);
1134
1135 ObDereferenceObject(SectionObject);
1136
1137 /* Release our copy */
1138 IntLockFreeType;
1139 SharedMem_Release(LoadFont.Memory);
1140 IntUnLockFreeType;
1141
1142 if (FontCount > 0)
1143 {
1144 if (LoadFont.IsTrueType)
1145 {
1146 /* append " (TrueType)" */
1147 UNICODE_STRING NewString;
1148 USHORT Length;
1149
1150 Length = LoadFont.RegValueName.Length + TrueTypePostfix.Length;
1151 NewString.Length = 0;
1152 NewString.MaximumLength = Length + sizeof(WCHAR);
1153 NewString.Buffer = ExAllocatePoolWithTag(PagedPool,
1154 NewString.MaximumLength,
1155 TAG_USTR);
1156 NewString.Buffer[0] = UNICODE_NULL;
1157
1158 RtlAppendUnicodeStringToString(&NewString, &LoadFont.RegValueName);
1159 RtlAppendUnicodeStringToString(&NewString, &TrueTypePostfix);
1160 RtlFreeUnicodeString(&LoadFont.RegValueName);
1161 LoadFont.RegValueName = NewString;
1162 }
1163
1164 /* registry */
1165 InitializeObjectAttributes(&ObjectAttributes, &FontRegPath,
1166 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1167 NULL, NULL);
1168 Status = ZwOpenKey(&KeyHandle, KEY_WRITE, &ObjectAttributes);
1169 if (NT_SUCCESS(Status))
1170 {
1171 ULONG DataSize;
1172 LPWSTR pFileName = wcsrchr(FileName->Buffer, L'\\');
1173 if (pFileName)
1174 {
1175 pFileName++;
1176 DataSize = (wcslen(pFileName) + 1) * sizeof(WCHAR);
1177 ZwSetValueKey(KeyHandle, &LoadFont.RegValueName, 0, REG_SZ,
1178 pFileName, DataSize);
1179 }
1180 ZwClose(KeyHandle);
1181 }
1182 }
1183 RtlFreeUnicodeString(&LoadFont.RegValueName);
1184
1185 return FontCount;
1186 }
1187
1188 HANDLE FASTCALL
1189 IntGdiAddFontMemResource(PVOID Buffer, DWORD dwSize, PDWORD pNumAdded)
1190 {
1191 GDI_LOAD_FONT LoadFont;
1192 FONT_ENTRY_COLL_MEM* EntryCollection;
1193 INT FaceCount;
1194 HANDLE Ret = 0;
1195
1196 PVOID BufferCopy = ExAllocatePoolWithTag(PagedPool, dwSize, TAG_FONT);
1197
1198 if (!BufferCopy)
1199 {
1200 *pNumAdded = 0;
1201 return NULL;
1202 }
1203 memcpy(BufferCopy, Buffer, dwSize);
1204
1205 LoadFont.pFileName = NULL;
1206 LoadFont.Memory = SharedMem_Create(BufferCopy, dwSize, FALSE);
1207 LoadFont.Characteristics = FR_PRIVATE | FR_NOT_ENUM;
1208 RtlInitUnicodeString(&LoadFont.RegValueName, NULL);
1209 LoadFont.IsTrueType = FALSE;
1210 LoadFont.PrivateEntry = NULL;
1211 FaceCount = IntGdiLoadFontsFromMemory(&LoadFont, NULL, -1, -1);
1212
1213 RtlFreeUnicodeString(&LoadFont.RegValueName);
1214
1215 /* Release our copy */
1216 IntLockFreeType;
1217 SharedMem_Release(LoadFont.Memory);
1218 IntUnLockFreeType;
1219
1220 if (FaceCount > 0)
1221 {
1222 EntryCollection = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_ENTRY_COLL_MEM), TAG_FONT);
1223 if (EntryCollection)
1224 {
1225 PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
1226 EntryCollection->Entry = LoadFont.PrivateEntry;
1227 IntLockProcessPrivateFonts(Win32Process);
1228 EntryCollection->Handle = ++Win32Process->PrivateMemFontHandleCount;
1229 InsertTailList(&Win32Process->PrivateMemFontListHead, &EntryCollection->ListEntry);
1230 IntUnLockProcessPrivateFonts(Win32Process);
1231 Ret = (HANDLE)EntryCollection->Handle;
1232 }
1233 }
1234 *pNumAdded = FaceCount;
1235
1236 return Ret;
1237 }
1238
1239 // FIXME: Add RemoveFontResource
1240
1241 static VOID FASTCALL
1242 CleanupFontEntry(PFONT_ENTRY FontEntry)
1243 {
1244 PFONTGDI FontGDI = FontEntry->Font;
1245 PSHARED_FACE SharedFace = FontGDI->SharedFace;
1246
1247 if (FontGDI->Filename)
1248 ExFreePoolWithTag(FontGDI->Filename, GDITAG_PFF);
1249
1250 EngFreeMem(FontGDI);
1251 SharedFace_Release(SharedFace);
1252 ExFreePoolWithTag(FontEntry, TAG_FONT);
1253 }
1254
1255 VOID FASTCALL
1256 IntGdiCleanupMemEntry(PFONT_ENTRY_MEM Head)
1257 {
1258 PLIST_ENTRY Entry;
1259 PFONT_ENTRY_MEM FontEntry;
1260
1261 while (!IsListEmpty(&Head->ListEntry))
1262 {
1263 Entry = RemoveHeadList(&Head->ListEntry);
1264 FontEntry = CONTAINING_RECORD(Entry, FONT_ENTRY_MEM, ListEntry);
1265
1266 CleanupFontEntry(FontEntry->Entry);
1267 ExFreePoolWithTag(FontEntry, TAG_FONT);
1268 }
1269
1270 CleanupFontEntry(Head->Entry);
1271 ExFreePoolWithTag(Head, TAG_FONT);
1272 }
1273
1274 static VOID FASTCALL
1275 UnlinkFontMemCollection(PFONT_ENTRY_COLL_MEM Collection)
1276 {
1277 PFONT_ENTRY_MEM FontMemEntry = Collection->Entry;
1278 PLIST_ENTRY ListEntry;
1279 RemoveEntryList(&Collection->ListEntry);
1280
1281 do {
1282 /* Also unlink the FONT_ENTRY stuff from the PrivateFontListHead */
1283 RemoveEntryList(&FontMemEntry->Entry->ListEntry);
1284
1285 ListEntry = FontMemEntry->ListEntry.Flink;
1286 FontMemEntry = CONTAINING_RECORD(ListEntry, FONT_ENTRY_MEM, ListEntry);
1287
1288 } while (FontMemEntry != Collection->Entry);
1289 }
1290
1291 BOOL FASTCALL
1292 IntGdiRemoveFontMemResource(HANDLE hMMFont)
1293 {
1294 PLIST_ENTRY Entry;
1295 PFONT_ENTRY_COLL_MEM CurrentEntry;
1296 PFONT_ENTRY_COLL_MEM EntryCollection = NULL;
1297 PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
1298
1299 IntLockProcessPrivateFonts(Win32Process);
1300 Entry = Win32Process->PrivateMemFontListHead.Flink;
1301 while (Entry != &Win32Process->PrivateMemFontListHead)
1302 {
1303 CurrentEntry = CONTAINING_RECORD(Entry, FONT_ENTRY_COLL_MEM, ListEntry);
1304
1305 if (CurrentEntry->Handle == (UINT)hMMFont)
1306 {
1307 EntryCollection = CurrentEntry;
1308 UnlinkFontMemCollection(CurrentEntry);
1309 break;
1310 }
1311
1312 Entry = Entry->Flink;
1313 }
1314 IntUnLockProcessPrivateFonts(Win32Process);
1315
1316 if (EntryCollection)
1317 {
1318 IntGdiCleanupMemEntry(EntryCollection->Entry);
1319 ExFreePoolWithTag(EntryCollection, TAG_FONT);
1320 return TRUE;
1321 }
1322 return FALSE;
1323 }
1324
1325
1326 VOID FASTCALL
1327 IntGdiCleanupPrivateFontsForProcess(VOID)
1328 {
1329 PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
1330 PLIST_ENTRY Entry;
1331 PFONT_ENTRY_COLL_MEM EntryCollection;
1332
1333 DPRINT("IntGdiCleanupPrivateFontsForProcess()\n");
1334 do {
1335 Entry = NULL;
1336 EntryCollection = NULL;
1337
1338 IntLockProcessPrivateFonts(Win32Process);
1339 if (!IsListEmpty(&Win32Process->PrivateMemFontListHead))
1340 {
1341 Entry = Win32Process->PrivateMemFontListHead.Flink;
1342 EntryCollection = CONTAINING_RECORD(Entry, FONT_ENTRY_COLL_MEM, ListEntry);
1343 UnlinkFontMemCollection(EntryCollection);
1344 }
1345 IntUnLockProcessPrivateFonts(Win32Process);
1346
1347 if (EntryCollection)
1348 {
1349 IntGdiCleanupMemEntry(EntryCollection->Entry);
1350 ExFreePoolWithTag(EntryCollection, TAG_FONT);
1351 }
1352 else
1353 {
1354 /* No Mem fonts anymore, see if we have any other private fonts left */
1355 Entry = NULL;
1356 IntLockProcessPrivateFonts(Win32Process);
1357 if (!IsListEmpty(&Win32Process->PrivateFontListHead))
1358 {
1359 Entry = RemoveHeadList(&Win32Process->PrivateFontListHead);
1360 }
1361 IntUnLockProcessPrivateFonts(Win32Process);
1362
1363 if (Entry)
1364 {
1365 CleanupFontEntry(CONTAINING_RECORD(Entry, FONT_ENTRY, ListEntry));
1366 }
1367 }
1368
1369 } while (Entry);
1370 }
1371
1372 BOOL FASTCALL
1373 IntIsFontRenderingEnabled(VOID)
1374 {
1375 BOOL Ret = RenderingEnabled;
1376 HDC hDC;
1377
1378 hDC = IntGetScreenDC();
1379 if (hDC)
1380 Ret = (NtGdiGetDeviceCaps(hDC, BITSPIXEL) > 8) && RenderingEnabled;
1381
1382 return Ret;
1383 }
1384
1385 VOID FASTCALL
1386 IntEnableFontRendering(BOOL Enable)
1387 {
1388 RenderingEnabled = Enable;
1389 }
1390
1391 FT_Render_Mode FASTCALL
1392 IntGetFontRenderMode(LOGFONTW *logfont)
1393 {
1394 switch (logfont->lfQuality)
1395 {
1396 case ANTIALIASED_QUALITY:
1397 break;
1398 case NONANTIALIASED_QUALITY:
1399 return FT_RENDER_MODE_MONO;
1400 case DRAFT_QUALITY:
1401 return FT_RENDER_MODE_LIGHT;
1402 /* case CLEARTYPE_QUALITY:
1403 return FT_RENDER_MODE_LCD; */
1404 }
1405 return FT_RENDER_MODE_NORMAL;
1406 }
1407
1408
1409 NTSTATUS FASTCALL
1410 TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont)
1411 {
1412 PLFONT plfont;
1413 LOGFONTW *plf;
1414
1415 plfont = LFONT_AllocFontWithHandle();
1416 if (!plfont)
1417 {
1418 return STATUS_NO_MEMORY;
1419 }
1420
1421 ExInitializePushLock(&plfont->lock);
1422 *NewFont = plfont->BaseObject.hHmgr;
1423 plf = &plfont->logfont.elfEnumLogfontEx.elfLogFont;
1424 RtlCopyMemory(plf, lf, sizeof(LOGFONTW));
1425 if (lf->lfEscapement != lf->lfOrientation)
1426 {
1427 /* This should really depend on whether GM_ADVANCED is set */
1428 plf->lfOrientation = plf->lfEscapement;
1429 }
1430 LFONT_UnlockFont(plfont);
1431
1432 return STATUS_SUCCESS;
1433 }
1434
1435 /*************************************************************************
1436 * TranslateCharsetInfo
1437 *
1438 * Fills a CHARSETINFO structure for a character set, code page, or
1439 * font. This allows making the correspondance between different labelings
1440 * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
1441 * of the same encoding.
1442 *
1443 * Only one codepage will be set in Cs->fs. If TCI_SRCFONTSIG is used,
1444 * only one codepage should be set in *Src.
1445 *
1446 * RETURNS
1447 * TRUE on success, FALSE on failure.
1448 *
1449 */
1450 static BOOLEAN APIENTRY
1451 IntTranslateCharsetInfo(PDWORD Src, /* [in]
1452 if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
1453 if flags == TCI_SRCCHARSET: a character set value
1454 if flags == TCI_SRCCODEPAGE: a code page value */
1455 LPCHARSETINFO Cs, /* [out] structure to receive charset information */
1456 DWORD Flags /* [in] determines interpretation of lpSrc */)
1457 {
1458 int Index = 0;
1459
1460 switch (Flags)
1461 {
1462 case TCI_SRCFONTSIG:
1463 while (Index < MAXTCIINDEX && 0 == (*Src >> Index & 0x0001))
1464 {
1465 Index++;
1466 }
1467 break;
1468 case TCI_SRCCODEPAGE:
1469 while (Index < MAXTCIINDEX && *Src != FontTci[Index].ciACP)
1470 {
1471 Index++;
1472 }
1473 break;
1474 case TCI_SRCCHARSET:
1475 while (Index < MAXTCIINDEX && *Src != FontTci[Index].ciCharset)
1476 {
1477 Index++;
1478 }
1479 break;
1480 default:
1481 return FALSE;
1482 }
1483
1484 if (Index >= MAXTCIINDEX || DEFAULT_CHARSET == FontTci[Index].ciCharset)
1485 {
1486 return FALSE;
1487 }
1488
1489 RtlCopyMemory(Cs, &FontTci[Index], sizeof(CHARSETINFO));
1490
1491 return TRUE;
1492 }
1493
1494
1495 static BOOL face_has_symbol_charmap(FT_Face ft_face)
1496 {
1497 int i;
1498
1499 for(i = 0; i < ft_face->num_charmaps; i++)
1500 {
1501 if(ft_face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL)
1502 return TRUE;
1503 }
1504 return FALSE;
1505 }
1506
1507
1508 static void FASTCALL
1509 FillTMEx(TEXTMETRICW *TM, PFONTGDI FontGDI,
1510 TT_OS2 *pOS2, TT_HoriHeader *pHori,
1511 FT_WinFNT_HeaderRec *pFNT, BOOL RealFont)
1512 {
1513 FT_Fixed XScale, YScale;
1514 int Ascent, Descent;
1515 FT_Face Face = FontGDI->SharedFace->Face;
1516
1517 XScale = Face->size->metrics.x_scale;
1518 YScale = Face->size->metrics.y_scale;
1519
1520 if (pFNT)
1521 {
1522 TM->tmHeight = pFNT->pixel_height;
1523 TM->tmAscent = pFNT->ascent;
1524 TM->tmDescent = TM->tmHeight - TM->tmAscent;
1525 TM->tmInternalLeading = pFNT->internal_leading;
1526 TM->tmExternalLeading = pFNT->external_leading;
1527 TM->tmAveCharWidth = pFNT->avg_width;
1528 TM->tmMaxCharWidth = pFNT->max_width;
1529 TM->tmOverhang = 0;
1530 TM->tmDigitizedAspectX = pFNT->horizontal_resolution;
1531 TM->tmDigitizedAspectY = pFNT->vertical_resolution;
1532 TM->tmFirstChar = pFNT->first_char;
1533 TM->tmLastChar = pFNT->last_char;
1534 TM->tmDefaultChar = pFNT->default_char + pFNT->first_char;
1535 TM->tmBreakChar = pFNT->break_char + pFNT->first_char;
1536 TM->tmPitchAndFamily = pFNT->pitch_and_family;
1537 if (RealFont)
1538 {
1539 TM->tmWeight = FontGDI->OriginalWeight;
1540 TM->tmItalic = FontGDI->OriginalItalic;
1541 TM->tmUnderlined = pFNT->underline;
1542 TM->tmStruckOut = pFNT->strike_out;
1543 TM->tmCharSet = pFNT->charset;
1544 }
1545 else
1546 {
1547 TM->tmWeight = FontGDI->RequestWeight;
1548 TM->tmItalic = FontGDI->RequestItalic;
1549 TM->tmUnderlined = FontGDI->RequestUnderline;
1550 TM->tmStruckOut = FontGDI->RequestStrikeOut;
1551 TM->tmCharSet = FontGDI->CharSet;
1552 }
1553 return;
1554 }
1555
1556 if (pOS2->usWinAscent + pOS2->usWinDescent == 0)
1557 {
1558 Ascent = pHori->Ascender;
1559 Descent = -pHori->Descender;
1560 }
1561 else
1562 {
1563 Ascent = pOS2->usWinAscent;
1564 Descent = pOS2->usWinDescent;
1565 }
1566
1567 #if 0 /* This (Wine) code doesn't seem to work correctly for us, cmd issue */
1568 TM->tmAscent = (FT_MulFix(Ascent, YScale) + 32) >> 6;
1569 TM->tmDescent = (FT_MulFix(Descent, YScale) + 32) >> 6;
1570 #else /* This (ros) code was previously affected by a FreeType bug, but it works now */
1571 TM->tmAscent = (Face->size->metrics.ascender + 32) >> 6; /* Units above baseline */
1572 TM->tmDescent = (32 - Face->size->metrics.descender) >> 6; /* Units below baseline */
1573 #endif
1574 TM->tmInternalLeading = (FT_MulFix(Ascent + Descent - Face->units_per_EM, YScale) + 32) >> 6;
1575
1576 TM->tmHeight = TM->tmAscent + TM->tmDescent;
1577
1578 /* MSDN says:
1579 * el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
1580 */
1581 TM->tmExternalLeading = max(0, (FT_MulFix(pHori->Line_Gap
1582 - ((Ascent + Descent)
1583 - (pHori->Ascender - pHori->Descender)),
1584 YScale) + 32) >> 6);
1585
1586 TM->tmAveCharWidth = (FT_MulFix(pOS2->xAvgCharWidth, XScale) + 32) >> 6;
1587 if (TM->tmAveCharWidth == 0)
1588 {
1589 TM->tmAveCharWidth = 1;
1590 }
1591
1592 /* Correct forumla to get the maxcharwidth from unicode and ansi font */
1593 TM->tmMaxCharWidth = (FT_MulFix(Face->max_advance_width, XScale) + 32) >> 6;
1594
1595 if (RealFont)
1596 {
1597 TM->tmWeight = FontGDI->OriginalWeight;
1598 }
1599 else
1600 {
1601 if (FontGDI->OriginalWeight != FW_DONTCARE &&
1602 FontGDI->OriginalWeight != FW_NORMAL)
1603 {
1604 TM->tmWeight = FontGDI->OriginalWeight;
1605 }
1606 else
1607 {
1608 TM->tmWeight = FontGDI->RequestWeight;
1609 }
1610 }
1611
1612 TM->tmOverhang = 0;
1613 TM->tmDigitizedAspectX = 96;
1614 TM->tmDigitizedAspectY = 96;
1615 if (face_has_symbol_charmap(Face) ||
1616 (pOS2->usFirstCharIndex >= 0xf000 && pOS2->usFirstCharIndex < 0xf100))
1617 {
1618 USHORT cpOEM, cpAnsi;
1619
1620 EngGetCurrentCodePage(&cpOEM, &cpAnsi);
1621 TM->tmFirstChar = 0;
1622 switch(cpAnsi)
1623 {
1624 case 1257: /* Baltic */
1625 TM->tmLastChar = 0xf8fd;
1626 break;
1627 default:
1628 TM->tmLastChar = 0xf0ff;
1629 }
1630 TM->tmBreakChar = 0x20;
1631 TM->tmDefaultChar = 0x1f;
1632 }
1633 else
1634 {
1635 TM->tmFirstChar = pOS2->usFirstCharIndex; /* Should be the first char in the cmap */
1636 TM->tmLastChar = pOS2->usLastCharIndex; /* Should be min(cmap_last, os2_last) */
1637
1638 if(pOS2->usFirstCharIndex <= 1)
1639 TM->tmBreakChar = pOS2->usFirstCharIndex + 2;
1640 else if (pOS2->usFirstCharIndex > 0xff)
1641 TM->tmBreakChar = 0x20;
1642 else
1643 TM->tmBreakChar = pOS2->usFirstCharIndex;
1644 TM->tmDefaultChar = TM->tmBreakChar - 1;
1645 }
1646
1647 if (RealFont)
1648 {
1649 TM->tmItalic = FontGDI->OriginalItalic;
1650 TM->tmUnderlined = FALSE;
1651 TM->tmStruckOut = FALSE;
1652 }
1653 else
1654 {
1655 if (FontGDI->OriginalItalic || FontGDI->RequestItalic)
1656 {
1657 TM->tmItalic = 0xFF;
1658 }
1659 else
1660 {
1661 TM->tmItalic = 0;
1662 }
1663 TM->tmUnderlined = (FontGDI->RequestUnderline ? 0xFF : 0);
1664 TM->tmStruckOut = (FontGDI->RequestStrikeOut ? 0xFF : 0);
1665 }
1666
1667 if (!FT_IS_FIXED_WIDTH(Face))
1668 {
1669 switch (pOS2->panose[PAN_PROPORTION_INDEX])
1670 {
1671 case PAN_PROP_MONOSPACED:
1672 TM->tmPitchAndFamily = 0;
1673 break;
1674 default:
1675 TM->tmPitchAndFamily = _TMPF_VARIABLE_PITCH;
1676 break;
1677 }
1678 }
1679 else
1680 {
1681 TM->tmPitchAndFamily = 0;
1682 }
1683
1684 switch (pOS2->panose[PAN_FAMILYTYPE_INDEX])
1685 {
1686 case PAN_FAMILY_SCRIPT:
1687 TM->tmPitchAndFamily |= FF_SCRIPT;
1688 break;
1689 case PAN_FAMILY_DECORATIVE:
1690 TM->tmPitchAndFamily |= FF_DECORATIVE;
1691 break;
1692
1693 case PAN_ANY:
1694 case PAN_NO_FIT:
1695 case PAN_FAMILY_TEXT_DISPLAY:
1696 case PAN_FAMILY_PICTORIAL: /* Symbol fonts get treated as if they were text */
1697 /* Which is clearly not what the panose spec says. */
1698 if (TM->tmPitchAndFamily == 0) /* Fixed */
1699 {
1700 TM->tmPitchAndFamily = FF_MODERN;
1701 }
1702 else
1703 {
1704 switch (pOS2->panose[PAN_SERIFSTYLE_INDEX])
1705 {
1706 case PAN_ANY:
1707 case PAN_NO_FIT:
1708 default:
1709 TM->tmPitchAndFamily |= FF_DONTCARE;
1710 break;
1711
1712 case PAN_SERIF_COVE:
1713 case PAN_SERIF_OBTUSE_COVE:
1714 case PAN_SERIF_SQUARE_COVE:
1715 case PAN_SERIF_OBTUSE_SQUARE_COVE:
1716 case PAN_SERIF_SQUARE:
1717 case PAN_SERIF_THIN:
1718 case PAN_SERIF_BONE:
1719 case PAN_SERIF_EXAGGERATED:
1720 case PAN_SERIF_TRIANGLE:
1721 TM->tmPitchAndFamily |= FF_ROMAN;
1722 break;
1723
1724 case PAN_SERIF_NORMAL_SANS:
1725 case PAN_SERIF_OBTUSE_SANS:
1726 case PAN_SERIF_PERP_SANS:
1727 case PAN_SERIF_FLARED:
1728 case PAN_SERIF_ROUNDED:
1729 TM->tmPitchAndFamily |= FF_SWISS;
1730 break;
1731 }
1732 }
1733 break;
1734 default:
1735 TM->tmPitchAndFamily |= FF_DONTCARE;
1736 }
1737
1738 if (FT_IS_SCALABLE(Face))
1739 {
1740 TM->tmPitchAndFamily |= TMPF_VECTOR;
1741 }
1742 if (FT_IS_SFNT(Face))
1743 {
1744 TM->tmPitchAndFamily |= TMPF_TRUETYPE;
1745 }
1746
1747 TM->tmCharSet = FontGDI->CharSet;
1748 }
1749
1750 static void FASTCALL
1751 FillTM(TEXTMETRICW *TM, PFONTGDI FontGDI,
1752 TT_OS2 *pOS2, TT_HoriHeader *pHori,
1753 FT_WinFNT_HeaderRec *pFNT)
1754 {
1755 FillTMEx(TM, FontGDI, pOS2, pHori, pFNT, FALSE);
1756 }
1757
1758 static NTSTATUS
1759 IntGetFontLocalizedName(PUNICODE_STRING pNameW, PSHARED_FACE SharedFace,
1760 FT_UShort NameID, FT_UShort LangID);
1761
1762 /*************************************************************
1763 * IntGetOutlineTextMetrics
1764 *
1765 */
1766 INT FASTCALL
1767 IntGetOutlineTextMetrics(PFONTGDI FontGDI,
1768 UINT Size,
1769 OUTLINETEXTMETRICW *Otm)
1770 {
1771 TT_OS2 *pOS2;
1772 TT_HoriHeader *pHori;
1773 TT_Postscript *pPost;
1774 FT_Fixed XScale, YScale;
1775 FT_WinFNT_HeaderRec Win;
1776 FT_Error Error;
1777 char *Cp;
1778 UNICODE_STRING FamilyNameW, FaceNameW, StyleNameW, FullNameW;
1779 PSHARED_FACE SharedFace = FontGDI->SharedFace;
1780 PSHARED_FACE_CACHE Cache = (PRIMARYLANGID(gusLanguageID) == LANG_ENGLISH) ? &SharedFace->EnglishUS : &SharedFace->UserLanguage;
1781 FT_Face Face = SharedFace->Face;
1782
1783 if (Cache->OutlineRequiredSize && Size < Cache->OutlineRequiredSize)
1784 {
1785 return Cache->OutlineRequiredSize;
1786 }
1787
1788 /* family name */
1789 RtlInitUnicodeString(&FamilyNameW, NULL);
1790 IntGetFontLocalizedName(&FamilyNameW, SharedFace, TT_NAME_ID_FONT_FAMILY, gusLanguageID);
1791
1792 /* face name */
1793 RtlInitUnicodeString(&FaceNameW, NULL);
1794 IntGetFontLocalizedName(&FaceNameW, SharedFace, TT_NAME_ID_FULL_NAME, gusLanguageID);
1795
1796 /* style name */
1797 RtlInitUnicodeString(&StyleNameW, NULL);
1798 IntGetFontLocalizedName(&StyleNameW, SharedFace, TT_NAME_ID_FONT_SUBFAMILY, gusLanguageID);
1799
1800 /* unique name (full name) */
1801 RtlInitUnicodeString(&FullNameW, NULL);
1802 IntGetFontLocalizedName(&FullNameW, SharedFace, TT_NAME_ID_UNIQUE_ID, gusLanguageID);
1803
1804 if (!Cache->OutlineRequiredSize)
1805 {
1806 UINT Needed;
1807 Needed = sizeof(OUTLINETEXTMETRICW);
1808 Needed += FamilyNameW.Length + sizeof(WCHAR);
1809 Needed += FaceNameW.Length + sizeof(WCHAR);
1810 Needed += StyleNameW.Length + sizeof(WCHAR);
1811 Needed += FullNameW.Length + sizeof(WCHAR);
1812
1813 Cache->OutlineRequiredSize = Needed;
1814 }
1815
1816 if (Size < Cache->OutlineRequiredSize)
1817 {
1818 RtlFreeUnicodeString(&FamilyNameW);
1819 RtlFreeUnicodeString(&FaceNameW);
1820 RtlFreeUnicodeString(&StyleNameW);
1821 RtlFreeUnicodeString(&FullNameW);
1822 return Cache->OutlineRequiredSize;
1823 }
1824
1825 XScale = Face->size->metrics.x_scale;
1826 YScale = Face->size->metrics.y_scale;
1827
1828 IntLockFreeType;
1829 pOS2 = FT_Get_Sfnt_Table(Face, ft_sfnt_os2);
1830 if (NULL == pOS2)
1831 {
1832 IntUnLockFreeType;
1833 DPRINT1("Can't find OS/2 table - not TT font?\n");
1834 RtlFreeUnicodeString(&FamilyNameW);
1835 RtlFreeUnicodeString(&FaceNameW);
1836 RtlFreeUnicodeString(&StyleNameW);
1837 RtlFreeUnicodeString(&FullNameW);
1838 return 0;
1839 }
1840
1841 pHori = FT_Get_Sfnt_Table(Face, ft_sfnt_hhea);
1842 if (NULL == pHori)
1843 {
1844 IntUnLockFreeType;
1845 DPRINT1("Can't find HHEA table - not TT font?\n");
1846 RtlFreeUnicodeString(&FamilyNameW);
1847 RtlFreeUnicodeString(&FaceNameW);
1848 RtlFreeUnicodeString(&StyleNameW);
1849 RtlFreeUnicodeString(&FullNameW);
1850 return 0;
1851 }
1852
1853 pPost = FT_Get_Sfnt_Table(Face, ft_sfnt_post); /* We can live with this failing */
1854
1855 Error = FT_Get_WinFNT_Header(Face , &Win);
1856
1857 Otm->otmSize = Cache->OutlineRequiredSize;
1858
1859 FillTM(&Otm->otmTextMetrics, FontGDI, pOS2, pHori, !Error ? &Win : 0);
1860
1861 Otm->otmFiller = 0;
1862 RtlCopyMemory(&Otm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
1863 Otm->otmfsSelection = pOS2->fsSelection;
1864 Otm->otmfsType = pOS2->fsType;
1865 Otm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
1866 Otm->otmsCharSlopeRun = pHori->caret_Slope_Run;
1867 Otm->otmItalicAngle = 0; /* POST table */
1868 Otm->otmEMSquare = Face->units_per_EM;
1869 Otm->otmAscent = (FT_MulFix(pOS2->sTypoAscender, YScale) + 32) >> 6;
1870 Otm->otmDescent = (FT_MulFix(pOS2->sTypoDescender, YScale) + 32) >> 6;
1871 Otm->otmLineGap = (FT_MulFix(pOS2->sTypoLineGap, YScale) + 32) >> 6;
1872 Otm->otmsCapEmHeight = (FT_MulFix(pOS2->sCapHeight, YScale) + 32) >> 6;
1873 Otm->otmsXHeight = (FT_MulFix(pOS2->sxHeight, YScale) + 32) >> 6;
1874 Otm->otmrcFontBox.left = (FT_MulFix(Face->bbox.xMin, XScale) + 32) >> 6;
1875 Otm->otmrcFontBox.right = (FT_MulFix(Face->bbox.xMax, XScale) + 32) >> 6;
1876 Otm->otmrcFontBox.top = (FT_MulFix(Face->bbox.yMax, YScale) + 32) >> 6;
1877 Otm->otmrcFontBox.bottom = (FT_MulFix(Face->bbox.yMin, YScale) + 32) >> 6;
1878 Otm->otmMacAscent = Otm->otmTextMetrics.tmAscent;
1879 Otm->otmMacDescent = -Otm->otmTextMetrics.tmDescent;
1880 Otm->otmMacLineGap = Otm->otmLineGap;
1881 Otm->otmusMinimumPPEM = 0; /* TT Header */
1882 Otm->otmptSubscriptSize.x = (FT_MulFix(pOS2->ySubscriptXSize, XScale) + 32) >> 6;
1883 Otm->otmptSubscriptSize.y = (FT_MulFix(pOS2->ySubscriptYSize, YScale) + 32) >> 6;
1884 Otm->otmptSubscriptOffset.x = (FT_MulFix(pOS2->ySubscriptXOffset, XScale) + 32) >> 6;
1885 Otm->otmptSubscriptOffset.y = (FT_MulFix(pOS2->ySubscriptYOffset, YScale) + 32) >> 6;
1886 Otm->otmptSuperscriptSize.x = (FT_MulFix(pOS2->ySuperscriptXSize, XScale) + 32) >> 6;
1887 Otm->otmptSuperscriptSize.y = (FT_MulFix(pOS2->ySuperscriptYSize, YScale) + 32) >> 6;
1888 Otm->otmptSuperscriptOffset.x = (FT_MulFix(pOS2->ySuperscriptXOffset, XScale) + 32) >> 6;
1889 Otm->otmptSuperscriptOffset.y = (FT_MulFix(pOS2->ySuperscriptYOffset, YScale) + 32) >> 6;
1890 Otm->otmsStrikeoutSize = (FT_MulFix(pOS2->yStrikeoutSize, YScale) + 32) >> 6;
1891 Otm->otmsStrikeoutPosition = (FT_MulFix(pOS2->yStrikeoutPosition, YScale) + 32) >> 6;
1892 if (!pPost)
1893 {
1894 Otm->otmsUnderscoreSize = 0;
1895 Otm->otmsUnderscorePosition = 0;
1896 }
1897 else
1898 {
1899 Otm->otmsUnderscoreSize = (FT_MulFix(pPost->underlineThickness, YScale) + 32) >> 6;
1900 Otm->otmsUnderscorePosition = (FT_MulFix(pPost->underlinePosition, YScale) + 32) >> 6;
1901 }
1902
1903 IntUnLockFreeType;
1904
1905 Cp = (char*) Otm + sizeof(OUTLINETEXTMETRICW);
1906
1907 /* family name */
1908 Otm->otmpFamilyName = (LPSTR)(Cp - (char*) Otm);
1909 wcscpy((WCHAR*) Cp, FamilyNameW.Buffer);
1910 Cp += FamilyNameW.Length + sizeof(WCHAR);
1911
1912 /* face name */
1913 Otm->otmpFaceName = (LPSTR)(Cp - (char*) Otm);
1914 wcscpy((WCHAR*) Cp, FaceNameW.Buffer);
1915 Cp += FaceNameW.Length + sizeof(WCHAR);
1916
1917 /* style name */
1918 Otm->otmpStyleName = (LPSTR)(Cp - (char*) Otm);
1919 wcscpy((WCHAR*) Cp, StyleNameW.Buffer);
1920 Cp += StyleNameW.Length + sizeof(WCHAR);
1921
1922 /* unique name (full name) */
1923 Otm->otmpFullName = (LPSTR)(Cp - (char*) Otm);
1924 wcscpy((WCHAR*) Cp, FullNameW.Buffer);
1925 Cp += FullNameW.Length + sizeof(WCHAR);
1926
1927 ASSERT(Cp - (char*)Otm == Cache->OutlineRequiredSize);
1928
1929 RtlFreeUnicodeString(&FamilyNameW);
1930 RtlFreeUnicodeString(&FaceNameW);
1931 RtlFreeUnicodeString(&StyleNameW);
1932 RtlFreeUnicodeString(&FullNameW);
1933
1934 return Cache->OutlineRequiredSize;
1935 }
1936
1937 static PFONTGDI FASTCALL
1938 FindFaceNameInList(PUNICODE_STRING FaceName, PLIST_ENTRY Head)
1939 {
1940 PLIST_ENTRY Entry;
1941 PFONT_ENTRY CurrentEntry;
1942 ANSI_STRING EntryFaceNameA;
1943 UNICODE_STRING EntryFaceNameW;
1944 FONTGDI *FontGDI;
1945 NTSTATUS status;
1946
1947 Entry = Head->Flink;
1948 while (Entry != Head)
1949 {
1950 CurrentEntry = CONTAINING_RECORD(Entry, FONT_ENTRY, ListEntry);
1951
1952 FontGDI = CurrentEntry->Font;
1953 ASSERT(FontGDI);
1954
1955 RtlInitAnsiString(&EntryFaceNameA, FontGDI->SharedFace->Face->family_name);
1956 status = RtlAnsiStringToUnicodeString(&EntryFaceNameW, &EntryFaceNameA, TRUE);
1957 if (!NT_SUCCESS(status))
1958 {
1959 break;
1960 }
1961
1962 if ((LF_FACESIZE - 1) * sizeof(WCHAR) < EntryFaceNameW.Length)
1963 {
1964 EntryFaceNameW.Length = (LF_FACESIZE - 1) * sizeof(WCHAR);
1965 EntryFaceNameW.Buffer[LF_FACESIZE - 1] = L'\0';
1966 }
1967
1968 if (RtlEqualUnicodeString(FaceName, &EntryFaceNameW, TRUE))
1969 {
1970 RtlFreeUnicodeString(&EntryFaceNameW);
1971 return FontGDI;
1972 }
1973
1974 RtlFreeUnicodeString(&EntryFaceNameW);
1975 Entry = Entry->Flink;
1976 }
1977
1978 return NULL;
1979 }
1980
1981 static PFONTGDI FASTCALL
1982 FindFaceNameInLists(PUNICODE_STRING FaceName)
1983 {
1984 PPROCESSINFO Win32Process;
1985 PFONTGDI Font;
1986
1987 /* Search the process local list.
1988 We do not have to search the 'Mem' list, since those fonts are linked in the PrivateFontListHead */
1989 Win32Process = PsGetCurrentProcessWin32Process();
1990 IntLockProcessPrivateFonts(Win32Process);
1991 Font = FindFaceNameInList(FaceName, &Win32Process->PrivateFontListHead);
1992 IntUnLockProcessPrivateFonts(Win32Process);
1993 if (NULL != Font)
1994 {
1995 return Font;
1996 }
1997
1998 /* Search the global list */
1999 IntLockGlobalFonts;
2000 Font = FindFaceNameInList(FaceName, &FontListHead);
2001 IntUnLockGlobalFonts;
2002
2003 return Font;
2004 }
2005
2006 /* See https://msdn.microsoft.com/en-us/library/bb165625(v=vs.90).aspx */
2007 static BYTE
2008 CharSetFromLangID(LANGID LangID)
2009 {
2010 /* FIXME: Add more and fix if wrong */
2011 switch (PRIMARYLANGID(LangID))
2012 {
2013 case LANG_CHINESE:
2014 switch (SUBLANGID(LangID))
2015 {
2016 case SUBLANG_CHINESE_TRADITIONAL:
2017 return CHINESEBIG5_CHARSET;
2018 case SUBLANG_CHINESE_SIMPLIFIED:
2019 default:
2020 break;
2021 }
2022 return GB2312_CHARSET;
2023
2024 case LANG_CZECH: case LANG_HUNGARIAN: case LANG_POLISH:
2025 case LANG_SLOVAK: case LANG_SLOVENIAN: case LANG_ROMANIAN:
2026 return EASTEUROPE_CHARSET;
2027
2028 case LANG_RUSSIAN: case LANG_BULGARIAN: case LANG_MACEDONIAN:
2029 case LANG_SERBIAN: case LANG_UKRAINIAN:
2030 return RUSSIAN_CHARSET;
2031
2032 case LANG_ARABIC: return ARABIC_CHARSET;
2033 case LANG_GREEK: return GREEK_CHARSET;
2034 case LANG_HEBREW: return HEBREW_CHARSET;
2035 case LANG_JAPANESE: return SHIFTJIS_CHARSET;
2036 case LANG_KOREAN: return JOHAB_CHARSET;
2037 case LANG_TURKISH: return TURKISH_CHARSET;
2038 case LANG_THAI: return THAI_CHARSET;
2039 case LANG_LATVIAN: return BALTIC_CHARSET;
2040 case LANG_VIETNAMESE: return VIETNAMESE_CHARSET;
2041
2042 case LANG_ENGLISH: case LANG_BASQUE: case LANG_CATALAN:
2043 case LANG_DANISH: case LANG_DUTCH: case LANG_FINNISH:
2044 case LANG_FRENCH: case LANG_GERMAN: case LANG_ITALIAN:
2045 case LANG_NORWEGIAN: case LANG_PORTUGUESE: case LANG_SPANISH:
2046 case LANG_SWEDISH: default:
2047 return ANSI_CHARSET;
2048 }
2049 }
2050
2051 static void
2052 SwapEndian(LPVOID pvData, DWORD Size)
2053 {
2054 BYTE b, *pb = pvData;
2055 Size /= 2;
2056 while (Size-- > 0)
2057 {
2058 b = pb[0];
2059 pb[0] = pb[1];
2060 pb[1] = b;
2061 ++pb; ++pb;
2062 }
2063 }
2064
2065 static NTSTATUS
2066 DuplicateUnicodeString(PUNICODE_STRING Source, PUNICODE_STRING Destination)
2067 {
2068 NTSTATUS Status = STATUS_NO_MEMORY;
2069 UNICODE_STRING Tmp;
2070
2071 Tmp.Buffer = ExAllocatePoolWithTag(PagedPool, Source->MaximumLength, TAG_USTR);
2072 if (Tmp.Buffer)
2073 {
2074 Tmp.MaximumLength = Source->MaximumLength;
2075 Tmp.Length = 0;
2076 RtlCopyUnicodeString(&Tmp, Source);
2077
2078 Destination->MaximumLength = Tmp.MaximumLength;
2079 Destination->Length = Tmp.Length;
2080 Destination->Buffer = Tmp.Buffer;
2081
2082 Status = STATUS_SUCCESS;
2083 }
2084
2085 return Status;
2086 }
2087
2088 static NTSTATUS
2089 IntGetFontLocalizedName(PUNICODE_STRING pNameW, PSHARED_FACE SharedFace,
2090 FT_UShort NameID, FT_UShort LangID)
2091 {
2092 FT_SfntName Name;
2093 INT i, Count, BestIndex, Score, BestScore;
2094 WCHAR Buf[LF_FULLFACESIZE];
2095 FT_Error Error;
2096 NTSTATUS Status = STATUS_NOT_FOUND;
2097 ANSI_STRING AnsiName;
2098 PSHARED_FACE_CACHE Cache;
2099 FT_Face Face = SharedFace->Face;
2100
2101 RtlFreeUnicodeString(pNameW);
2102
2103 /* select cache */
2104 if (PRIMARYLANGID(LangID) == LANG_ENGLISH)
2105 {
2106 Cache = &SharedFace->EnglishUS;
2107 }
2108 else
2109 {
2110 Cache = &SharedFace->UserLanguage;
2111 }
2112
2113 /* use cache if available */
2114 if (NameID == TT_NAME_ID_FONT_FAMILY && Cache->FontFamily.Buffer)
2115 {
2116 return DuplicateUnicodeString(&Cache->FontFamily, pNameW);
2117 }
2118 if (NameID == TT_NAME_ID_FULL_NAME && Cache->FullName.Buffer)
2119 {
2120 return DuplicateUnicodeString(&Cache->FullName, pNameW);
2121 }
2122
2123 BestIndex = -1;
2124 BestScore = 0;
2125
2126 Count = FT_Get_Sfnt_Name_Count(Face);
2127 for (i = 0; i < Count; ++i)
2128 {
2129 Error = FT_Get_Sfnt_Name(Face, i, &Name);
2130 if (Error)
2131 {
2132 continue; /* failure */
2133 }
2134
2135 if (Name.name_id != NameID)
2136 {
2137 continue; /* mismatched */
2138 }
2139
2140 if (Name.platform_id != TT_PLATFORM_MICROSOFT ||
2141 (Name.encoding_id != TT_MS_ID_UNICODE_CS &&
2142 Name.encoding_id != TT_MS_ID_SYMBOL_CS))
2143 {
2144 continue; /* not Microsoft Unicode name */
2145 }
2146
2147 if (Name.string == NULL || Name.string_len == 0 ||
2148 (Name.string[0] == 0 && Name.string[1] == 0))
2149 {
2150 continue; /* invalid string */
2151 }
2152
2153 if (sizeof(Buf) < Name.string_len + sizeof(UNICODE_NULL))
2154 {
2155 continue; /* name too long */
2156 }
2157
2158 if (Name.language_id == LangID)
2159 {
2160 Score = 30;
2161 BestIndex = i;
2162 break; /* best match */
2163 }
2164 else if (PRIMARYLANGID(Name.language_id) == PRIMARYLANGID(LangID))
2165 {
2166 Score = 20;
2167 }
2168 else if (PRIMARYLANGID(Name.language_id) == LANG_ENGLISH)
2169 {
2170 Score = 10;
2171 }
2172 else
2173 {
2174 Score = 0;
2175 }
2176
2177 if (Score > BestScore)
2178 {
2179 BestScore = Score;
2180 BestIndex = i;
2181 }
2182 }
2183
2184 if (BestIndex >= 0)
2185 {
2186 /* store the best name */
2187 Error = (Score == 30) ? 0 : FT_Get_Sfnt_Name(Face, BestIndex, &Name);
2188 if (!Error)
2189 {
2190 /* NOTE: Name.string is not null-terminated */
2191 RtlCopyMemory(Buf, Name.string, Name.string_len);
2192 Buf[Name.string_len / sizeof(WCHAR)] = UNICODE_NULL;
2193
2194 /* Convert UTF-16 big endian to little endian */
2195 SwapEndian(Buf, Name.string_len);
2196
2197 if (RtlCreateUnicodeString(pNameW, Buf))
2198 {
2199 Status = STATUS_SUCCESS;
2200 }
2201 else
2202 {
2203 Status = STATUS_INSUFFICIENT_RESOURCES;
2204 }
2205 }
2206 }
2207
2208 if (!NT_SUCCESS(Status))
2209 {
2210 /* defaulted */
2211 if (NameID == TT_NAME_ID_FONT_SUBFAMILY)
2212 {
2213 RtlInitAnsiString(&AnsiName, Face->style_name);
2214 Status = RtlAnsiStringToUnicodeString(pNameW, &AnsiName, TRUE);
2215 }
2216 else
2217 {
2218 RtlInitAnsiString(&AnsiName, Face->family_name);
2219 Status = RtlAnsiStringToUnicodeString(pNameW, &AnsiName, TRUE);
2220 }
2221 }
2222
2223 if (NT_SUCCESS(Status))
2224 {
2225 /* make cache */
2226 if (NameID == TT_NAME_ID_FONT_FAMILY)
2227 {
2228 ASSERT_FREETYPE_LOCK_NOT_HELD();
2229 IntLockFreeType;
2230 if (!Cache->FontFamily.Buffer)
2231 DuplicateUnicodeString(pNameW, &Cache->FontFamily);
2232 IntUnLockFreeType;
2233 }
2234 else if (NameID == TT_NAME_ID_FULL_NAME)
2235 {
2236 ASSERT_FREETYPE_LOCK_NOT_HELD();
2237 IntLockFreeType;
2238 if (!Cache->FullName.Buffer)
2239 DuplicateUnicodeString(pNameW, &Cache->FullName);
2240 IntUnLockFreeType;
2241 }
2242 }
2243
2244 return Status;
2245 }
2246
2247 static void FASTCALL
2248 FontFamilyFillInfo(PFONTFAMILYINFO Info, LPCWSTR FaceName,
2249 LPCWSTR FullName, PFONTGDI FontGDI)
2250 {
2251 ANSI_STRING StyleA;
2252 UNICODE_STRING StyleW;
2253 TT_OS2 *pOS2;
2254 FONTSIGNATURE fs;
2255 CHARSETINFO CharSetInfo;
2256 unsigned i, Size;
2257 OUTLINETEXTMETRICW *Otm;
2258 LOGFONTW *Lf;
2259 TEXTMETRICW *TM;
2260 NEWTEXTMETRICW *Ntm;
2261 DWORD fs0;
2262 NTSTATUS status;
2263 PSHARED_FACE SharedFace = FontGDI->SharedFace;
2264 FT_Face Face = SharedFace->Face;
2265 UNICODE_STRING NameW;
2266
2267 RtlInitUnicodeString(&NameW, NULL);
2268 RtlZeroMemory(Info, sizeof(FONTFAMILYINFO));
2269 Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL);
2270 Otm = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
2271 if (!Otm)
2272 {
2273 return;
2274 }
2275 Size = IntGetOutlineTextMetrics(FontGDI, Size, Otm);
2276 if (!Size)
2277 {
2278 ExFreePoolWithTag(Otm, GDITAG_TEXT);
2279 return;
2280 }
2281
2282 Lf = &Info->EnumLogFontEx.elfLogFont;
2283 TM = &Otm->otmTextMetrics;
2284
2285 Lf->lfHeight = TM->tmHeight;
2286 Lf->lfWidth = TM->tmAveCharWidth;
2287 Lf->lfWeight = TM->tmWeight;
2288 Lf->lfItalic = TM->tmItalic;
2289 Lf->lfPitchAndFamily = (TM->tmPitchAndFamily & 0xf1) + 1;
2290 Lf->lfCharSet = TM->tmCharSet;
2291 Lf->lfOutPrecision = OUT_OUTLINE_PRECIS;
2292 Lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
2293 Lf->lfQuality = PROOF_QUALITY;
2294
2295 Ntm = &Info->NewTextMetricEx.ntmTm;
2296 Ntm->tmHeight = TM->tmHeight;
2297 Ntm->tmAscent = TM->tmAscent;
2298 Ntm->tmDescent = TM->tmDescent;
2299 Ntm->tmInternalLeading = TM->tmInternalLeading;
2300 Ntm->tmExternalLeading = TM->tmExternalLeading;
2301 Ntm->tmAveCharWidth = TM->tmAveCharWidth;
2302 Ntm->tmMaxCharWidth = TM->tmMaxCharWidth;
2303 Ntm->tmWeight = TM->tmWeight;
2304 Ntm->tmOverhang = TM->tmOverhang;
2305 Ntm->tmDigitizedAspectX = TM->tmDigitizedAspectX;
2306 Ntm->tmDigitizedAspectY = TM->tmDigitizedAspectY;
2307 Ntm->tmFirstChar = TM->tmFirstChar;
2308 Ntm->tmLastChar = TM->tmLastChar;
2309 Ntm->tmDefaultChar = TM->tmDefaultChar;
2310 Ntm->tmBreakChar = TM->tmBreakChar;
2311 Ntm->tmItalic = TM->tmItalic;
2312 Ntm->tmUnderlined = TM->tmUnderlined;
2313 Ntm->tmStruckOut = TM->tmStruckOut;
2314 Ntm->tmPitchAndFamily = TM->tmPitchAndFamily;
2315 Ntm->tmCharSet = TM->tmCharSet;
2316 Ntm->ntmFlags = TM->tmItalic ? NTM_ITALIC : 0;
2317
2318 if (550 < TM->tmWeight) Ntm->ntmFlags |= NTM_BOLD;
2319
2320 if (0 == Ntm->ntmFlags) Ntm->ntmFlags = NTM_REGULAR;
2321
2322 Ntm->ntmSizeEM = Otm->otmEMSquare;
2323 Ntm->ntmCellHeight = Otm->otmEMSquare;
2324 Ntm->ntmAvgWidth = 0;
2325
2326 Info->FontType = (0 != (TM->tmPitchAndFamily & TMPF_TRUETYPE)
2327 ? TRUETYPE_FONTTYPE : 0);
2328
2329 if (0 == (TM->tmPitchAndFamily & TMPF_VECTOR))
2330 Info->FontType |= RASTER_FONTTYPE;
2331
2332
2333 /* face name */
2334 if (!FaceName)
2335 FaceName = (WCHAR*)((ULONG_PTR)Otm + (ULONG_PTR)Otm->otmpFamilyName);
2336
2337 RtlStringCbCopyW(Lf->lfFaceName, sizeof(Lf->lfFaceName), FaceName);
2338
2339 /* full name */
2340 if (!FullName)
2341 FullName = (WCHAR*)((ULONG_PTR) Otm + (ULONG_PTR)Otm->otmpFaceName);
2342
2343 RtlStringCbCopyW(Info->EnumLogFontEx.elfFullName,
2344 sizeof(Info->EnumLogFontEx.elfFullName),
2345 FullName);
2346
2347 ExFreePoolWithTag(Otm, GDITAG_TEXT);
2348
2349 RtlInitAnsiString(&StyleA, Face->style_name);
2350 StyleW.Buffer = Info->EnumLogFontEx.elfStyle;
2351 StyleW.MaximumLength = sizeof(Info->EnumLogFontEx.elfStyle);
2352 status = RtlAnsiStringToUnicodeString(&StyleW, &StyleA, FALSE);
2353 if (!NT_SUCCESS(status))
2354 {
2355 return;
2356 }
2357 Info->EnumLogFontEx.elfScript[0] = UNICODE_NULL;
2358
2359 IntLockFreeType;
2360 pOS2 = FT_Get_Sfnt_Table(Face, ft_sfnt_os2);
2361
2362 if (!pOS2)
2363 {
2364 IntUnLockFreeType;
2365 return;
2366 }
2367
2368 fs.fsCsb[0] = pOS2->ulCodePageRange1;
2369 fs.fsCsb[1] = pOS2->ulCodePageRange2;
2370 fs.fsUsb[0] = pOS2->ulUnicodeRange1;
2371 fs.fsUsb[1] = pOS2->ulUnicodeRange2;
2372 fs.fsUsb[2] = pOS2->ulUnicodeRange3;
2373 fs.fsUsb[3] = pOS2->ulUnicodeRange4;
2374
2375 if (0 == pOS2->version)
2376 {
2377 FT_UInt Dummy;
2378
2379 if (FT_Get_First_Char(Face, &Dummy) < 0x100)
2380 fs.fsCsb[0] |= FS_LATIN1;
2381 else
2382 fs.fsCsb[0] |= FS_SYMBOL;
2383 }
2384 IntUnLockFreeType;
2385
2386 if (fs.fsCsb[0] == 0)
2387 {
2388 /* Let's see if we can find any interesting cmaps */
2389 for (i = 0; i < (UINT)Face->num_charmaps; i++)
2390 {
2391 switch (Face->charmaps[i]->encoding)
2392 {
2393 case FT_ENCODING_UNICODE:
2394 case FT_ENCODING_APPLE_ROMAN:
2395 fs.fsCsb[0] |= FS_LATIN1;
2396 break;
2397 case FT_ENCODING_MS_SYMBOL:
2398 fs.fsCsb[0] |= FS_SYMBOL;
2399 break;
2400 default:
2401 break;
2402 }
2403 }
2404 }
2405
2406 for (i = 0; i < MAXTCIINDEX; i++)
2407 {
2408 fs0 = 1L << i;
2409 if (fs.fsCsb[0] & fs0)
2410 {
2411 if (!IntTranslateCharsetInfo(&fs0, &CharSetInfo, TCI_SRCFONTSIG))
2412 {
2413 CharSetInfo.ciCharset = DEFAULT_CHARSET;
2414 }
2415 if (DEFAULT_CHARSET != CharSetInfo.ciCharset)
2416 {
2417 if (ElfScripts[i])
2418 wcscpy(Info->EnumLogFontEx.elfScript, ElfScripts[i]);
2419 else
2420 {
2421 DPRINT1("Unknown elfscript for bit %u\n", i);
2422 }
2423 }
2424 }
2425 }
2426 Info->NewTextMetricEx.ntmFontSig = fs;
2427 }
2428
2429 static int FASTCALL
2430 FindFaceNameInInfo(PUNICODE_STRING FaceName, PFONTFAMILYINFO Info, DWORD InfoEntries)
2431 {
2432 DWORD i;
2433 UNICODE_STRING InfoFaceName;
2434
2435 for (i = 0; i < InfoEntries; i++)
2436 {
2437 RtlInitUnicodeString(&InfoFaceName, Info[i].EnumLogFontEx.elfLogFont.lfFaceName);
2438 if (RtlEqualUnicodeString(&InfoFaceName, FaceName, TRUE))
2439 {
2440 return i;
2441 }
2442 }
2443
2444 return -1;
2445 }
2446
2447 static BOOLEAN FASTCALL
2448 FontFamilyInclude(LPLOGFONTW LogFont, PUNICODE_STRING FaceName,
2449 PFONTFAMILYINFO Info, DWORD InfoEntries)
2450 {
2451 UNICODE_STRING LogFontFaceName;
2452
2453 RtlInitUnicodeString(&LogFontFaceName, LogFont->lfFaceName);
2454 if (0 != LogFontFaceName.Length &&
2455 !RtlEqualUnicodeString(&LogFontFaceName, FaceName, TRUE))
2456 {
2457 return FALSE;
2458 }
2459
2460 return FindFaceNameInInfo(FaceName, Info, InfoEntries) < 0;
2461 }
2462
2463 static BOOL FASTCALL
2464 FontFamilyFound(PFONTFAMILYINFO InfoEntry,
2465 PFONTFAMILYINFO Info, DWORD InfoCount)
2466 {
2467 LPLOGFONTW plf1 = &InfoEntry->EnumLogFontEx.elfLogFont;
2468 LPWSTR pFullName1 = InfoEntry->EnumLogFontEx.elfFullName;
2469 LPWSTR pFullName2;
2470 DWORD i;
2471
2472 for (i = 0; i < InfoCount; ++i)
2473 {
2474 LPLOGFONTW plf2 = &Info[i].EnumLogFontEx.elfLogFont;
2475 if (plf1->lfCharSet != plf2->lfCharSet)
2476 continue;
2477
2478 pFullName2 = Info[i].EnumLogFontEx.elfFullName;
2479 if (_wcsicmp(pFullName1, pFullName2) != 0)
2480 continue;
2481
2482 return TRUE;
2483 }
2484 return FALSE;
2485 }
2486
2487 static BOOLEAN FASTCALL
2488 GetFontFamilyInfoForList(LPLOGFONTW LogFont,
2489 PFONTFAMILYINFO Info,
2490 DWORD *pCount,
2491 DWORD MaxCount,
2492 PLIST_ENTRY Head)
2493 {
2494 PLIST_ENTRY Entry;
2495 PFONT_ENTRY CurrentEntry;
2496 FONTGDI *FontGDI;
2497 FONTFAMILYINFO InfoEntry;
2498 DWORD Count = *pCount;
2499
2500 for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
2501 {
2502 CurrentEntry = CONTAINING_RECORD(Entry, FONT_ENTRY, ListEntry);
2503 FontGDI = CurrentEntry->Font;
2504 ASSERT(FontGDI);
2505
2506 if (LogFont->lfCharSet != DEFAULT_CHARSET &&
2507 LogFont->lfCharSet != FontGDI->CharSet)
2508 {
2509 continue;
2510 }
2511
2512 if (LogFont->lfFaceName[0] == UNICODE_NULL)
2513 {
2514 if (Count < MaxCount)
2515 {
2516 FontFamilyFillInfo(&Info[Count], NULL, NULL, FontGDI);
2517 }
2518 Count++;
2519 continue;
2520 }
2521
2522 FontFamilyFillInfo(&InfoEntry, NULL, NULL, FontGDI);
2523
2524 if (_wcsicmp(LogFont->lfFaceName, InfoEntry.EnumLogFontEx.elfLogFont.lfFaceName) != 0 &&
2525 _wcsicmp(LogFont->lfFaceName, InfoEntry.EnumLogFontEx.elfFullName) != 0)
2526 {
2527 continue;
2528 }
2529
2530 if (!FontFamilyFound(&InfoEntry, Info, min(Count, MaxCount)))
2531 {
2532 if (Count < MaxCount)
2533 {
2534 RtlCopyMemory(&Info[Count], &InfoEntry, sizeof(InfoEntry));
2535 }
2536 Count++;
2537 }
2538 }
2539
2540 *pCount = Count;
2541
2542 return TRUE;
2543 }
2544
2545 static BOOLEAN FASTCALL
2546 GetFontFamilyInfoForSubstitutes(LPLOGFONTW LogFont,
2547 PFONTFAMILYINFO Info,
2548 DWORD *pCount,
2549 DWORD MaxCount)
2550 {
2551 PLIST_ENTRY pEntry, pHead = &FontSubstListHead;
2552 PFONTSUBST_ENTRY pCurrentEntry;
2553 PUNICODE_STRING pFromW;
2554 FONTGDI *FontGDI;
2555 LOGFONTW lf = *LogFont;
2556 UNICODE_STRING NameW;
2557
2558 for (pEntry = pHead->Flink; pEntry != pHead; pEntry = pEntry->Flink)
2559 {
2560 pCurrentEntry = CONTAINING_RECORD(pEntry, FONTSUBST_ENTRY, ListEntry);
2561
2562 pFromW = &pCurrentEntry->FontNames[FONTSUBST_FROM];
2563 if (LogFont->lfFaceName[0] != UNICODE_NULL)
2564 {
2565 if (!FontFamilyInclude(LogFont, pFromW, Info, min(*pCount, MaxCount)))
2566 continue; /* mismatch */
2567 }
2568
2569 RtlStringCchCopyW(lf.lfFaceName, LF_FACESIZE, pFromW->Buffer);
2570 SubstituteFontRecurse(&lf);
2571
2572 RtlInitUnicodeString(&NameW, lf.lfFaceName);
2573 FontGDI = FindFaceNameInLists(&NameW);
2574 if (FontGDI == NULL)
2575 {
2576 continue; /* no real font */
2577 }
2578
2579 if (*pCount < MaxCount)
2580 {
2581 FontFamilyFillInfo(&Info[*pCount], pFromW->Buffer, NULL, FontGDI);
2582 }
2583 (*pCount)++;
2584 }
2585
2586 return TRUE;
2587 }
2588
2589 BOOL
2590 FASTCALL
2591 ftGdiGetRasterizerCaps(LPRASTERIZER_STATUS lprs)
2592 {
2593 if ( lprs )
2594 {
2595 lprs->nSize = sizeof(RASTERIZER_STATUS);
2596 lprs->wFlags = TT_AVAILABLE | TT_ENABLED;
2597 lprs->nLanguageID = gusLanguageID;
2598 return TRUE;
2599 }
2600 EngSetLastError(ERROR_INVALID_PARAMETER);
2601 return FALSE;
2602 }
2603
2604 static
2605 BOOL
2606 SameScaleMatrix(
2607 PMATRIX pmx1,
2608 PMATRIX pmx2)
2609 {
2610 return (FLOATOBJ_Equal(&pmx1->efM11, &pmx2->efM11) &&
2611 FLOATOBJ_Equal(&pmx1->efM12, &pmx2->efM12) &&
2612 FLOATOBJ_Equal(&pmx1->efM21, &pmx2->efM21) &&
2613 FLOATOBJ_Equal(&pmx1->efM22, &pmx2->efM22));
2614 }
2615
2616 FT_BitmapGlyph APIENTRY
2617 ftGdiGlyphCacheGet(
2618 FT_Face Face,
2619 INT GlyphIndex,
2620 INT Height,
2621 FT_Render_Mode RenderMode,
2622 PMATRIX pmx)
2623 {
2624 PLIST_ENTRY CurrentEntry;
2625 PFONT_CACHE_ENTRY FontEntry;
2626
2627 ASSERT_FREETYPE_LOCK_HELD();
2628
2629 CurrentEntry = FontCacheListHead.Flink;
2630 while (CurrentEntry != &FontCacheListHead)
2631 {
2632 FontEntry = CONTAINING_RECORD(CurrentEntry, FONT_CACHE_ENTRY, ListEntry);
2633 if ((FontEntry->Face == Face) &&
2634 (FontEntry->GlyphIndex == GlyphIndex) &&
2635 (FontEntry->Height == Height) &&
2636 (FontEntry->RenderMode == RenderMode) &&
2637 (SameScaleMatrix(&FontEntry->mxWorldToDevice, pmx)))
2638 break;
2639 CurrentEntry = CurrentEntry->Flink;
2640 }
2641
2642 if (CurrentEntry == &FontCacheListHead)
2643 {
2644 return NULL;
2645 }
2646
2647 RemoveEntryList(CurrentEntry);
2648 InsertHeadList(&FontCacheListHead, CurrentEntry);
2649 return FontEntry->BitmapGlyph;
2650 }
2651
2652 /* no cache */
2653 FT_BitmapGlyph APIENTRY
2654 ftGdiGlyphSet(
2655 FT_Face Face,
2656 FT_GlyphSlot GlyphSlot,
2657 FT_Render_Mode RenderMode)
2658 {
2659 FT_Glyph Glyph;
2660 INT error;
2661 FT_Bitmap AlignedBitmap;
2662 FT_BitmapGlyph BitmapGlyph;
2663
2664 error = FT_Get_Glyph(GlyphSlot, &Glyph);
2665 if (error)
2666 {
2667 DPRINT1("Failure getting glyph.\n");
2668 return NULL;
2669 }
2670
2671 error = FT_Glyph_To_Bitmap(&Glyph, RenderMode, 0, 1);
2672 if (error)
2673 {
2674 FT_Done_Glyph(Glyph);
2675 DPRINT1("Failure rendering glyph.\n");
2676 return NULL;
2677 }
2678
2679 BitmapGlyph = (FT_BitmapGlyph)Glyph;
2680 FT_Bitmap_New(&AlignedBitmap);
2681 if (FT_Bitmap_Convert(GlyphSlot->library, &BitmapGlyph->bitmap, &AlignedBitmap, 4))
2682 {
2683 DPRINT1("Conversion failed\n");
2684 FT_Done_Glyph((FT_Glyph)BitmapGlyph);
2685 return NULL;
2686 }
2687
2688 FT_Bitmap_Done(GlyphSlot->library, &BitmapGlyph->bitmap);
2689 BitmapGlyph->bitmap = AlignedBitmap;
2690
2691 return BitmapGlyph;
2692 }
2693
2694 FT_BitmapGlyph APIENTRY
2695 ftGdiGlyphCacheSet(
2696 FT_Face Face,
2697 INT GlyphIndex,
2698 INT Height,
2699 PMATRIX pmx,
2700 FT_GlyphSlot GlyphSlot,
2701 FT_Render_Mode RenderMode)
2702 {
2703 FT_Glyph GlyphCopy;
2704 INT error;
2705 PFONT_CACHE_ENTRY NewEntry;
2706 FT_Bitmap AlignedBitmap;
2707 FT_BitmapGlyph BitmapGlyph;
2708
2709 ASSERT_FREETYPE_LOCK_HELD();
2710
2711 error = FT_Get_Glyph(GlyphSlot, &GlyphCopy);
2712 if (error)
2713 {
2714 DPRINT1("Failure caching glyph.\n");
2715 return NULL;
2716 };
2717
2718 error = FT_Glyph_To_Bitmap(&GlyphCopy, RenderMode, 0, 1);
2719 if (error)
2720 {
2721 FT_Done_Glyph(GlyphCopy);
2722 DPRINT1("Failure rendering glyph.\n");
2723 return NULL;
2724 };
2725
2726 NewEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_CACHE_ENTRY), TAG_FONT);
2727 if (!NewEntry)
2728 {
2729 DPRINT1("Alloc failure caching glyph.\n");
2730 FT_Done_Glyph(GlyphCopy);
2731 return NULL;
2732 }
2733
2734 BitmapGlyph = (FT_BitmapGlyph)GlyphCopy;
2735 FT_Bitmap_New(&AlignedBitmap);
2736 if(FT_Bitmap_Convert(GlyphSlot->library, &BitmapGlyph->bitmap, &AlignedBitmap, 4))
2737 {
2738 DPRINT1("Conversion failed\n");
2739 ExFreePoolWithTag(NewEntry, TAG_FONT);
2740 FT_Bitmap_Done(GlyphSlot->library, &AlignedBitmap);
2741 FT_Done_Glyph((FT_Glyph)BitmapGlyph);
2742 return NULL;
2743 }
2744
2745 FT_Bitmap_Done(GlyphSlot->library, &BitmapGlyph->bitmap);
2746 BitmapGlyph->bitmap = AlignedBitmap;
2747
2748 NewEntry->GlyphIndex = GlyphIndex;
2749 NewEntry->Face = Face;
2750 NewEntry->BitmapGlyph = BitmapGlyph;
2751 NewEntry->Height = Height;
2752 NewEntry->RenderMode = RenderMode;
2753 NewEntry->mxWorldToDevice = *pmx;
2754
2755 InsertHeadList(&FontCacheListHead, &NewEntry->ListEntry);
2756 if (++FontCacheNumEntries > MAX_FONT_CACHE)
2757 {
2758 NewEntry = CONTAINING_RECORD(FontCacheListHead.Blink, FONT_CACHE_ENTRY, ListEntry);
2759 RemoveCachedEntry(NewEntry);
2760 }
2761
2762 return BitmapGlyph;
2763 }
2764
2765
2766 static void FTVectorToPOINTFX(FT_Vector *vec, POINTFX *pt)
2767 {
2768 pt->x.value = vec->x >> 6;
2769 pt->x.fract = (vec->x & 0x3f) << 10;
2770 pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
2771 pt->y.value = vec->y >> 6;
2772 pt->y.fract = (vec->y & 0x3f) << 10;
2773 pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
2774 }
2775
2776 /*
2777 This function builds an FT_Fixed from a float. It puts the integer part
2778 in the highest 16 bits and the decimal part in the lowest 16 bits of the FT_Fixed.
2779 It fails if the integer part of the float number is greater than SHORT_MAX.
2780 */
2781 static __inline FT_Fixed FT_FixedFromFloat(float f)
2782 {
2783 short value = f;
2784 unsigned short fract = (f - value) * 0xFFFF;
2785 return (FT_Fixed)((long)value << 16 | (unsigned long)fract);
2786 }
2787
2788 /*
2789 This function builds an FT_Fixed from a FIXED. It simply put f.value
2790 in the highest 16 bits and f.fract in the lowest 16 bits of the FT_Fixed.
2791 */
2792 static __inline FT_Fixed FT_FixedFromFIXED(FIXED f)
2793 {
2794 return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
2795 }
2796
2797 static unsigned int get_native_glyph_outline(FT_Outline *outline, unsigned int buflen, char *buf)
2798 {
2799 TTPOLYGONHEADER *pph;
2800 TTPOLYCURVE *ppc;
2801 int needed = 0, point = 0, contour, first_pt;
2802 unsigned int pph_start, cpfx;
2803 DWORD type;
2804
2805 for (contour = 0; contour < outline->n_contours; contour++)
2806 {
2807 /* Ignore contours containing one point */
2808 if (point == outline->contours[contour])
2809 {
2810 point++;
2811 continue;
2812 }
2813
2814 pph_start = needed;
2815 pph = (TTPOLYGONHEADER *)(buf + needed);
2816 first_pt = point;
2817 if (buf)
2818 {
2819 pph->dwType = TT_POLYGON_TYPE;
2820 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
2821 }
2822 needed += sizeof(*pph);
2823 point++;
2824 while (point <= outline->contours[contour])
2825 {
2826 ppc = (TTPOLYCURVE *)(buf + needed);
2827 type = outline->tags[point] & FT_Curve_Tag_On ?
2828 TT_PRIM_LINE : TT_PRIM_QSPLINE;
2829 cpfx = 0;
2830 do
2831 {
2832 if (buf)
2833 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
2834 cpfx++;
2835 point++;
2836 } while (point <= outline->contours[contour] &&
2837 (outline->tags[point] & FT_Curve_Tag_On) ==
2838 (outline->tags[point-1] & FT_Curve_Tag_On));
2839 /* At the end of a contour Windows adds the start point, but
2840 only for Beziers */
2841 if (point > outline->contours[contour] &&
2842 !(outline->tags[point-1] & FT_Curve_Tag_On))
2843 {
2844 if (buf)
2845 FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
2846 cpfx++;
2847 }
2848 else if (point <= outline->contours[contour] &&
2849 outline->tags[point] & FT_Curve_Tag_On)
2850 {
2851 /* add closing pt for bezier */
2852 if (buf)
2853 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
2854 cpfx++;
2855 point++;
2856 }
2857 if (buf)
2858 {
2859 ppc->wType = type;
2860 ppc->cpfx = cpfx;
2861 }
2862 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
2863 }
2864 if (buf)
2865 pph->cb = needed - pph_start;
2866 }
2867 return needed;
2868 }
2869
2870 static unsigned int get_bezier_glyph_outline(FT_Outline *outline, unsigned int buflen, char *buf)
2871 {
2872 /* Convert the quadratic Beziers to cubic Beziers.
2873 The parametric eqn for a cubic Bezier is, from PLRM:
2874 r(t) = at^3 + bt^2 + ct + r0
2875 with the control points:
2876 r1 = r0 + c/3
2877 r2 = r1 + (c + b)/3
2878 r3 = r0 + c + b + a
2879
2880 A quadratic Bezier has the form:
2881 p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
2882
2883 So equating powers of t leads to:
2884 r1 = 2/3 p1 + 1/3 p0
2885 r2 = 2/3 p1 + 1/3 p2
2886 and of course r0 = p0, r3 = p2
2887 */
2888 int contour, point = 0, first_pt;
2889 TTPOLYGONHEADER *pph;
2890 TTPOLYCURVE *ppc;
2891 DWORD pph_start, cpfx, type;
2892 FT_Vector cubic_control[4];
2893 unsigned int needed = 0;
2894
2895 for (contour = 0; contour < outline->n_contours; contour++)
2896 {
2897 pph_start = needed;
2898 pph = (TTPOLYGONHEADER *)(buf + needed);
2899 first_pt = point;
2900 if (buf)
2901 {
2902 pph->dwType = TT_POLYGON_TYPE;
2903 FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
2904 }
2905 needed += sizeof(*pph);
2906 point++;
2907 while (point <= outline->contours[contour])
2908 {
2909 ppc = (TTPOLYCURVE *)(buf + needed);
2910 type = outline->tags[point] & FT_Curve_Tag_On ?
2911 TT_PRIM_LINE : TT_PRIM_CSPLINE;
2912 cpfx = 0;
2913 do
2914 {
2915 if (type == TT_PRIM_LINE)
2916 {
2917 if (buf)
2918 FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
2919 cpfx++;
2920 point++;
2921 }
2922 else
2923 {
2924 /* Unlike QSPLINEs, CSPLINEs always have their endpoint
2925 so cpfx = 3n */
2926
2927 /* FIXME: Possible optimization in endpoint calculation
2928 if there are two consecutive curves */
2929 cubic_control[0] = outline->points[point-1];
2930 if (!(outline->tags[point-1] & FT_Curve_Tag_On))
2931 {
2932 cubic_control[0].x += outline->points[point].x + 1;
2933 cubic_control[0].y += outline->points[point].y + 1;
2934 cubic_control[0].x >>= 1;
2935 cubic_control[0].y >>= 1;
2936 }
2937 if (point+1 > outline->contours[contour])
2938 cubic_control[3] = outline->points[first_pt];
2939 else
2940 {
2941 cubic_control[3] = outline->points[point+1];
2942 if (!(outline->tags[point+1] & FT_Curve_Tag_On))
2943 {
2944 cubic_control[3].x += outline->points[point].x + 1;
2945 cubic_control[3].y += outline->points[point].y + 1;
2946 cubic_control[3].x >>= 1;
2947 cubic_control[3].y >>= 1;
2948 }
2949 }
2950 /* r1 = 1/3 p0 + 2/3 p1
2951 r2 = 1/3 p2 + 2/3 p1 */
2952 cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
2953 cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
2954 cubic_control[2] = cubic_control[1];
2955 cubic_control[1].x += (cubic_control[0].x + 1) / 3;
2956 cubic_control[1].y += (cubic_control[0].y + 1) / 3;
2957 cubic_control[2].x += (cubic_control[3].x + 1) / 3;
2958 cubic_control[2].y += (cubic_control[3].y + 1) / 3;
2959 if (buf)
2960 {
2961 FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
2962 FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
2963 FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
2964 }
2965 cpfx += 3;
2966 point++;
2967 }
2968 } while (point <= outline->contours[contour] &&
2969 (outline->tags[point] & FT_Curve_Tag_On) ==
2970 (outline->tags[point-1] & FT_Curve_Tag_On));
2971 /* At the end of a contour Windows adds the start point,
2972 but only for Beziers and we've already done that.
2973 */
2974 if (point <= outline->contours[contour] &&
2975 outline->tags[point] & FT_Curve_Tag_On)
2976 {
2977 /* This is the closing pt of a bezier, but we've already
2978 added it, so just inc point and carry on */
2979 point++;
2980 }
2981 if (buf)
2982 {
2983 ppc->wType = type;
2984 ppc->cpfx = cpfx;
2985 }
2986 needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
2987 }
2988 if (buf)
2989 pph->cb = needed - pph_start;
2990 }
2991 return needed;
2992 }
2993
2994 static INT
2995 IntRequestFontSize(PDC dc, FT_Face face, LONG Width, LONG Height)
2996 {
2997 FT_Size_RequestRec req;
2998
2999 if (Width < 0)
3000 Width = -Width;
3001
3002 if (Height < 0)
3003 {
3004 Height = -Height;
3005 }
3006 if (Height == 0)
3007 {
3008 Height = dc->ppdev->devinfo.lfDefaultFont.lfHeight;
3009 }
3010 if (Height == 0)
3011 {
3012 Height = Width;
3013 }
3014
3015 if (Height < 1)
3016 Height = 1;
3017
3018 if (Width > 0xFFFFU)
3019 Width = 0xFFFFU;
3020 if (Height > 0xFFFFU)
3021 Height = 0xFFFFU;
3022
3023 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
3024 req.width = (FT_Long)(Width << 6);
3025 req.height = (FT_Long)(Height << 6);
3026 req.horiResolution = 0;
3027 req.vertResolution = 0;
3028 return FT_Request_Size(face, &req);
3029 }
3030
3031 BOOL
3032 FASTCALL
3033 TextIntUpdateSize(PDC dc,
3034 PTEXTOBJ TextObj,
3035 PFONTGDI FontGDI,
3036 BOOL bDoLock)
3037 {
3038 FT_Face face;
3039 INT error, n;
3040 FT_CharMap charmap, found;
3041 LOGFONTW *plf;
3042
3043 if (bDoLock)
3044 IntLockFreeType;
3045
3046 face = FontGDI->SharedFace->Face;
3047 if (face->charmap == NULL)
3048 {
3049 DPRINT("WARNING: No charmap selected!\n");
3050 DPRINT("This font face has %d charmaps\n", face->num_charmaps);
3051
3052 found = NULL;
3053 for (n = 0; n < face->num_charmaps; n++)
3054 {
3055 charmap = face->charmaps[n];
3056 DPRINT("Found charmap encoding: %i\n", charmap->encoding);
3057 if (charmap->encoding != 0)
3058 {
3059 found = charmap;
3060 break;
3061 }
3062 }
3063 if (!found)
3064 {
3065 DPRINT1("WARNING: Could not find desired charmap!\n");
3066 }
3067 else
3068 {
3069 error = FT_Set_Charmap(face, found);
3070 if (error)
3071 {
3072 DPRINT1("WARNING: Could not set the charmap!\n");
3073 }
3074 }
3075 }
3076
3077 plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
3078
3079 error = IntRequestFontSize(dc, face, plf->lfWidth, plf->lfHeight);
3080
3081 if (bDoLock)
3082 IntUnLockFreeType;
3083
3084 if (error)
3085 {
3086 DPRINT1("Error in setting pixel sizes: %d\n", error);
3087 return FALSE;
3088 }
3089
3090 return TRUE;
3091 }
3092
3093
3094 /*
3095 * Based on WineEngGetGlyphOutline
3096 *
3097 */
3098 ULONG
3099 FASTCALL
3100 ftGdiGetGlyphOutline(
3101 PDC dc,
3102 WCHAR wch,
3103 UINT iFormat,
3104 LPGLYPHMETRICS pgm,
3105 ULONG cjBuf,
3106 PVOID pvBuf,
3107 LPMAT2 pmat2,
3108 BOOL bIgnoreRotation)
3109 {
3110 static const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)};
3111 PDC_ATTR pdcattr;
3112 PTEXTOBJ TextObj;
3113 PFONTGDI FontGDI;
3114 HFONT hFont = 0;
3115 GLYPHMETRICS gm;
3116 ULONG Size;
3117 FT_Face ft_face;
3118 FT_UInt glyph_index;
3119 DWORD width, height, pitch, needed = 0;
3120 FT_Bitmap ft_bitmap;
3121 FT_Error error;
3122 INT left, right, top = 0, bottom = 0;
3123 FT_Angle angle = 0;
3124 FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
3125 FLOAT eM11, widthRatio = 1.0;
3126 FT_Matrix transMat = identityMat;
3127 BOOL needsTransform = FALSE;
3128 INT orientation;
3129 LONG aveWidth;
3130 INT adv, lsb, bbx; /* These three hold to widths of the unrotated chars */
3131 OUTLINETEXTMETRICW *potm;
3132 XFORM xForm;
3133 LOGFONTW *plf;
3134
3135 DPRINT("%u, %08x, %p, %08lx, %p, %p\n", wch, iFormat, pgm,
3136 cjBuf, pvBuf, pmat2);
3137
3138 pdcattr = dc->pdcattr;
3139
3140 MatrixS2XForm(&xForm, &dc->pdcattr->mxWorldToDevice);
3141 eM11 = xForm.eM11;
3142
3143 hFont = pdcattr->hlfntNew;
3144 TextObj = RealizeFontInit(hFont);
3145
3146 if (!TextObj)
3147 {
3148 EngSetLastError(ERROR_INVALID_HANDLE);
3149 return GDI_ERROR;
3150 }
3151 FontGDI = ObjToGDI(TextObj->Font, FONT);
3152 ft_face = FontGDI->SharedFace->Face;
3153
3154 plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
3155 aveWidth = FT_IS_SCALABLE(ft_face) ? abs(plf->lfWidth) : 0;
3156 orientation = FT_IS_SCALABLE(ft_face) ? plf->lfOrientation : 0;
3157
3158 Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL);
3159 potm = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
3160 if (!potm)
3161 {
3162 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
3163 TEXTOBJ_UnlockText(TextObj);
3164 return GDI_ERROR;
3165 }
3166 Size = IntGetOutlineTextMetrics(FontGDI, Size, potm);
3167 if (!Size)
3168 {
3169 /* FIXME: last error? */
3170 ExFreePoolWithTag(potm, GDITAG_TEXT);
3171 TEXTOBJ_UnlockText(TextObj);
3172 return GDI_ERROR;
3173 }
3174
3175 IntLockFreeType;
3176 TextIntUpdateSize(dc, TextObj, FontGDI, FALSE);
3177 FtSetCoordinateTransform(ft_face, DC_pmxWorldToDevice(dc));
3178
3179 TEXTOBJ_UnlockText(TextObj);
3180
3181 if (iFormat & GGO_GLYPH_INDEX)
3182 {
3183 glyph_index = wch;
3184 iFormat &= ~GGO_GLYPH_INDEX;
3185 }
3186 else glyph_index = FT_Get_Char_Index(ft_face, wch);
3187
3188 if (orientation || (iFormat != GGO_METRICS && iFormat != GGO_BITMAP) || aveWidth || pmat2)
3189 load_flags |= FT_LOAD_NO_BITMAP;
3190
3191 if (iFormat & GGO_UNHINTED)
3192 {
3193 load_flags |= FT_LOAD_NO_HINTING;
3194 iFormat &= ~GGO_UNHINTED;
3195 }
3196
3197 error = FT_Load_Glyph(ft_face, glyph_index, load_flags);
3198 if (error)
3199 {
3200 DPRINT1("WARNING: Failed to load and render glyph! [index: %u]\n", glyph_index);
3201 IntUnLockFreeType;
3202 if (potm) ExFreePoolWithTag(potm, GDITAG_TEXT);
3203 return GDI_ERROR;
3204 }
3205 IntUnLockFreeType;
3206
3207 if (aveWidth && potm)
3208 {
3209 widthRatio = (FLOAT)aveWidth * eM11 /
3210 (FLOAT) potm->otmTextMetrics.tmAveCharWidth;
3211 }
3212
3213 left = (INT)(ft_face->glyph->metrics.horiBearingX * widthRatio) & -64;
3214 right = (INT)((ft_face->glyph->metrics.horiBearingX +
3215 ft_face->glyph->metrics.width) * widthRatio + 63) & -64;
3216
3217 adv = (INT)((ft_face->glyph->metrics.horiAdvance * widthRatio) + 63) >> 6;
3218 lsb = left >> 6;
3219 bbx = (right - left) >> 6;
3220
3221 DPRINT("Advance = %d, lsb = %d, bbx = %d\n",adv, lsb, bbx);
3222
3223 IntLockFreeType;
3224
3225 /* Scaling transform */
3226 /*if (aveWidth)*/
3227 {
3228
3229 FT_Matrix ftmatrix;
3230 FLOATOBJ efTemp;
3231
3232 PMATRIX pmx = DC_pmxWorldToDevice(dc);
3233
3234 /* Create a freetype matrix, by converting to 16.16 fixpoint format */
3235 efTemp = pmx->efM11;
3236 FLOATOBJ_MulLong(&efTemp, 0x00010000);
3237 ftmatrix.xx = FLOATOBJ_GetLong(&efTemp);
3238
3239 efTemp = pmx->efM12;
3240 FLOATOBJ_MulLong(&efTemp, 0x00010000);
3241 ftmatrix.xy = FLOATOBJ_GetLong(&efTemp);
3242
3243 efTemp = pmx->efM21;
3244 FLOATOBJ_MulLong(&efTemp, 0x00010000);
3245 ftmatrix.yx = FLOATOBJ_GetLong(&efTemp);
3246
3247 efTemp = pmx->efM22;
3248 FLOATOBJ_MulLong(&efTemp, 0x00010000);
3249 ftmatrix.yy = FLOATOBJ_GetLong(&efTemp);
3250
3251 FT_Matrix_Multiply(&ftmatrix, &transMat);
3252 needsTransform = TRUE;
3253 }
3254
3255 /* Rotation transform */
3256 if (orientation)
3257 {
3258 FT_Matrix rotationMat;
3259 FT_Vector vecAngle;
3260 DPRINT("Rotation Trans!\n");
3261 angle = FT_FixedFromFloat((float)orientation / 10.0);
3262 FT_Vector_Unit(&vecAngle, angle);
3263 rotationMat.xx = vecAngle.x;
3264 rotationMat.xy = -vecAngle.y;
3265 rotationMat.yx = -rotationMat.xy;
3266 rotationMat.yy = rotationMat.xx;
3267 FT_Matrix_Multiply(&rotationMat, &transMat);
3268 needsTransform = TRUE;
3269 }
3270
3271 /* Extra transformation specified by caller */
3272 if (pmat2)
3273 {
3274 FT_Matrix extraMat;
3275 DPRINT("MAT2 Matrix Trans!\n");
3276 extraMat.xx = FT_FixedFromFIXED(pmat2->eM11);
3277 extraMat.xy = FT_FixedFromFIXED(pmat2->eM21);
3278 extraMat.yx = FT_FixedFromFIXED(pmat2->eM12);
3279 extraMat.yy = FT_FixedFromFIXED(pmat2->eM22);
3280 FT_Matrix_Multiply(&extraMat, &transMat);
3281 needsTransform = TRUE;
3282 }
3283
3284 if (potm) ExFreePoolWithTag(potm, GDITAG_TEXT); /* It looks like we are finished with potm ATM. */
3285
3286 if (!needsTransform)
3287 {
3288 DPRINT("No Need to be Transformed!\n");
3289 top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
3290 bottom = (ft_face->glyph->metrics.horiBearingY -
3291 ft_face->glyph->metrics.height) & -64;
3292 gm.gmCellIncX = adv;
3293 gm.gmCellIncY = 0;
3294 }
3295 else
3296 {
3297 INT xc, yc;
3298 FT_Vector vec;
3299 for (xc = 0; xc < 2; xc++)
3300 {
3301 for (yc = 0; yc < 2; yc++)
3302 {
3303 vec.x = (ft_face->glyph->metrics.horiBearingX +
3304 xc * ft_face->glyph->metrics.width);
3305 vec.y = ft_face->glyph->metrics.horiBearingY -
3306 yc * ft_face->glyph->metrics.height;
3307 DPRINT("Vec %ld,%ld\n", vec.x, vec.y);
3308 FT_Vector_Transform(&vec, &transMat);
3309 if (xc == 0 && yc == 0)
3310 {
3311 left = right = vec.x;
3312 top = bottom = vec.y;
3313 }
3314 else
3315 {
3316 if (vec.x < left) left = vec.x;
3317 else if (vec.x > right) right = vec.x;
3318 if (vec.y < bottom) bottom = vec.y;
3319 else if (vec.y > top) top = vec.y;
3320 }
3321 }
3322 }
3323 left = left & -64;
3324 right = (right + 63) & -64;
3325 bottom = bottom & -64;
3326 top = (top + 63) & -64;
3327
3328 DPRINT("Transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
3329 vec.x = ft_face->glyph->metrics.horiAdvance;
3330 vec.y = 0;
3331 FT_Vector_Transform(&vec, &transMat);
3332 gm.gmCellIncX = (vec.x+63) >> 6;
3333 gm.gmCellIncY = -((vec.y+63) >> 6);
3334 }
3335 gm.gmBlackBoxX = (right - left) >> 6;
3336 gm.gmBlackBoxY = (top - bottom) >> 6;
3337 gm.gmptGlyphOrigin.x = left >> 6;
3338 gm.gmptGlyphOrigin.y = top >> 6;
3339
3340 DPRINT("CX %d CY %d BBX %u BBY %u GOX %d GOY %d\n",
3341 gm.gmCellIncX, gm.gmCellIncY,
3342 gm.gmBlackBoxX, gm.gmBlackBoxY,
3343 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
3344
3345 IntUnLockFreeType;
3346
3347
3348 if (iFormat == GGO_METRICS)
3349 {
3350 DPRINT("GGO_METRICS Exit!\n");
3351 *pgm = gm;
3352 return 1; /* FIXME */
3353 }
3354
3355 if (ft_face->glyph->format != ft_glyph_format_outline && iFormat != GGO_BITMAP)
3356 {
3357 DPRINT1("Loaded a bitmap\n");
3358 return GDI_ERROR;
3359 }
3360
3361 switch (iFormat)
3362 {
3363 case GGO_BITMAP:
3364 width = gm.gmBlackBoxX;
3365 height = gm.gmBlackBoxY;
3366 pitch = ((width + 31) >> 5) << 2;
3367 needed = pitch * height;
3368
3369 if (!pvBuf || !cjBuf) break;
3370 if (!needed) return GDI_ERROR; /* empty glyph */
3371 if (needed > cjBuf)
3372 return GDI_ERROR;
3373
3374 switch (ft_face->glyph->format)
3375 {
3376 case ft_glyph_format_bitmap:
3377 {
3378 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = pvBuf;
3379 INT w = min( pitch, (ft_face->glyph->bitmap.width + 7) >> 3 );
3380 INT h = min( height, ft_face->glyph->bitmap.rows );
3381 while (h--)
3382 {
3383 RtlCopyMemory(dst, src, w);
3384 src += ft_face->glyph->bitmap.pitch;
3385 dst += pitch;
3386 }
3387 break;
3388 }
3389
3390 case ft_glyph_format_outline:
3391 ft_bitmap.width = width;
3392 ft_bitmap.rows = height;
3393 ft_bitmap.pitch = pitch;
3394 ft_bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
3395 ft_bitmap.buffer = pvBuf;
3396
3397 IntLockFreeType;
3398 if (needsTransform)
3399 {
3400 FT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3401 }
3402 FT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3403 /* Note: FreeType will only set 'black' bits for us. */
3404 RtlZeroMemory(pvBuf, needed);
3405 FT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3406 IntUnLockFreeType;
3407 break;
3408
3409 default:
3410 DPRINT1("Loaded glyph format %x\n", ft_face->glyph->format);
3411 return GDI_ERROR;
3412 }
3413 break;
3414
3415 case GGO_GRAY2_BITMAP:
3416 case GGO_GRAY4_BITMAP:
3417 case GGO_GRAY8_BITMAP:
3418 {
3419 unsigned int mult, row, col;
3420 BYTE *start, *ptr;
3421
3422 width = gm.gmBlackBoxX;
3423 height = gm.gmBlackBoxY;
3424 pitch = (width + 3) / 4 * 4;
3425 needed = pitch * height;
3426
3427 if (!pvBuf || !cjBuf) break;
3428 if (!needed) return GDI_ERROR; /* empty glyph */
3429 if (needed > cjBuf)
3430 return GDI_ERROR;
3431
3432 switch (ft_face->glyph->format)
3433 {
3434 case ft_glyph_format_bitmap:
3435 {
3436 BYTE *src = ft_face->glyph->bitmap.buffer, *dst = pvBuf;
3437 INT h = min( height, ft_face->glyph->bitmap.rows );
3438 INT x;
3439 while (h--)
3440 {
3441 for (x = 0; (UINT)x < pitch; x++)
3442 {
3443 if (x < ft_face->glyph->bitmap.width)
3444 dst[x] = (src[x / 8] & (1 << ( (7 - (x % 8))))) ? 0xff : 0;
3445 else
3446 dst[x] = 0;
3447 }
3448 src += ft_face->glyph->bitmap.pitch;
3449 dst += pitch;
3450 }
3451 break;
3452 }
3453 case ft_glyph_format_outline:
3454 {
3455 ft_bitmap.width = width;
3456 ft_bitmap.rows = height;
3457 ft_bitmap.pitch = pitch;
3458 ft_bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
3459 ft_bitmap.buffer = pvBuf;
3460
3461 IntLockFreeType;
3462 if (needsTransform)
3463 {
3464 FT_Outline_Transform(&ft_face->glyph->outline, &transMat);
3465 }
3466 FT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
3467 RtlZeroMemory(ft_bitmap.buffer, cjBuf);
3468 FT_Outline_Get_Bitmap(library, &ft_face->glyph->outline, &ft_bitmap);
3469 IntUnLockFreeType;
3470
3471 if (iFormat == GGO_GRAY2_BITMAP)
3472 mult = 4;
3473 else if (iFormat == GGO_GRAY4_BITMAP)
3474 mult = 16;
3475 else if (iFormat == GGO_GRAY8_BITMAP)
3476 mult = 64;
3477 else
3478 {
3479 return GDI_ERROR;
3480 }
3481
3482 start = pvBuf;
3483 for (row = 0; row < height; row++)
3484 {
3485 ptr = start;
3486 for (col = 0; col < width; col++, ptr++)
3487 {
3488 *ptr = (((int)*ptr) * mult + 128) / 256;
3489 }
3490 start += pitch;
3491 }
3492
3493 break;
3494 }
3495 default:
3496 DPRINT1("Loaded glyph format %x\n", ft_face->glyph->format);
3497 return GDI_ERROR;
3498 }
3499 }
3500
3501 case GGO_NATIVE:
3502 {
3503 FT_Outline *outline = &ft_face->glyph->outline;
3504
3505 if (cjBuf == 0) pvBuf = NULL; /* This is okay, need cjBuf to allocate. */
3506
3507 IntLockFreeType;
3508 if (needsTransform && pvBuf) FT_Outline_Transform(outline, &transMat);
3509
3510 needed = get_native_glyph_outline(outline, cjBuf, NULL);
3511
3512 if (!pvBuf || !cjBuf)
3513 {
3514 IntUnLockFreeType;
3515 break;
3516 }
3517 if (needed > cjBuf)
3518 {
3519 IntUnLockFreeType;
3520 return GDI_ERROR;
3521 }
3522 get_native_glyph_outline(outline, cjBuf, pvBuf);
3523 IntUnLockFreeType;
3524 break;
3525 }
3526 case GGO_BEZIER:
3527 {
3528 FT_Outline *outline = &ft_face->glyph->outline;
3529 if (cjBuf == 0) pvBuf = NULL;
3530
3531 if (needsTransform && pvBuf)
3532 {
3533 IntLockFreeType;
3534 FT_Outline_Transform(outline, &transMat);
3535 IntUnLockFreeType;
3536 }
3537 needed = get_bezier_glyph_outline(outline, cjBuf, NULL);
3538
3539 if (!pvBuf || !cjBuf)
3540 break;
3541 if (needed > cjBuf)
3542 return GDI_ERROR;
3543
3544 get_bezier_glyph_outline(outline, cjBuf, pvBuf);
3545 break;
3546 }
3547
3548 default:
3549 DPRINT1("Unsupported format %u\n", iFormat);
3550 return GDI_ERROR;
3551 }
3552
3553 DPRINT("ftGdiGetGlyphOutline END and needed %lu\n", needed);
3554 *pgm = gm;
3555 return needed;
3556 }
3557
3558 BOOL
3559 FASTCALL
3560 TextIntGetTextExtentPoint(PDC dc,
3561 PTEXTOBJ TextObj,
3562 LPCWSTR String,
3563 INT Count,
3564 ULONG MaxExtent,
3565 LPINT Fit,
3566 LPINT Dx,
3567 LPSIZE Size,
3568 FLONG fl)
3569 {
3570 PFONTGDI FontGDI;
3571 FT_Face face;
3572 FT_GlyphSlot glyph;
3573 FT_BitmapGlyph realglyph;
3574 INT error, glyph_index, i, previous;
3575 ULONGLONG TotalWidth = 0;
3576 BOOL use_kerning;
3577 FT_Render_Mode RenderMode;
3578 BOOLEAN Render;
3579 PMATRIX pmxWorldToDevice;
3580 LOGFONTW *plf;
3581 BOOL EmuBold, EmuItalic;
3582 LONG ascender, descender;
3583
3584 FontGDI = ObjToGDI(TextObj->Font, FONT);
3585
3586 face = FontGDI->SharedFace->Face;
3587 if (NULL != Fit)
3588 {
3589 *Fit = 0;
3590 }
3591
3592 IntLockFreeType;
3593
3594 TextIntUpdateSize(dc, TextObj, FontGDI, FALSE);
3595
3596 plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
3597 EmuBold = (plf->lfWeight >= FW_BOLD && FontGDI->OriginalWeight <= FW_NORMAL);
3598 EmuItalic = (plf->lfItalic && !FontGDI->OriginalItalic);
3599
3600 Render = IntIsFontRenderingEnabled();
3601 if (Render)
3602 RenderMode = IntGetFontRenderMode(plf);
3603 else
3604 RenderMode = FT_RENDER_MODE_MONO;
3605
3606 /* Get the DC's world-to-device transformation matrix */
3607 pmxWorldToDevice = DC_pmxWorldToDevice(dc);
3608 FtSetCoordinateTransform(face, pmxWorldToDevice);
3609
3610 use_kerning = FT_HAS_KERNING(face);
3611 previous = 0;
3612
3613 for (i = 0; i < Count; i++)
3614 {
3615 if (fl & GTEF_INDICES)
3616 glyph_index = *String;
3617 else
3618 glyph_index = FT_Get_Char_Index(face, *String);
3619
3620 if (EmuBold || EmuItalic)
3621 realglyph = NULL;
3622 else
3623 realglyph = ftGdiGlyphCacheGet(face, glyph_index, plf->lfHeight,
3624 RenderMode, pmxWorldToDevice);
3625
3626 if (EmuBold || EmuItalic || !realglyph)
3627 {
3628 error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
3629 if (error)
3630 {
3631 DPRINT1("WARNING: Failed to load and render glyph! [index: %d]\n", glyph_index);
3632 break;
3633 }
3634
3635 glyph = face->glyph;
3636 if (EmuBold || EmuItalic)
3637 {
3638 if (EmuBold)
3639 FT_GlyphSlot_Embolden(glyph);
3640 if (EmuItalic)
3641 FT_GlyphSlot_Oblique(glyph);
3642 realglyph = ftGdiGlyphSet(face, glyph, RenderMode);
3643 }
3644 else
3645 {
3646 realglyph = ftGdiGlyphCacheSet(face,
3647 glyph_index,
3648 plf->lfHeight,
3649 pmxWorldToDevice,
3650 glyph,
3651 RenderMode);
3652 }
3653
3654 if (!realglyph)
3655 {
3656 DPRINT1("Failed to render glyph! [index: %d]\n", glyph_index);
3657 break;
3658 }
3659 }
3660
3661 /* Retrieve kerning distance */
3662 if (use_kerning && previous && glyph_index)
3663 {
3664 FT_Vector delta;
3665 FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
3666 TotalWidth += delta.x;
3667 }
3668
3669 TotalWidth += realglyph->root.advance.x >> 10;
3670
3671 if (((TotalWidth + 32) >> 6) <= MaxExtent && NULL != Fit)
3672 {
3673 *Fit = i + 1;
3674 }
3675 if (NULL != Dx)
3676 {
3677 Dx[i] = (TotalWidth + 32) >> 6;
3678 }
3679
3680 if (EmuBold || EmuItalic)
3681 {
3682 FT_Done_Glyph((FT_Glyph)realglyph);
3683 realglyph = NULL;
3684 }
3685
3686 previous = glyph_index;
3687 String++;
3688 }
3689 ascender = (face->size->metrics.ascender + 32) >> 6; /* Units above baseline */
3690 descender = (32 - face->size->metrics.descender) >> 6; /* Units below baseline */
3691 IntUnLockFreeType;
3692
3693 Size->cx = (TotalWidth + 32) >> 6;
3694 Size->cy = ascender + descender;
3695
3696 return TRUE;
3697 }
3698
3699
3700 INT
3701 FASTCALL
3702 ftGdiGetTextCharsetInfo(
3703 PDC Dc,
3704 LPFONTSIGNATURE lpSig,
3705 DWORD dwFlags)
3706 {
3707 PDC_ATTR pdcattr;
3708 UINT Ret = DEFAULT_CHARSET;
3709 INT i;
3710 HFONT hFont;
3711 PTEXTOBJ TextObj;
3712 PFONTGDI FontGdi;
3713 FONTSIGNATURE fs;
3714 TT_OS2 *pOS2;
3715 FT_Face Face;
3716 CHARSETINFO csi;
3717 DWORD cp, fs0;
3718 USHORT usACP, usOEM;
3719
3720 pdcattr = Dc->pdcattr;
3721 hFont = pdcattr->hlfntNew;
3722 TextObj = RealizeFontInit(hFont);
3723
3724 if (!TextObj)
3725 {
3726 EngSetLastError(ERROR_INVALID_HANDLE);
3727 return Ret;
3728 }
3729 FontGd