ReactOS  0.4.12-dev-75-g00dd17e
utils.c File Reference
#include <precomp.h>
Include dependency graph for utils.c:

Go to the source code of this file.

Macros

#define COPYS(f, len)   MultiByteToWideChar ( CP_THREAD_ACP, 0, pA->f, len, pW->f, len )
 
#define COPYN(f)   pW->f = pA->f
 
#define COPYS(f, len)   WideCharToMultiByte ( CP_THREAD_ACP, 0, pW->f, len, pA->f, len, NULL, NULL )
 
#define COPYN(f)   pA->f = pW->f
 

Functions

CalculateColorTableSize

Internal routine to calculate the number of color table entries.

Parameters
BitmapInfoHeaderInput bitmap information header, can be any version of BITMAPINFOHEADER or BITMAPCOREHEADER.
ColorSpecPointer to variable which specifiing the color mode (DIB_RGB_COLORS or DIB_RGB_COLORS). On successful return this value is normalized according to the bitmap info.
ColorTableSizeOn successful return this variable is filled with number of entries in color table for the image with specified parameters.
Returns
TRUE if the input values together form a valid image, FALSE otherwise.
BOOL WINAPI CalculateColorTableSize (CONST BITMAPINFOHEADER *BitmapInfoHeader, UINT *ColorSpec, UINT *ColorTableSize)
 
ConvertBitmapInfo

Internal routine to convert a user-passed BITMAPINFO structure into unified BITMAPINFO structure.

Parameters
BitmapInfoInput bitmap info, can be any version of BITMAPINFO or BITMAPCOREINFO.
ColorSpecSpecifies whether the bmiColors member of the BITMAPINFO structure contains a valid color table and, if so, whether the entries in this color table contain explicit red, green, blue (DIB_RGB_COLORS) values or palette indexes (DIB_PAL_COLORS).
BitmapInfoSizeOn successful return contains the size of the returned BITMAPINFO structure. If FollowedByData is TRUE the size includes the number of bytes occupied by the image data.
FollowedByDataSpecifies if the BITMAPINFO header is immediately followed by the actual bitmap data (eg. as passed to CreateDIBPatternBrush).
Returns
Either the original BitmapInfo or newly allocated structure is returned. For the later case the caller is responsible for freeing the memory using RtlFreeHeap with the current process heap.
LPBITMAPINFO WINAPI ConvertBitmapInfo (CONST BITMAPINFO *BitmapInfo, UINT ColorSpec, UINT *BitmapInfoSize, BOOL FollowedByData)
 
VOID WINAPI LogFontA2W (LPLOGFONTW pW, CONST LOGFONTA *pA)
 
VOID WINAPI LogFontW2A (LPLOGFONTA pA, CONST LOGFONTW *pW)
 
VOID WINAPI EnumLogFontExW2A (LPENUMLOGFONTEXA fontA, CONST ENUMLOGFONTEXW *fontW)
 
BOOL WINAPI LoadLPK (INT LpkFunctionID)
 

Variables

HINSTANCE hLpk = NULL
 
LPKETO LpkExtTextOut = NULL
 
LPKGCP LpkGetCharacterPlacement = NULL
 

Macro Definition Documentation

◆ COPYN [1/2]

#define COPYN (   f)    pW->f = pA->f

◆ COPYN [2/2]

#define COPYN (   f)    pA->f = pW->f

◆ COPYS [1/2]

#define COPYS (   f,
  len 
)    MultiByteToWideChar ( CP_THREAD_ACP, 0, pA->f, len, pW->f, len )

◆ COPYS [2/2]

#define COPYS (   f,
  len 
)    WideCharToMultiByte ( CP_THREAD_ACP, 0, pW->f, len, pA->f, len, NULL, NULL )

Function Documentation

◆ CalculateColorTableSize()

BOOL WINAPI CalculateColorTableSize ( CONST BITMAPINFOHEADER BitmapInfoHeader,
UINT ColorSpec,
UINT ColorTableSize 
)

Definition at line 31 of file utils.c.

Referenced by ConvertBitmapInfo().

