ReactOS  0.4.13-dev-551-gf37fb1f
font.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS win32 kernel mode subsystem
3  * LICENSE: GPL - See COPYING in the top level directory
4  * FILE: win32ss/gdi/ntgdi/font.c
5  * PURPOSE: Font
6  * PROGRAMMERS: James Tabor <james.tabor@reactos.org>
7  * Timo Kreuzer <timo.kreuzer@reactos.org>
8  * Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
9  */
10 
13 #include <win32k.h>
14 
15 #define NDEBUG
16 #include <debug.h>
17 
19 
24 {
25  if (lplf)
26  {
27  ENUMLOGFONTEXDVW Logfont;
28 
29  RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW));
31  sizeof(Logfont.elfEnumLogfontEx.elfFullName));
33  sizeof(Logfont.elfEnumLogfontEx.elfStyle));
35  sizeof(Logfont.elfEnumLogfontEx.elfScript));
36 
37  Logfont.elfDesignVector.dvNumAxes = 0;
38 
39  RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
40 
41  return HfontCreate((PENUMLOGFONTEXDVW)&Logfont, 0, 0, 0, NULL );
42  }
43  else return NULL;
44 }
45 
46 DWORD
49  HDC hDC,
50  ULONG NumPairs,
51  LPKERNINGPAIR krnpair)
52 {
53  PDC dc;
54  PDC_ATTR pdcattr;
55  PTEXTOBJ TextObj;
56  PFONTGDI FontGDI;
57  DWORD Count;
58  KERNINGPAIR *pKP;
59 
60  dc = DC_LockDc(hDC);
61  if (!dc)
62  {
64  return 0;
65  }
66 
67  pdcattr = dc->pdcattr;
68  TextObj = RealizeFontInit(pdcattr->hlfntNew);
69  DC_UnlockDc(dc);
70 
71  if (!TextObj)
72  {
74  return 0;
75  }
76 
77  FontGDI = ObjToGDI(TextObj->Font, FONT);
78  TEXTOBJ_UnlockText(TextObj);
79 
80  Count = ftGdiGetKerningPairs(FontGDI,0,NULL);
81 
82  if ( Count && krnpair )
83  {
84  if (Count > NumPairs)
85  {
87  return 0;
88  }
90  if (!pKP)
91  {
93  return 0;
94  }
95  ftGdiGetKerningPairs(FontGDI,Count,pKP);
96 
97  RtlCopyMemory(krnpair, pKP, Count * sizeof(KERNINGPAIR));
98 
100  }
101  return Count;
102 }
103 
104 /*
105 
106  It is recommended that an application use the GetFontLanguageInfo function
107  to determine whether the GCP_DIACRITIC, GCP_DBCS, GCP_USEKERNING, GCP_LIGATE,
108  GCP_REORDER, GCP_GLYPHSHAPE, and GCP_KASHIDA values are valid for the
109  currently selected font. If not valid, GetCharacterPlacement ignores the
110  value.
111 
112  MS must use a preset "compiled in" support for each language based releases.
113  ReactOS uses FreeType, this will need to be supported. ATM this is hard coded
114  for GCPCLASS_LATIN!
115 
116  */
117 #if 0
118 DWORD
119 FASTCALL
120 GreGetCharacterPlacementW(
121  HDC hdc,
122  LPCWSTR pwsz,
123  INT nCount,
124  INT nMaxExtent,
125  LPGCP_RESULTSW pgcpw,
126  DWORD dwFlags)
127 {
128  GCP_RESULTSW gcpwSave;
129  UINT i, nSet, cSet;
130  INT *tmpDxCaretPos;
131  LONG Cx;
132  SIZE Size = {0,0};
133 
134  DPRINT1("GreGCPW Start\n");
135 
136  if (!pgcpw)
137  {
138  if (GreGetTextExtentW( hdc, pwsz, nCount, &Size, 1))
139  return MAKELONG(Size.cx, Size.cy);
140  return 0;
141  }
142 
143  DPRINT1("GreGCPW 1\n");
144 
145  RtlCopyMemory(&gcpwSave, pgcpw, sizeof(GCP_RESULTSW));
146 
147  cSet = nSet = nCount;
148 
149  if ( nCount > gcpwSave.nGlyphs ) cSet = gcpwSave.nGlyphs;
150 
151  /* GCP_JUSTIFY may only be used in conjunction with GCP_MAXEXTENT. */
153 
154  if ( !gcpwSave.lpDx && gcpwSave.lpCaretPos )
155  tmpDxCaretPos = gcpwSave.lpCaretPos;
156  else
157  tmpDxCaretPos = gcpwSave.lpDx;
158 
159  if ( !GreGetTextExtentExW( hdc,
160  pwsz,
161  cSet,
162  nMaxExtent,
163  ((dwFlags & GCP_MAXEXTENT) ? (PULONG) &cSet : NULL),
164  (PULONG) tmpDxCaretPos,
165  &Size,
166  0) )
167  {
168  return 0;
169  }
170 
171  DPRINT1("GreGCPW 2\n");
172 
173  nSet = cSet;
174 
175  if ( tmpDxCaretPos && nSet > 0)
176  {
177  for (i = (nSet - 1); i > 0; i--)
178  {
179  tmpDxCaretPos[i] -= tmpDxCaretPos[i - 1];
180  }
181  }
182 
183  if ( !(dwFlags & GCP_MAXEXTENT) || nSet )
184  {
185  if ( (dwFlags & GCP_USEKERNING) &&
186  ( gcpwSave.lpDx ||
187  gcpwSave.lpCaretPos ) &&
188  nSet >= 2 )
189  {
190  DWORD Count;
191  LPKERNINGPAIR pKP;
192 
194  if (Count)
195  {
197  if (pKP)
198  {
199  if ( GreGetKerningPairs( hdc, Count, pKP) != Count)
200  {
202  return 0;
203  }
204 
205  if ( (ULONG_PTR)(pKP) < ((ULONG_PTR)(pKP) + (ULONG_PTR)(Count * sizeof(KERNINGPAIR))) )
206  {
207  DPRINT1("We Need to Do Something HERE!\n");
208  }
209 
211 
212  if ( dwFlags & GCP_MAXEXTENT )
213  {
214  if ( Size.cx > nMaxExtent )
215  {
216  for (Cx = Size.cx; nSet > 0; nSet--)
217  {
218  Cx -= tmpDxCaretPos[nSet - 1];
219  Size.cx = Cx;
220  if ( Cx <= nMaxExtent ) break;
221  }
222  }
223  if ( !nSet )
224  {
225  pgcpw->nGlyphs = 0;
226  pgcpw->nMaxFit = 0;
227  return 0;
228  }
229  }
230  }
231  }
232  }
233 
234  if ( (dwFlags & GCP_JUSTIFY) &&
235  ( gcpwSave.lpDx ||
236  gcpwSave.lpCaretPos ) &&
237  nSet )
238  {
239  DPRINT1("We Need to Do Something HERE 2!\n");
240  }
241 
242  if ( gcpwSave.lpDx && gcpwSave.lpCaretPos )
243  RtlCopyMemory( gcpwSave.lpCaretPos, gcpwSave.lpDx, nSet * sizeof(LONG));
244 
245  if ( gcpwSave.lpCaretPos )
246  {
247  int pos = 0;
248  i = 0;
249  if ( nSet > 0 )
250  {
251  do
252  {
253  Cx = gcpwSave.lpCaretPos[i];
254  gcpwSave.lpCaretPos[i] = pos;
255  pos += Cx;
256  ++i;
257  }
258  while ( i < nSet );
259  }
260  }
261 
262  if ( gcpwSave.lpOutString )
263  RtlCopyMemory(gcpwSave.lpOutString, pwsz, nSet * sizeof(WCHAR));
264 
265  if ( gcpwSave.lpClass )
266  RtlFillMemory(gcpwSave.lpClass, nSet, GCPCLASS_LATIN);
267 
268  if ( gcpwSave.lpOrder )
269  {
270  for (i = 0; i < nSet; i++)
271  gcpwSave.lpOrder[i] = i;
272  }
273 
274  if ( gcpwSave.lpGlyphs )
275  {
276  if ( GreGetGlyphIndicesW( hdc, pwsz, nSet, gcpwSave.lpGlyphs, 0, 0) == GDI_ERROR )
277  {
278  nSet = 0;
279  Size.cx = 0;
280  Size.cy = 0;
281  }
282  }
283  pgcpw->nGlyphs = nSet;
284  pgcpw->nMaxFit = nSet;
285  }
286  DPRINT1("GreGCPW Exit\n");
287  return MAKELONG(Size.cx, Size.cy);
288 }
289 #endif
290 
291 ULONG
292 FASTCALL
294 {
295  ULONG cjMaxSize;
296  ENUMLOGFONTEXDVW *plf;
297 
298  ASSERT(plfont);
299  plf = &plfont->logfont;
300 
301  if (!(plfont->fl & TEXTOBJECT_INIT))
302  {
304  DPRINT1("FontGetObject font not initialized!\n");
305 
306  Status = TextIntRealizeFont(plfont->BaseObject.hHmgr, plfont);
307  if (!NT_SUCCESS(Status))
308  {
309  DPRINT1("FontGetObject(TextIntRealizeFont) Status = 0x%lx\n", Status);
310  }
311  }
312 
313  /* If buffer is NULL, only the size is requested */
314  if (pvBuffer == NULL) return sizeof(LOGFONTW);
315 
316  /* Calculate the maximum size according to number of axes */
317  cjMaxSize = FIELD_OFFSET(ENUMLOGFONTEXDVW,
318  elfDesignVector.dvValues[plf->elfDesignVector.dvNumAxes]);
319 
320  if (cjBuffer > cjMaxSize) cjBuffer = cjMaxSize;
321 
322  RtlCopyMemory(pvBuffer, plf, cjBuffer);
323 
324  return cjBuffer;
325 }
326 
327 DWORD
328 FASTCALL
330 {
331  PDC pdc;
332  PDC_ATTR pdcattr;
333  PTEXTOBJ TextObj;
334  SIZE sz;
335  TMW_INTERNAL tmwi;
336  BOOL Good;
337 
338  static const WCHAR alphabet[] = {
339  'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
340  'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
341  'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
342 
343  if(!ftGdiGetTextMetricsW(hdc, &tmwi)) return 0;
344 
345  pdc = DC_LockDc(hdc);
346 
347  if (!pdc) return 0;
348 
349  pdcattr = pdc->pdcattr;
350 
351  TextObj = RealizeFontInit(pdcattr->hlfntNew);
352  if ( !TextObj )
353  {
354  DC_UnlockDc(pdc);
355  return 0;
356  }
357  Good = TextIntGetTextExtentPoint(pdc, TextObj, alphabet, 52, 0, NULL, 0, &sz, 0);
358  TEXTOBJ_UnlockText(TextObj);
359  DC_UnlockDc(pdc);
360 
361  if (!Good) return 0;
362  if (ptm) *ptm = tmwi.TextMetric;
363  if (height) *height = tmwi.TextMetric.tmHeight;
364 
365  return (sz.cx / 26 + 1) / 2;
366 }
367 
368 
369 DWORD
370 FASTCALL
372 {
373  PDC_ATTR pdcattr;
374  FONTSIGNATURE fontsig;
375  static const DWORD GCP_DBCS_MASK=0x003F0000,
376  GCP_DIACRITIC_MASK=0x00000000,
377  FLI_GLYPHS_MASK=0x00000000,
378  GCP_GLYPHSHAPE_MASK=0x00000040,
379  GCP_KASHIDA_MASK=0x00000000,
380  GCP_LIGATE_MASK=0x00000000,
381  GCP_USEKERNING_MASK=0x00000000,
382  GCP_REORDER_MASK=0x00000060;
383 
384  DWORD result=0;
385 
386  ftGdiGetTextCharsetInfo( Dc, &fontsig, 0 );
387 
388  /* We detect each flag we return using a bitmask on the Codepage Bitfields */
389  if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
390  result|=GCP_DBCS;
391 
392  if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
394 
395  if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
397 
398  if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
400 
401  if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
403 
404  if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
406 
407  if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
409 
410  pdcattr = Dc->pdcattr;
411 
412  /* This might need a test for a HEBREW- or ARABIC_CHARSET as well */
413  if ( pdcattr->flTextAlign & TA_RTLREADING )
414  if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
416 
417  return result;
418 }
419 
420 PTEXTOBJ
421 FASTCALL
423 {
425  PTEXTOBJ pTextObj;
426 
427  pTextObj = TEXTOBJ_LockText(hFont);
428 
429  if ( pTextObj && !(pTextObj->fl & TEXTOBJECT_INIT))
430  {
431  Status = TextIntRealizeFont(hFont, pTextObj);
432  if (!NT_SUCCESS(Status))
433  {
434  TEXTOBJ_UnlockText(pTextObj);
435  return NULL;
436  }
437  }
438  return pTextObj;
439 }
440 
441 
444 INT
445 APIENTRY
447  IN WCHAR *pwcFiles,
448  IN ULONG cwc,
449  IN ULONG cFiles,
450  IN FLONG fl,
451  IN DWORD dwPidTid,
453 {
454  UNICODE_STRING SafeFileName;
455  INT Ret;
456 
458  DBG_UNREFERENCED_PARAMETER(dwPidTid);
460 
461  DPRINT("NtGdiAddFontResourceW\n");
462 
463  /* cwc = Length + trailing zero. */
464  if ((cwc <= 1) || (cwc > UNICODE_STRING_MAX_CHARS))
465  return 0;
466 
467  SafeFileName.MaximumLength = (USHORT)(cwc * sizeof(WCHAR));
468  SafeFileName.Length = SafeFileName.MaximumLength - sizeof(UNICODE_NULL);
469  SafeFileName.Buffer = ExAllocatePoolWithTag(PagedPool,
470  SafeFileName.MaximumLength,
471  TAG_STRING);
472  if (!SafeFileName.Buffer)
473  {
474  return 0;
475  }
476 
477  _SEH2_TRY
478  {
479  ProbeForRead(pwcFiles, cwc * sizeof(WCHAR), sizeof(WCHAR));
480  RtlCopyMemory(SafeFileName.Buffer, pwcFiles, SafeFileName.Length);
481  }
483  {
484  ExFreePoolWithTag(SafeFileName.Buffer, TAG_STRING);
485  _SEH2_YIELD(return 0);
486  }
487  _SEH2_END;
488 
489  SafeFileName.Buffer[SafeFileName.Length / sizeof(WCHAR)] = UNICODE_NULL;
490  Ret = IntGdiAddFontResource(&SafeFileName, fl);
491 
492  ExFreePoolWithTag(SafeFileName.Buffer, TAG_STRING);
493  return Ret;
494 }
495 
496 HANDLE
497 APIENTRY
499  IN PVOID pvBuffer,
500  IN DWORD cjBuffer,
502  IN ULONG cjDV,
503  OUT DWORD *pNumFonts)
504 {
505  _SEH2_VOLATILE PVOID Buffer = NULL;
506  HANDLE Ret;
507  DWORD NumFonts = 0;
508 
509  DPRINT("NtGdiAddFontMemResourceEx\n");
512 
513  if (!pvBuffer || !cjBuffer)
514  return NULL;
515 
516  _SEH2_TRY
517  {
518  ProbeForRead(pvBuffer, cjBuffer, sizeof(BYTE));
520  RtlCopyMemory(Buffer, pvBuffer, cjBuffer);
521  }
523  {
524  if (Buffer != NULL)
525  {
527  }
528  _SEH2_YIELD(return NULL);
529  }
530  _SEH2_END;
531 
532  Ret = IntGdiAddFontMemResource(Buffer, cjBuffer, &NumFonts);
534 
535  _SEH2_TRY
536  {
537  ProbeForWrite(pNumFonts, sizeof(NumFonts), 1);
538  *pNumFonts = NumFonts;
539  }
541  {
542  /* Leak it? */
543  _SEH2_YIELD(return NULL);
544  }
545  _SEH2_END;
546 
547 
548  return Ret;
549 }
550 
551 
552 BOOL
553 APIENTRY
555  IN HANDLE hMMFont)
556 {
557  return IntGdiRemoveFontMemResource(hMMFont);
558 }
559 
560 
561  /*
562  * @unimplemented
563  */
564 DWORD
565 APIENTRY
567  IN HDC hdc,
568  IN LPWSTR pwsz,
569  IN INT nCount,
570  IN INT nMaxExtent,
571  IN OUT LPGCP_RESULTSW pgcpw,
572  IN DWORD dwFlags)
573 {
575  return 0;
576 #if 0
577  return GreGetCharacterPlacementW( hdc,
578  pwsz,
579  nCount,
580  nMaxExtent,
581  pgcpw,
582  dwFlags);
583 #endif
584 }
585 
586 DWORD
587 APIENTRY
589  HDC hDC,
590  DWORD Table,
591  DWORD Offset,
592  LPVOID Buffer,
593  DWORD Size)
594 {
595  PDC Dc;
596  PDC_ATTR pdcattr;
597  HFONT hFont;
598  PTEXTOBJ TextObj;
599  PFONTGDI FontGdi;
602 
603  if (Buffer && Size)
604  {
605  _SEH2_TRY
606  {
607  ProbeForRead(Buffer, Size, 1);
608  }
610  {
612  }
613  _SEH2_END
614  }
615 
616  if (!NT_SUCCESS(Status)) return Result;
617 
618  Dc = DC_LockDc(hDC);
619  if (Dc == NULL)
620  {
622  return GDI_ERROR;
623  }
624  pdcattr = Dc->pdcattr;
625 
626  hFont = pdcattr->hlfntNew;
627  TextObj = RealizeFontInit(hFont);
628  DC_UnlockDc(Dc);
629 
630  if (TextObj == NULL)
631  {
633  return GDI_ERROR;
634  }
635 
636  FontGdi = ObjToGDI(TextObj->Font, FONT);
637 
639 
640  TEXTOBJ_UnlockText(TextObj);
641 
642  return Result;
643 }
644 
645  /*
646  * @implemented
647  */
648 DWORD
649 APIENTRY
651  IN HDC hdc,
652  OUT OPTIONAL LPGLYPHSET pgs)
653 {
654  PDC pDc;
655  PDC_ATTR pdcattr;
656  HFONT hFont;
657  PTEXTOBJ TextObj;
658  PFONTGDI FontGdi;
659  DWORD Size = 0;
660  PGLYPHSET pgsSafe;
662 
663  pDc = DC_LockDc(hdc);
664  if (!pDc)
665  {
667  return 0;
668  }
669 
670  pdcattr = pDc->pdcattr;
671 
672  hFont = pdcattr->hlfntNew;
673  TextObj = RealizeFontInit(hFont);
674 
675  if ( TextObj == NULL)
676  {
678  goto Exit;
679  }
680  FontGdi = ObjToGDI(TextObj->Font, FONT);
681 
682  Size = ftGetFontUnicodeRanges( FontGdi, NULL);
683 
684  if (Size && pgs)
685  {
687  if (!pgsSafe)
688  {
690  Size = 0;
691  goto Exit;
692  }
693 
694  Size = ftGetFontUnicodeRanges( FontGdi, pgsSafe);
695 
696  if (Size)
697  {
698  _SEH2_TRY
699  {
700  ProbeForWrite(pgs, Size, 1);
701  RtlCopyMemory(pgs, pgsSafe, Size);
702  }
704  {
706  }
707  _SEH2_END
708 
709  if (!NT_SUCCESS(Status)) Size = 0;
710  }
711  ExFreePoolWithTag(pgsSafe, GDITAG_TEXT);
712  }
713 Exit:
714  TEXTOBJ_UnlockText(TextObj);
715  DC_UnlockDc(pDc);
716  return Size;
717 }
718 
719 ULONG
720 APIENTRY
722  IN HDC hdc,
723  IN WCHAR wch,
724  IN UINT iFormat,
725  OUT LPGLYPHMETRICS pgm,
726  IN ULONG cjBuf,
727  OUT OPTIONAL PVOID UnsafeBuf,
728  IN LPMAT2 pmat2,
729  IN BOOL bIgnoreRotation)
730 {
731  ULONG Ret = GDI_ERROR;
732  PDC dc;
733  PVOID pvBuf = NULL;
734  GLYPHMETRICS gm;
736 
737  dc = DC_LockDc(hdc);
738  if (!dc)
739  {
741  return GDI_ERROR;
742  }
743 
744  if (UnsafeBuf && cjBuf)
745  {
747  if (!pvBuf)
748  {
750  goto Exit;
751  }
752  }
753 
754  Ret = ftGdiGetGlyphOutline( dc,
755  wch,
756  iFormat,
757  pgm ? &gm : NULL,
758  cjBuf,
759  pvBuf,
760  pmat2,
761  bIgnoreRotation);
762 
763  if (pvBuf)
764  {
765  _SEH2_TRY
766  {
767  ProbeForWrite(UnsafeBuf, cjBuf, 1);
768  RtlCopyMemory(UnsafeBuf, pvBuf, cjBuf);
769  }
771  {
773  }
774  _SEH2_END
775 
777  }
778 
779  if (pgm)
780  {
781  _SEH2_TRY
782  {
783  ProbeForWrite(pgm, sizeof(GLYPHMETRICS), 1);
784  RtlCopyMemory(pgm, &gm, sizeof(GLYPHMETRICS));
785  }
787  {
789  }
790  _SEH2_END
791  }
792 
793  if (! NT_SUCCESS(Status))
794  {
796  Ret = GDI_ERROR;
797  }
798 
799 Exit:
800  DC_UnlockDc(dc);
801  return Ret;
802 }
803 
804 DWORD
805 APIENTRY
807  ULONG NumPairs,
808  LPKERNINGPAIR krnpair)
809 {
810  PDC dc;
811  PDC_ATTR pdcattr;
812  PTEXTOBJ TextObj;
813  PFONTGDI FontGDI;
814  DWORD Count;
815  KERNINGPAIR *pKP;
817 
818  dc = DC_LockDc(hDC);
819  if (!dc)
820  {
822  return 0;
823  }
824 
825  pdcattr = dc->pdcattr;
826  TextObj = RealizeFontInit(pdcattr->hlfntNew);
827  DC_UnlockDc(dc);
828 
829  if (!TextObj)
830  {
832  return 0;
833  }
834 
835  FontGDI = ObjToGDI(TextObj->Font, FONT);
836  TEXTOBJ_UnlockText(TextObj);
837 
838  Count = ftGdiGetKerningPairs(FontGDI,0,NULL);
839 
840  if ( Count && krnpair )
841  {
842  if (Count > NumPairs)
843  {
845  return 0;
846  }
848  if (!pKP)
849  {
851  return 0;
852  }
853  ftGdiGetKerningPairs(FontGDI,Count,pKP);
854  _SEH2_TRY
855  {
856  ProbeForWrite(krnpair, Count * sizeof(KERNINGPAIR), 1);
857  RtlCopyMemory(krnpair, pKP, Count * sizeof(KERNINGPAIR));
858  }
860  {
862  }
863  _SEH2_END
864  if (!NT_SUCCESS(Status))
865  {
867  Count = 0;
868  }
870  }
871  return Count;
872 }
873 
874 /*
875  From "Undocumented Windows 2000 Secrets" Appendix B, Table B-2, page
876  472, this is NtGdiGetOutlineTextMetricsInternalW.
877  */
878 ULONG
879 APIENTRY
881  ULONG Data,
882  OUTLINETEXTMETRICW *otm,
883  TMDIFF *Tmd)
884 {
885  PDC dc;
886  PDC_ATTR pdcattr;
887  PTEXTOBJ TextObj;
888  PFONTGDI FontGDI;
889  HFONT hFont = 0;
890  ULONG Size;
891  OUTLINETEXTMETRICW *potm;
893 
894  dc = DC_LockDc(hDC);
895  if (!dc)
896  {
898  return 0;
899  }
900  pdcattr = dc->pdcattr;
901  hFont = pdcattr->hlfntNew;
902  TextObj = RealizeFontInit(hFont);
903  DC_UnlockDc(dc);
904  if (!TextObj)
905  {
907  return 0;
908  }
909  FontGDI = ObjToGDI(TextObj->Font, FONT);
910  TextIntUpdateSize(dc, TextObj, FontGDI, TRUE);
911  TEXTOBJ_UnlockText(TextObj);
912  Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL);
913  if (!otm) return Size;
914  if (Size > Data)
915  {
917  return 0;
918  }
920  if (!potm)
921  {
923  return 0;
924  }
925  IntGetOutlineTextMetrics(FontGDI, Size, potm);
926  if (otm)
927  {
928  _SEH2_TRY
929  {
930  ProbeForWrite(otm, Size, 1);
931  RtlCopyMemory(otm, potm, Size);
932  }
934  {
936  }
937  _SEH2_END
938 
939  if (!NT_SUCCESS(Status))
940  {
942  Size = 0;
943  }
944  }
946  return Size;
947 }
948 
949 W32KAPI
950 BOOL
951 APIENTRY
953  IN LPWSTR pwszFiles,
954  IN ULONG cwc,
955  IN ULONG cFiles,
956  IN UINT cjIn,
958  OUT LPVOID pvBuf,
959  IN DWORD dwType)
960 {
962  DWORD dwBytes, dwBytesRequested;
963  UNICODE_STRING SafeFileNames;
964  BOOL bRet = FALSE;
965  ULONG cbStringSize;
966  LPVOID Buffer;
967 
968  /* FIXME: Handle cFiles > 0 */
969 
970  /* Check for valid dwType values */
971  if (dwType > 5)
972  {
974  return FALSE;
975  }
976 
977  /* Allocate a safe unicode string buffer */
978  cbStringSize = cwc * sizeof(WCHAR);
979  SafeFileNames.MaximumLength = SafeFileNames.Length = (USHORT)cbStringSize - sizeof(WCHAR);
980  SafeFileNames.Buffer = ExAllocatePoolWithTag(PagedPool,
981  cbStringSize,
982  TAG_USTR);
983  if (!SafeFileNames.Buffer)
984  {
986  return FALSE;
987  }
988  RtlZeroMemory(SafeFileNames.Buffer, SafeFileNames.MaximumLength);
989 
990  /* Check buffers and copy pwszFiles to safe unicode string */
991  _SEH2_TRY
992  {
993  ProbeForRead(pwszFiles, cbStringSize, 1);
994  ProbeForWrite(pdwBytes, sizeof(DWORD), 1);
995  if (pvBuf)
996  ProbeForWrite(pvBuf, cjIn, 1);
997 
998  dwBytes = *pdwBytes;
999  dwBytesRequested = dwBytes;
1000 
1001  RtlCopyMemory(SafeFileNames.Buffer, pwszFiles, cbStringSize);
1002  if (dwBytes > 0)
1003  {
1005  }
1006  else
1007  {
1009  }
1010  }
1012  {
1014  }
1015  _SEH2_END
1016 
1017  if(!NT_SUCCESS(Status))
1018  {
1020  /* Free the string buffer for the safe filename */
1021  ExFreePoolWithTag(SafeFileNames.Buffer, TAG_USTR);
1022  return FALSE;
1023  }
1024 
1025  /* Do the actual call */
1026  bRet = IntGdiGetFontResourceInfo(&SafeFileNames,
1027  (pvBuf ? Buffer : NULL),
1028  &dwBytes, dwType);
1029 
1030  /* Check if succeeded */
1031  if (bRet)
1032  {
1033  /* Copy the data back to caller */
1034  _SEH2_TRY
1035  {
1036  /* Buffers are already probed */
1037  if (pvBuf && dwBytesRequested > 0)
1038  RtlCopyMemory(pvBuf, Buffer, min(dwBytesRequested, dwBytes));
1039  *pdwBytes = dwBytes;
1040  }
1042  {
1044  }
1045  _SEH2_END
1046 
1047  if(!NT_SUCCESS(Status))
1048  {
1050  bRet = FALSE;
1051  }
1052  }
1053 
1055  /* Free the string for the safe filenames */
1056  ExFreePoolWithTag(SafeFileNames.Buffer, TAG_USTR);
1057 
1058  return bRet;
1059 }
1060 
1061  /*
1062  * @unimplemented
1063  */
1064 BOOL
1065 APIENTRY
1067  IN HDC hdc,
1068  OUT PREALIZATION_INFO pri,
1069  IN HFONT hf)
1070 {
1071  PDC pDc;
1072  PTEXTOBJ pTextObj;
1073  PFONTGDI pFontGdi;
1074  PDC_ATTR pdcattr;
1075  BOOL Ret = FALSE;
1076  INT i = 0;
1077  REALIZATION_INFO ri;
1078 
1079  pDc = DC_LockDc(hdc);
1080  if (!pDc)
1081  {
1083  return 0;
1084  }
1085  pdcattr = pDc->pdcattr;
1086  pTextObj = RealizeFontInit(pdcattr->hlfntNew);
1087  ASSERT(pTextObj != NULL);
1088  pFontGdi = ObjToGDI(pTextObj->Font, FONT);
1089  TEXTOBJ_UnlockText(pTextObj);
1090  DC_UnlockDc(pDc);
1091 
1092  Ret = ftGdiRealizationInfo(pFontGdi, &ri);
1093  if (Ret)
1094  {
1095  if (pri)
1096  {
1098  _SEH2_TRY
1099  {
1100  ProbeForWrite(pri, sizeof(REALIZATION_INFO), 1);
1101  RtlCopyMemory(pri, &ri, sizeof(REALIZATION_INFO));
1102  }
1104  {
1106  }
1107  _SEH2_END
1108 
1109  if(!NT_SUCCESS(Status))
1110  {
1112  return FALSE;
1113  }
1114  }
1115  do
1116  {
1117  if (GdiHandleTable->cfPublic[i].hf == hf)
1118  {
1119  GdiHandleTable->cfPublic[i].iTechnology = ri.iTechnology;
1120  GdiHandleTable->cfPublic[i].iUniq = ri.iUniq;
1121  GdiHandleTable->cfPublic[i].dwUnknown = ri.dwUnknown;
1122  GdiHandleTable->cfPublic[i].dwCFCount = GdiHandleTable->dwCFCount;
1123  GdiHandleTable->cfPublic[i].fl |= CFONT_REALIZATION;
1124  }
1125  i++;
1126  }
1127  while ( i < GDI_CFONT_MAX );
1128  }
1129  return Ret;
1130 }
1131 
1132 
1133 HFONT
1134 APIENTRY
1136  IN PENUMLOGFONTEXDVW pelfw,
1137  IN ULONG cjElfw,
1138  IN LFTYPE lft,
1139  IN FLONG fl,
1140  IN PVOID pvCliData )
1141 {
1142  HFONT hNewFont;
1143  PLFONT plfont;
1144 
1145  if (!pelfw)
1146  {
1147  return NULL;
1148  }
1149 
1150  plfont = LFONT_AllocFontWithHandle();
1151  if (!plfont)
1152  {
1153  return NULL;
1154  }
1155  hNewFont = plfont->BaseObject.hHmgr;
1156 
1157  plfont->lft = lft;
1158  plfont->fl = fl;
1159  RtlCopyMemory (&plfont->logfont, pelfw, sizeof(ENUMLOGFONTEXDVW));
1160  ExInitializePushLock(&plfont->lock);
1161 
1162  if (pelfw->elfEnumLogfontEx.elfLogFont.lfEscapement !=
1163  pelfw->elfEnumLogfontEx.elfLogFont.lfOrientation)
1164  {
1165  /* This should really depend on whether GM_ADVANCED is set */
1168  }
1169  LFONT_UnlockFont(plfont);
1170 
1171  if (pvCliData && hNewFont)
1172  {
1173  // FIXME: Use GDIOBJ_InsertUserData
1175  {
1176  INT Index = GDI_HANDLE_GET_INDEX((HGDIOBJ)hNewFont);
1178  Entry->UserData = pvCliData;
1179  }
1181  }
1182 
1183  return hNewFont;
1184 }
1185 
1186 
1187 HFONT
1188 APIENTRY
1190  IN PENUMLOGFONTEXDVW pelfw,
1191  IN ULONG cjElfw,
1192  IN LFTYPE lft,
1193  IN FLONG fl,
1194  IN PVOID pvCliData )
1195 {
1196  ENUMLOGFONTEXDVW SafeLogfont;
1198 
1199  /* Silence GCC warnings */
1200  SafeLogfont.elfEnumLogfontEx.elfLogFont.lfEscapement = 0;
1201  SafeLogfont.elfEnumLogfontEx.elfLogFont.lfOrientation = 0;
1202 
1203  if (!pelfw)
1204  {
1205  return NULL;
1206  }
1207 
1208  _SEH2_TRY
1209  {
1210  ProbeForRead(pelfw, sizeof(ENUMLOGFONTEXDVW), 1);
1211  RtlCopyMemory(&SafeLogfont, pelfw, sizeof(ENUMLOGFONTEXDVW));
1212  }
1214  {
1216  }
1217  _SEH2_END
1218 
1219  if (!NT_SUCCESS(Status))
1220  {
1221  return NULL;
1222  }
1223 
1224  return HfontCreate(&SafeLogfont, cjElfw, lft, fl, pvCliData);
1225 }
1226 
1227 
1228 /* EOF */
TEXTMETRICW TextMetric
Definition: ntgdityp.h:369
#define FLI_GLYPHS
Definition: wingdi.h:845
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define GDI_HANDLE_GET_INDEX(h)
Definition: gdi.h:28
#define GCPCLASS_LATIN
Definition: wingdi.h:669
#define TAG_FINF
Definition: text.h:3
DWORD FASTCALL ftGetFontUnicodeRanges(PFONTGDI Font, PGLYPHSET glyphset)
Definition: freetype.c:4188
#define IN
Definition: typedefs.h:38
LPWSTR lpGlyphs
Definition: wingdi.h:2415
ASMGENDATA Table[]
Definition: genincdata.c:61
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
_In_ ULONG_PTR _In_opt_ DESIGNVECTOR * pdv
Definition: winddi.h:3723
WCHAR elfFullName[LF_FULLFACESIZE]
Definition: wingdi.h:2681
DWORD APIENTRY NtGdiGetKerningPairs(HDC hDC, ULONG NumPairs, LPKERNINGPAIR krnpair)
Definition: font.c:806
PVOID NTAPI ExAllocatePoolWithQuotaTag(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
Definition: expool.c:2939
FORCEINLINE PDC DC_LockDc(HDC hdc)
Definition: dc.h:219
INT APIENTRY NtGdiAddFontResourceW(IN WCHAR *pwcFiles, IN ULONG cwc, IN ULONG cFiles, IN FLONG fl, IN DWORD dwPidTid, IN OPTIONAL DESIGNVECTOR *pdv)
Definition: font.c:446
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
USHORT MaximumLength
Definition: env_spec_w32.h:370
DWORD APIENTRY NtGdiGetFontUnicodeRanges(IN HDC hdc, OUT OPTIONAL LPGLYPHSET pgs)
Definition: font.c:650
FORCEINLINE VOID TEXTOBJ_UnlockText(PLFONT plfnt)
Definition: text.h:96
#define DBG_UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:325
#define TAG_STRING
Definition: oslist.c:24
BOOL FASTCALL IntGdiGetFontResourceInfo(PUNICODE_STRING FileName, PVOID pBuffer, DWORD *pdwBytes, DWORD dwType)
Definition: freetype.c:5105
DWORD FASTCALL IntGetFontLanguageInfo(PDC Dc)
Definition: font.c:371
BOOL FASTCALL GreGetTextExtentW(HDC hDC, LPCWSTR lpwsz, INT cwc, LPSIZE psize, UINT flOpts)
Definition: text.c:36
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
LONG NTSTATUS
Definition: precomp.h:26
#define LFONT_AllocFontWithHandle()
Definition: text.h:76
FORCEINLINE PTEXTOBJ TEXTOBJ_LockText(HFONT hfont)
Definition: text.h:83
static HDC
Definition: imagelist.c:92
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
DWORD APIENTRY NtGdiGetCharacterPlacementW(IN HDC hdc, IN LPWSTR pwsz, IN INT nCount, IN INT nMaxExtent, IN OUT LPGCP_RESULTSW pgcpw, IN DWORD dwFlags)
Definition: font.c:566
HFONT APIENTRY NtGdiHfontCreate(IN PENUMLOGFONTEXDVW pelfw, IN ULONG cjElfw, IN LFTYPE lft, IN FLONG fl, IN PVOID pvCliData)
Definition: font.c:1189
LONG lfEscapement
Definition: dimm.idl:61
HDC dc
Definition: cylfrac.c:34
#define TAG_FONT
Definition: tags.h:12
Definition: wingdi.h:2450
#define TEXTOBJECT_INIT
Definition: text.h:56
ULONG APIENTRY NtGdiGetOutlineTextMetricsInternalW(HDC hDC, ULONG Data, OUTLINETEXTMETRICW *otm, TMDIFF *Tmd)
Definition: font.c:880
#define GCP_JUSTIFY
Definition: wingdi.h:833
BOOL APIENTRY NtGdiGetRealizationInfo(IN HDC hdc, OUT PREALIZATION_INFO pri, IN HFONT hf)
Definition: font.c:1066
#define FASTCALL
Definition: nt_native.h:50
int32_t INT
Definition: typedefs.h:56
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
HFONT hFont
Definition: main.c:53
DWORD dvNumAxes
Definition: wingdi.h:2747
#define LFONT_UnlockFont(plfnt)
Definition: text.h:79
_SEH2_TRY
Definition: create.c:4250
WCHAR elfStyle[LF_FACESIZE]
Definition: wingdi.h:2682
uint32_t ULONG_PTR
Definition: typedefs.h:63
DWORD FASTCALL ftGdiGetKerningPairs(PFONTGDI Font, DWORD cPairs, LPKERNINGPAIR pKerningPair)
Definition: freetype.c:5392
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSTATUS FASTCALL TextIntRealizeFont(HFONT FontHandle, PTEXTOBJ pTextObj)
Definition: freetype.c:4906
_In_ FLONG fl
Definition: winddi.h:1279
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define UNICODE_NULL
BOOL FASTCALL TextIntUpdateSize(PDC dc, PTEXTOBJ TextObj, PFONTGDI FontGDI, BOOL bDoLock)
Definition: freetype.c:3338
Definition: text.h:59
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
LONG lfOrientation
Definition: dimm.idl:62
HANDLE hlfntNew
Definition: ntgdihdl.h:327
FLONG fl
Definition: text.h:65
DWORD FASTCALL IntGetCharDimensions(HDC hdc, PTEXTMETRICW ptm, PDWORD height)
Definition: font.c:329
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
HGDIOBJ hHmgr(VOID)
Definition: baseobj.hpp:95
#define MAKELONG(a, b)
Definition: typedefs.h:248
INT FASTCALL IntGetOutlineTextMetrics(PFONTGDI FontGDI, UINT Size, OUTLINETEXTMETRICW *Otm)
Definition: freetype.c:2154
WCHAR elfScript[LF_FACESIZE]
Definition: wingdi.h:2683
smooth NULL
Definition: ftsmooth.c:416
#define GCP_MAXEXTENT
Definition: wingdi.h:837
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
LONG cx
Definition: windef.h:319
ULONG APIENTRY NtGdiGetGlyphOutline(IN HDC hdc, IN WCHAR wch, IN UINT iFormat, OUT LPGLYPHMETRICS pgm, IN ULONG cjBuf, OUT OPTIONAL PVOID UnsafeBuf, IN LPMAT2 pmat2, IN BOOL bIgnoreRotation)
Definition: font.c:721
LPWSTR lpClass
Definition: wingdi.h:2414
void DPRINT(...)
Definition: polytest.cpp:61
#define ExInitializePushLock
Definition: ex.h:999
#define GCP_DIACRITIC
Definition: wingdi.h:830
DWORD LFTYPE
Definition: ntgdityp.h:188
Definition: bufpool.h:45
HFONT FASTCALL GreCreateFontIndirectW(LOGFONTW *lplf)
Definition: font.c:23
unsigned long FLONG
Definition: ntbasedef.h:373
#define GCP_LIGATE
Definition: wingdi.h:836
HFONT APIENTRY HfontCreate(IN PENUMLOGFONTEXDVW pelfw, IN ULONG cjElfw, IN LFTYPE lft, IN FLONG fl, IN PVOID pvCliData)
Definition: font.c:1135
#define GCP_KASHIDA
Definition: wingdi.h:835
#define GdiHandleTable
Definition: win32nt.h:35
BASEOBJECT BaseObject
Definition: text.h:63
Definition: polytest.cpp:40
DWORD FASTCALL ftGdiGetFontData(PFONTGDI FontGdi, DWORD Table, DWORD Offset, PVOID Buffer, DWORD Size)
Definition: freetype.c:4352
#define UNICODE_STRING_MAX_CHARS
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
struct tagLOGFONTW LOGFONTW
static void Exit(void)
Definition: sock.c:1331
static const UCHAR Index[8]
Definition: usbohci.c:18
unsigned long DWORD
Definition: ntddk_ex.h:95
static PWSTR PDWORD pdwBytes
Definition: layerapi.c:34
LPWSTR lpOutString
Definition: wingdi.h:2410
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_In_ DWORD cjBuf
Definition: winddi.h:3827
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
HDC hdc
Definition: main.c:9
#define GDI_CFONT_MAX
Definition: ntgdihdl.h:20
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define KeEnterCriticalRegion()
Definition: ke_x.h:83
BOOL FASTCALL ftGdiGetTextMetricsW(HDC hDC, PTMW_INTERNAL ptmwi)
Definition: freetype.c:4256
unsigned char BYTE
Definition: mem.h:68
_In_ ULONG _In_ CLIPOBJ _In_ RECTL _In_ ULONG cjIn
Definition: winddi.h:3529
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
W32KAPI BOOL APIENTRY NtGdiGetFontResourceInfoInternalW(IN LPWSTR pwszFiles, IN ULONG cwc, IN ULONG cFiles, IN UINT cjIn, IN OUT LPDWORD pdwBytes, OUT LPVOID pvBuf, IN DWORD dwType)
Definition: font.c:952
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:36
#define TAG_USTR
Definition: libsupp.c:111
ENUMLOGFONTEXDVW logfont
Definition: text.h:70
INT FASTCALL IntGdiAddFontResource(PUNICODE_STRING FileName, DWORD Characteristics)
Definition: freetype.c:1388
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
_In_ SIZEL _In_ ULONG iFormat
Definition: winddi.h:3467
Status
Definition: gdiplustypes.h:24
Definition: gdi.h:1
static HDC hDC
Definition: 3dtext.c:33
FONTOBJ * Font
Definition: text.h:66
DWORD fsCsb[2]
Definition: wingdi.h:1521
_SEH2_END
Definition: create.c:4424
#define GCP_GLYPHSHAPE
Definition: wingdi.h:832
#define KeLeaveCriticalRegion()
Definition: ke_x.h:114
#define GDITAG_TEXT
Definition: tags.h:171
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
Definition: dc.h:237
unsigned short USHORT
Definition: pedump.c:61
PTEXTOBJ FASTCALL RealizeFontInit(HFONT hFont)
Definition: font.c:422
LFTYPE lft
Definition: text.h:64
EX_PUSH_LOCK lock
Definition: text.h:71
ULONG FASTCALL ftGdiGetGlyphOutline(PDC dc, WCHAR wch, UINT iFormat, LPGLYPHMETRICS pgm, ULONG cjBuf, PVOID pvBuf, LPMAT2 pmat2, BOOL bIgnoreRotation)
Definition: freetype.c:3460
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
BOOL FASTCALL ftGdiRealizationInfo(PFONTGDI Font, PREALIZATION_INFO Info)
Definition: freetype.c:5373
unsigned int * PULONG
Definition: retypes.h:1
#define min(a, b)
Definition: monoChain.cc:55
#define CFONT_REALIZATION
Definition: ntgdityp.h:429
unsigned int UINT
Definition: ndis.h:50
DWORD * PDWORD
Definition: pedump.c:68
FLONG flTextAlign
Definition: ntgdihdl.h:321
#define DPRINT1
Definition: precomp.h:8
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
DESIGNVECTOR elfDesignVector
Definition: wingdi.h:2758
UINT * lpOrder
Definition: wingdi.h:2411
#define GCP_REORDER
Definition: wingdi.h:842
#define OUT
Definition: typedefs.h:39
ULONG FASTCALL FontGetObject(PTEXTOBJ plfont, ULONG cjBuffer, PVOID pvBuffer)
Definition: font.c:293
LOGFONTW elfLogFont
Definition: wingdi.h:2680
HANDLE FASTCALL IntGdiAddFontMemResource(PVOID Buffer, DWORD dwSize, PDWORD pNumAdded)
Definition: freetype.c:1500
uint32_t * LPDWORD
Definition: typedefs.h:57
unsigned int ULONG
Definition: retypes.h:1
#define W32KAPI
Definition: ntgdi.h:9
_In_ ULONG cjBuffer
Definition: ntgdi.h:2860
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define ObjToGDI(ClipObj, Type)
Definition: engobjects.h:180
BOOL APIENTRY NtGdiRemoveFontMemResourceEx(IN HANDLE hMMFont)
Definition: font.c:554
DWORD APIENTRY NtGdiGetFontData(HDC hDC, DWORD Table, DWORD Offset, LPVOID Buffer, DWORD Size)
Definition: font.c:588
BOOL FASTCALL IntGdiRemoveFontMemResource(HANDLE hMMFont)
Definition: freetype.c:1603
#define GCP_DBCS
Definition: wingdi.h:827
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
LONG tmHeight
Definition: wingdi.h:2361
DWORD FASTCALL GreGetKerningPairs(HDC hDC, ULONG NumPairs, LPKERNINGPAIR krnpair)
Definition: font.c:48
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
ENUMLOGFONTEXW elfEnumLogfontEx
Definition: wingdi.h:2757
WCHAR * LPWSTR
Definition: xmlstorage.h:184
BOOL FASTCALL TextIntGetTextExtentPoint(PDC dc, PTEXTOBJ TextObj, LPCWSTR String, INT Count, ULONG MaxExtent, LPINT Fit, LPINT Dx, LPSIZE Size, FLONG fl)
Definition: freetype.c:3935
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:2777
#define TA_RTLREADING
Definition: wingdi.h:933
INT FASTCALL ftGdiGetTextCharsetInfo(PDC Dc, LPFONTSIGNATURE lpSig, DWORD dwFlags)
Definition: freetype.c:4075
#define GDI_ERROR
Definition: wingdi.h:1291
GLuint64EXT * result
Definition: glext.h:11304
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:593
HANDLE APIENTRY NtGdiAddFontMemResourceEx(IN PVOID pvBuffer, IN DWORD cjBuffer, IN DESIGNVECTOR *pdv, IN ULONG cjDV, OUT DWORD *pNumFonts)
Definition: font.c:498
BOOL FASTCALL GreGetTextExtentExW(HDC hDC, LPCWSTR String, ULONG Count, ULONG MaxExtent, PULONG Fit, PULONG Dx, LPSIZE pSize, FLONG fl)
Definition: text.c:93
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
INT * lpCaretPos
Definition: wingdi.h:2413
base of all file and directory entries
Definition: entries.h:82
#define APIENTRY
Definition: api.h:79
#define GCP_USEKERNING
Definition: wingdi.h:844
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68