35 {
36  WORD BitCount;
37  DWORD ClrUsed;
38  DWORD Compression;
39 
40  /*
41  * At first get some basic parameters from the passed BitmapInfoHeader
42  * structure. It can have one of the following formats:
43  * - BITMAPCOREHEADER (the oldest one with totally different layout
44  * from the others)
45  * - BITMAPINFOHEADER (the standard and most common header)
46  * - BITMAPV4HEADER (extension of BITMAPINFOHEADER)
47  * - BITMAPV5HEADER (extension of BITMAPV4HEADER)
48  */
49 
50  if (BitmapInfoHeader->biSize == sizeof(BITMAPCOREHEADER))
51  {
52  BitCount = ((LPBITMAPCOREHEADER)BitmapInfoHeader)->bcBitCount;
53  ClrUsed = 0;
54  Compression = BI_RGB;
55  }
56  else
57  {
58  BitCount = BitmapInfoHeader->biBitCount;
59  ClrUsed = BitmapInfoHeader->biClrUsed;
60  Compression = BitmapInfoHeader->biCompression;
61  }
62 
63  switch (Compression)
64  {
65  case BI_BITFIELDS:
66  if (*ColorSpec == DIB_PAL_COLORS)
67  *ColorSpec = DIB_RGB_COLORS;
68 
69  if (BitCount != 16 && BitCount != 32)
70  return FALSE;
71 
72  /*
73  * For BITMAPV4HEADER/BITMAPV5HEADER the masks are included in
74  * the structure itself (bV4RedMask, bV4GreenMask, and bV4BlueMask).
75  * For BITMAPINFOHEADER the color masks are stored in the palette.
76  */
77 
78  if (BitmapInfoHeader->biSize > sizeof(BITMAPINFOHEADER))
79  *ColorTableSize = 0;
80  else
81  *ColorTableSize = 3;
82 
83  return TRUE;
84 
85  case BI_RGB:
86  switch (BitCount)
87  {
88  case 1:
89  *ColorTableSize = ClrUsed ? min(ClrUsed, 2) : 2;
90  return TRUE;
91 
92  case 4:
93  *ColorTableSize = ClrUsed ? min(ClrUsed, 16) : 16;
94  return TRUE;
95 
96  case 8:
97  *ColorTableSize = ClrUsed ? min(ClrUsed, 256) : 256;
98  return TRUE;
99 
100  default:
101  if (*ColorSpec == DIB_PAL_COLORS)
102  *ColorSpec = DIB_RGB_COLORS;
103  if (BitCount != 16 && BitCount != 24 && BitCount != 32)
104  return FALSE;
105  *ColorTableSize = ClrUsed;
106  return TRUE;
107  }
108 
109  case BI_RLE4:
110  if (BitCount == 4)
111  {
112  *ColorTableSize = ClrUsed ? min(ClrUsed, 16) : 16;
113  return TRUE;
114  }
115  return FALSE;
116 
117  case BI_RLE8:
118  if (BitCount == 8)
119  {
120  *ColorTableSize = ClrUsed ? min(ClrUsed, 256) : 256;
121  return TRUE;
122  }
123  return FALSE;
124 
125  case BI_JPEG:
126  case BI_PNG:
127  *ColorTableSize = ClrUsed;
128  return TRUE;
129 
130  default:
131  return FALSE;
132  }
133 }
#define TRUE
Definition: types.h:120
#define DIB_PAL_COLORS
Definition: wingdi.h:364
#define BI_JPEG
Definition: wingdi.h:38
#define BI_BITFIELDS
Definition: mmreg.h:507
struct tagBITMAPCOREHEADER * LPBITMAPCOREHEADER
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
#define BI_PNG
Definition: wingdi.h:39
#define min(a, b)
Definition: monoChain.cc:55
#define BI_RLE4
Definition: precomp.h:36
#define DIB_RGB_COLORS
Definition: wingdi.h:365
#define BI_RLE8
Definition: wingdi.h:35
#define BI_RGB
Definition: precomp.h:35

◆ ConvertBitmapInfo()

LPBITMAPINFO WINAPI ConvertBitmapInfo ( CONST BITMAPINFO BitmapInfo,
UINT  ColorSpec,
UINT BitmapInfoSize,
BOOL  FollowedByData 
)

Definition at line 177 of file utils.c.

Referenced by CreateDIBitmap(), CreateDIBPatternBrush(), CreateDIBPatternBrushPt(), CreateDIBSection(), ExtCreatePen(), SetDIBitsToDevice(), and StretchDIBits().

182 {
183  LPBITMAPINFO NewBitmapInfo = (LPBITMAPINFO)BitmapInfo;
184  LPBITMAPCOREINFO CoreBitmapInfo = (LPBITMAPCOREINFO)BitmapInfo;
185  DWORD Size = 0;
186  ULONG DataSize = 0;
187  UINT PaletteEntryCount = 0;
188 
189  /*
190  * At first check if the passed BitmapInfo structure has valid size. It
191  * can have one of these headers: BITMAPCOREHEADER, BITMAPINFOHEADER,
192  * BITMAPV4HEADER or BITMAPV5HEADER (see CalculateColorTableSize for
193  * description).
194  */
195 
196  if ( !BitmapInfo ||
197  (BitmapInfo->bmiHeader.biSize != sizeof(BITMAPCOREHEADER) &&
198  (BitmapInfo->bmiHeader.biSize < sizeof(BITMAPINFOHEADER) ||
199  BitmapInfo->bmiHeader.biSize > sizeof(BITMAPV5HEADER))))
200  {
201  return NULL;
202  }
203 
204  /*
205  * Now calculate the color table size. Also if the bitmap info contains
206  * invalid color information it's rejected here.
207  */
208 
209  if (!CalculateColorTableSize(&BitmapInfo->bmiHeader, &ColorSpec,
210  &PaletteEntryCount))
211  {
212  return NULL;
213  }
214 
215  /*
216  * Calculate the size of image data if applicable. We must be careful
217  * to do proper aligning on line ends.
218  */
219 
220  if (FollowedByData)
221  {
222  DataSize = GdiGetBitmapBitsSize((PBITMAPINFO)BitmapInfo );
223  }
224 
225  /*
226  * If BitmapInfo was originally BITMAPCOREINFO then we need to convert
227  * it to the standard BITMAPINFO layout.
228  */
229 
230  if (BitmapInfo->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
231  {
232  Size = sizeof(BITMAPINFOHEADER);
233  if (ColorSpec == DIB_RGB_COLORS)
234  Size += PaletteEntryCount * sizeof(RGBQUAD);
235  else
236  Size += PaletteEntryCount * sizeof(USHORT);
237  Size += DataSize;
238 
239  NewBitmapInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
240  if (NewBitmapInfo == NULL)
241  {
242  return NULL;
243  }
244 
245  NewBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
246  NewBitmapInfo->bmiHeader.biWidth = CoreBitmapInfo->bmciHeader.bcWidth;
247  NewBitmapInfo->bmiHeader.biHeight = CoreBitmapInfo->bmciHeader.bcHeight;
248  NewBitmapInfo->bmiHeader.biPlanes = CoreBitmapInfo->bmciHeader.bcPlanes;
249  NewBitmapInfo->bmiHeader.biBitCount = CoreBitmapInfo->bmciHeader.bcBitCount;
250  NewBitmapInfo->bmiHeader.biCompression = BI_RGB;
251  NewBitmapInfo->bmiHeader.biSizeImage = 0;
252  NewBitmapInfo->bmiHeader.biXPelsPerMeter = 0;
253  NewBitmapInfo->bmiHeader.biYPelsPerMeter = 0;
254  NewBitmapInfo->bmiHeader.biClrUsed = 0;
255  NewBitmapInfo->bmiHeader.biClrImportant = 0;
256 
257  if (PaletteEntryCount != 0)
258  {
259  if (ColorSpec == DIB_RGB_COLORS)
260  {
261  ULONG Index;
262 
263  for (Index = 0; Index < PaletteEntryCount; Index++)
264  {
265  NewBitmapInfo->bmiColors[Index].rgbRed =
266  CoreBitmapInfo->bmciColors[Index].rgbtRed;
267  NewBitmapInfo->bmiColors[Index].rgbGreen =
268  CoreBitmapInfo->bmciColors[Index].rgbtGreen;
269  NewBitmapInfo->bmiColors[Index].rgbBlue =
270  CoreBitmapInfo->bmciColors[Index].rgbtBlue;
271  NewBitmapInfo->bmiColors[Index].rgbReserved = 0;
272  }
273  }
274  else
275  {
276  RtlCopyMemory(NewBitmapInfo->bmiColors,
277  CoreBitmapInfo->bmciColors,
278  PaletteEntryCount * sizeof(USHORT));
279  }
280  }
281 
282  if (FollowedByData)
283  {
284  ULONG_PTR NewDataPtr, OldDataPtr;
285 
286  if (ColorSpec == DIB_RGB_COLORS)
287  {
288  NewDataPtr = (ULONG_PTR)(NewBitmapInfo->bmiColors +
289  PaletteEntryCount);
290  OldDataPtr = (ULONG_PTR)(CoreBitmapInfo->bmciColors +
291  PaletteEntryCount);
292  }
293  else
294  {
295  NewDataPtr = (ULONG_PTR)(NewBitmapInfo->bmiColors) +
296  PaletteEntryCount * sizeof(USHORT);
297  OldDataPtr = (ULONG_PTR)(CoreBitmapInfo->bmciColors) +
298  PaletteEntryCount * sizeof(USHORT);
299  }
300 
301  RtlCopyMemory((PVOID)NewDataPtr, (PVOID)OldDataPtr, DataSize);
302  }
303  }
304  else
305  {
306  /* Verify some data validity */
307  switch (BitmapInfo->bmiHeader.biCompression)
308  {
309  case BI_RLE8:
310  if (BitmapInfo->bmiHeader.biBitCount != 8)
311  return NULL;
312  if (BitmapInfo->bmiHeader.biHeight < 0)
313  return NULL;
314  break;
315  case BI_RLE4:
316  if (BitmapInfo->bmiHeader.biBitCount != 4)
317  return NULL;
318  if (BitmapInfo->bmiHeader.biHeight < 0)
319  return NULL;
320  break;
321  default:
322  break;
323  }
324 
325  /* Non "standard" formats must have a valid size set */
326  if ((BitmapInfo->bmiHeader.biCompression != BI_RGB) &&
327  (BitmapInfo->bmiHeader.biCompression != BI_BITFIELDS))
328  {
329  if (BitmapInfo->bmiHeader.biSizeImage == 0)
330  return NULL;
331  }
332  }
333 
334  Size = NewBitmapInfo->bmiHeader.biSize;
335  if (ColorSpec == DIB_RGB_COLORS)
336  Size += PaletteEntryCount * sizeof(RGBQUAD);
337  else
338  Size += PaletteEntryCount * sizeof(USHORT);
339  Size += DataSize;
340  *BitmapInfoSize = Size;
341 
342  return NewBitmapInfo;
343 }
BYTE rgbtBlue
Definition: wingdi.h:1415
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1453
DWORD biClrImportant
Definition: amvideo.idl:40
struct tagBITMAPINFO * LPBITMAPINFO
int WINAPI GdiGetBitmapBitsSize(BITMAPINFO *lpbmi)
Definition: bitmap.c:161
LONG biXPelsPerMeter
Definition: amvideo.idl:37
struct tagBITMAPINFOHEADER BITMAPINFOHEADER
LONG biYPelsPerMeter
Definition: amvideo.idl:38
#define BI_BITFIELDS
Definition: mmreg.h:507
UCHAR rgbBlue
Definition: inbv.c:118
uint32_t ULONG_PTR
Definition: typedefs.h:63
UCHAR rgbGreen
Definition: inbv.c:119
UCHAR rgbRed
Definition: inbv.c:120
BITMAPCOREHEADER bmciHeader
Definition: wingdi.h:1430
DWORD biCompression
Definition: amvideo.idl:35
smooth NULL
Definition: ftsmooth.c:416
RGBTRIPLE bmciColors[1]
Definition: wingdi.h:1431
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:585
struct tagRGBQUAD RGBQUAD
RGBQUAD bmiColors[1]
Definition: wingdi.h:1454
unsigned int UINT
Definition: ndis.h:50
static const UCHAR Index[8]
Definition: usbohci.c:18
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD biSizeImage
Definition: amvideo.idl:36
struct _BITMAPCOREINFO * LPBITMAPCOREINFO
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
unsigned short USHORT
Definition: pedump.c:61
BYTE rgbtRed
Definition: wingdi.h:1417
#define BI_RLE4
Definition: precomp.h:36
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
BYTE rgbtGreen
Definition: wingdi.h:1416
UCHAR rgbReserved
Definition: inbv.c:121
#define DIB_RGB_COLORS
Definition: wingdi.h:365
#define BI_RLE8
Definition: wingdi.h:35
#define BI_RGB
Definition: precomp.h:35
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4733
BOOL WINAPI CalculateColorTableSize(CONST BITMAPINFOHEADER *BitmapInfoHeader, UINT *ColorSpec, UINT *ColorTableSize)
Definition: utils.c:31

◆ EnumLogFontExW2A()

VOID WINAPI EnumLogFontExW2A ( LPENUMLOGFONTEXA  fontA,
CONST ENUMLOGFONTEXW fontW 
)

Definition at line 401 of file utils.c.

Referenced by CreateFontIndirectExA(), and GetFontObjectA().

402 {
403  LogFontW2A( (LPLOGFONTA)fontA, (CONST LOGFONTW *)fontW );
404 
405  WideCharToMultiByte( CP_THREAD_ACP, 0, fontW->elfFullName, -1,
406  (LPSTR) fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
407  fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
408  WideCharToMultiByte( CP_THREAD_ACP, 0, fontW->elfStyle, -1,
409  (LPSTR) fontA->elfStyle, LF_FACESIZE, NULL, NULL );
410  fontA->elfStyle[LF_FACESIZE-1] = '\0';
411  WideCharToMultiByte( CP_THREAD_ACP, 0, fontW->elfScript, -1,
412  (LPSTR) fontA->elfScript, LF_FACESIZE, NULL, NULL );
413  fontA->elfScript[LF_FACESIZE-1] = '\0';
414 }
#define LF_FACESIZE
Definition: dimm.idl:39
#define LF_FULLFACESIZE
Definition: wingdi.h:41
#define WideCharToMultiByte
Definition: compat.h:101
char * LPSTR
Definition: xmlstorage.h:182
VOID WINAPI LogFontW2A(LPLOGFONTA pA, CONST LOGFONTW *pW)
Definition: utils.c:374
smooth NULL
Definition: ftsmooth.c:416
#define CONST
Definition: compiler.h:170
static const WCHAR fontW[]
Definition: editor.c:78
#define CP_THREAD_ACP
Definition: winnls.h:221

◆ LoadLPK()

BOOL WINAPI LoadLPK ( INT  LpkFunctionID)

Definition at line 422 of file utils.c.

Referenced by ExtTextOutW(), GdiInitializeLanguagePack(), and GetCharacterPlacementW().

423 {
424  if(!hLpk) // Check if the DLL is already loaded
425  hLpk = LoadLibraryW(L"lpk.dll");
426 
427  if (hLpk)
428  {
429  switch (LpkFunctionID)
430  {
431  case LPK_INIT:
432  return TRUE;
433 
434  case LPK_ETO:
435  if (!LpkExtTextOut) // Check if the function is already loaded
436  LpkExtTextOut = (LPKETO) GetProcAddress(hLpk, "LpkExtTextOut");
437 
438  if (!LpkExtTextOut)
439  {
440  FreeLibrary(hLpk);
441  return FALSE;
442  }
443 
444  return TRUE;
445 
446  case LPK_GCP:
447  if (!LpkGetCharacterPlacement) // Check if the function is already loaded
448  LpkGetCharacterPlacement = (LPKGCP) GetProcAddress(hLpk, "LpkGetCharacterPlacement");
449 
451  {
452  FreeLibrary(hLpk);
453  return FALSE;
454  }
455 
456  return TRUE;
457 
458  default:
459  FreeLibrary(hLpk);
460  return FALSE;
461  }
462  }
463 
464  else
465  return FALSE;
466 }
#define TRUE
Definition: types.h:120
LPKETO LpkExtTextOut
Definition: utils.c:5
#define LoadLibraryW(x)
Definition: compat.h:404
DWORD(WINAPI * LPKGCP)(HDC hdc, LPCWSTR lpString, INT uCount, INT nMaxExtent, LPGCP_RESULTSW lpResults, DWORD dwFlags, DWORD dwUnused)
Definition: gdi32p.h:44
HINSTANCE hLpk
Definition: utils.c:4
#define FreeLibrary(x)
Definition: compat.h:405
static const WCHAR L[]
Definition: oid.c:1087
#define LPK_ETO
Definition: gdi32p.h:68
#define LPK_INIT
Definition: gdi32p.h:67
#define LPK_GCP
Definition: gdi32p.h:69
#define GetProcAddress(x, y)
Definition: compat.h:410
LPKGCP LpkGetCharacterPlacement
Definition: utils.c:6
BOOL(WINAPI * LPKETO)(HDC hdc, int x, int y, UINT fuOptions, const RECT *lprc, LPCWSTR lpString, UINT uCount, const INT *lpDx, INT unknown)
Definition: gdi32p.h:31

◆ LogFontA2W()

VOID WINAPI LogFontA2W ( LPLOGFONTW  pW,
CONST LOGFONTA pA 
)

Definition at line 347 of file utils.c.

348 {
349 #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, pA->f, len, pW->f, len )
350 #define COPYN(f) pW->f = pA->f
351 
352  COPYN(lfHeight);
353  COPYN(lfWidth);
354  COPYN(lfEscapement);
355  COPYN(lfOrientation);
356  COPYN(lfWeight);
357  COPYN(lfItalic);
358  COPYN(lfUnderline);
359  COPYN(lfStrikeOut);
360  COPYN(lfCharSet);
361  COPYN(lfOutPrecision);
362  COPYN(lfClipPrecision);
363  COPYN(lfQuality);
364  COPYN(lfPitchAndFamily);
365  COPYS(lfFaceName,LF_FACESIZE);
366  pW->lfFaceName[LF_FACESIZE - 1] = '\0';
367 
368 #undef COPYN
369 #undef COPYS
370 }
#define COPYN(f)
#define LF_FACESIZE
Definition: dimm.idl:39
#define COPYS(f, len)
WCHAR lfFaceName[LF_FACESIZE]
Definition: wingdi.h:1887

◆ LogFontW2A()

VOID WINAPI LogFontW2A ( LPLOGFONTA  pA,
CONST LOGFONTW pW 
)

Definition at line 374 of file utils.c.

Referenced by EnumLogFontExW2A().

375 {
376 #define COPYS(f,len) WideCharToMultiByte ( CP_THREAD_ACP, 0, pW->f, len, pA->f, len, NULL, NULL )
377 #define COPYN(f) pA->f = pW->f
378 
379  COPYN(lfHeight);
380  COPYN(lfWidth);
381  COPYN(lfEscapement);
382  COPYN(lfOrientation);
383  COPYN(lfWeight);
384  COPYN(lfItalic);
385  COPYN(lfUnderline);
386  COPYN(lfStrikeOut);
387  COPYN(lfCharSet);
388  COPYN(lfOutPrecision);
389  COPYN(lfClipPrecision);
390  COPYN(lfQuality);
391  COPYN(lfPitchAndFamily);
392  COPYS(lfFaceName,LF_FACESIZE);
393  pA->lfFaceName[LF_FACESIZE - 1] = '\0';
394 
395 #undef COPYN
396 #undef COPYS
397 }
#define COPYN(f)
#define LF_FACESIZE
Definition: dimm.idl:39
CHAR lfFaceName[LF_FACESIZE]
Definition: wingdi.h:1871
#define COPYS(f, len)

Variable Documentation

◆ hLpk

HINSTANCE hLpk = NULL

Definition at line 4 of file utils.c.

Referenced by GdiInitializeLanguagePack().

◆ LpkExtTextOut

LPKETO LpkExtTextOut = NULL

Definition at line 5 of file utils.c.

Referenced by ExtTextOutW(), and LoadLPK().

◆ LpkGetCharacterPlacement

LPKGCP LpkGetCharacterPlacement = NULL

Definition at line 6 of file utils.c.

Referenced by GetCharacterPlacementW(), and LoadLPK().