ReactOS 0.4.16-dev-336-gb667d82
Classes | Macros | Functions | Variables
font.c File Reference
#include <math.h>
#include "objbase.h"
#include "gdiplus.h"
#include "wine/test.h"
Include dependency graph for font.c:

Go to the source code of this file.

Classes

struct  font_metrics
 

Macros

#define expect(expected, got)   ok(got == expected, "Expected %d, got %d\n", expected, got)
 
#define expect_(expected, got, precision)   ok(abs((expected) - (got)) <= (precision), "Expected %d, got %d\n", (expected), (got))
 
#define expectf_(expected, got, precision)   ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))
 
#define expectf(expected, got)   expectf_((expected), (got), 0.001)
 
#define DELETE_FONTFILE(filename)   _delete_testfontfile(filename, __LINE__)
 

Functions

static void set_rect_empty (RectF *rc)
 
static void create_testfontfile (const WCHAR *filename, int resource, WCHAR pathW[MAX_PATH])
 
static void _delete_testfontfile (const WCHAR *filename, int line)
 
static void test_long_name (void)
 
static void test_createfont (void)
 
static void test_logfont (void)
 
static void test_fontfamily (void)
 
static void test_fontfamily_properties (void)
 
static void check_family (const char *context, GpFontFamily *family, WCHAR *name)
 
static void test_getgenerics (void)
 
static void test_installedfonts (void)
 
static void test_heightgivendpi (void)
 
static int CALLBACK font_enum_proc (const LOGFONTW *lfe, const TEXTMETRICW *ntme, DWORD type, LPARAM lparam)
 
static void gdi_get_font_metrics (LOGFONTW *lf, struct font_metrics *fm)
 
static void gdip_get_font_metrics (GpFont *font, struct font_metrics *fm)
 
static void cmp_font_metrics (struct font_metrics *fm1, struct font_metrics *fm2, int line)
 
static void test_font_metrics (void)
 
static void test_font_substitution (void)
 
static void test_font_transform (void)
 
static void test_GdipGetFontCollectionFamilyList (void)
 
static void test_GdipGetFontCollectionFamilyCount (void)
 
 START_TEST (font)
 

Variables

static const WCHAR nonexistent [] = {'T','h','i','s','F','o','n','t','s','h','o','u','l','d','N','o','t','E','x','i','s','t','\0'}
 
static const WCHAR MSSansSerif [] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'}
 
static const WCHAR TimesNewRoman [] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'}
 
static const WCHAR Tahoma [] = {'T','a','h','o','m','a',0}
 

Macro Definition Documentation

◆ DELETE_FONTFILE

#define DELETE_FONTFILE (   filename)    _delete_testfontfile(filename, __LINE__)

Definition at line 67 of file font.c.

◆ expect

#define expect (   expected,
  got 
)    ok(got == expected, "Expected %d, got %d\n", expected, got)

Definition at line 28 of file font.c.

◆ expect_

#define expect_ (   expected,
  got,
  precision 
)    ok(abs((expected) - (got)) <= (precision), "Expected %d, got %d\n", (expected), (got))

Definition at line 29 of file font.c.

◆ expectf

#define expectf (   expected,
  got 
)    expectf_((expected), (got), 0.001)

Definition at line 31 of file font.c.

◆ expectf_

#define expectf_ (   expected,
  got,
  precision 
)    ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))

Definition at line 30 of file font.c.

Function Documentation

◆ _delete_testfontfile()

static void _delete_testfontfile ( const WCHAR *  filename,
int  line 
)
static

Definition at line 68 of file font.c.

69{
70 BOOL ret = DeleteFileW(filename);
71 ok_(__FILE__,line)(ret, "failed to delete file %s, error %d\n", wine_dbgstr_w(filename), GetLastError());
72}
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
filename
const char * filename
Definition: ioapi.h:137
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
line
Definition: parser.c:49
ret
int ret
Definition: wcstombs-tests.c:31
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

◆ check_family()

static void check_family ( const char *  context,
GpFontFamily *  family,
WCHAR *  name 
)
static

Definition at line 405 of file font.c.

406{
407 GpStatus stat;
408 GpFont* font;
409
410 *name = 0;
411 stat = GdipGetFamilyName(family, name, LANG_NEUTRAL);
412 ok(stat == Ok, "could not get the %s family name: %.8x\n", context, stat);
413
414 stat = GdipCreateFont(family, 12, FontStyleRegular, UnitPixel, &font);
415 ok(stat == Ok, "could not create a font for the %s family: %.8x\n", context, stat);
416 if (stat == Ok)
417 {
418 stat = GdipDeleteFont(font);
419 ok(stat == Ok, "could not delete the %s family font: %.8x\n", context, stat);
420 }
421
422 stat = GdipDeleteFontFamily(family);
423 ok(stat == Ok, "could not delete the %s family: %.8x\n", context, stat);
424}
stat
#define stat
Definition: acwin.h:99
ok
#define ok(value,...)
Definition: atltest.h:57
GdipDeleteFontFamily
GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily *FontFamily)
Definition: font.c:869
GdipDeleteFont
GpStatus WINGDIPAPI GdipDeleteFont(GpFont *font)
Definition: font.c:270
GdipCreateFont
GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily, REAL emSize, INT style, Unit unit, GpFont **font)
Definition: font.c:144
GdipGetFamilyName
GpStatus WINGDIPAPI GdipGetFamilyName(GDIPCONST GpFontFamily *family, WCHAR *name, LANGID language)
Definition: font.c:837
FontStyleRegular
@ FontStyleRegular
Definition: gdiplusenums.h:303
UnitPixel
@ UnitPixel
Definition: gdiplusenums.h:29
Status
Status
Definition: gdiplustypes.h:25
Ok
@ Ok
Definition: gdiplustypes.h:26
font
Definition: mk_font.cpp:20
LANG_NEUTRAL
#define LANG_NEUTRAL
Definition: nls.h:22
context
Definition: http.c:7252
name
Definition: name.c:39
stat
Definition: stat.h:55

Referenced by test_getgenerics().

◆ cmp_font_metrics()

static void cmp_font_metrics ( struct font_metrics *  fm1,
struct font_metrics *  fm2,
int  line 
)
static

Definition at line 652 of file font.c.

653{
654 ok_(__FILE__, line)(fm1->lfHeight == fm2->lfHeight, "lfHeight %d != %d\n", fm1->lfHeight, fm2->lfHeight);
655 ok_(__FILE__, line)(fm1->em_height == fm2->em_height, "em_height %u != %u\n", fm1->em_height, fm2->em_height);
656 ok_(__FILE__, line)(fm1->line_spacing == fm2->line_spacing, "line_spacing %u != %u\n", fm1->line_spacing, fm2->line_spacing);
657 ok_(__FILE__, line)(abs(fm1->ascent - fm2->ascent) <= 1, "ascent %u != %u\n", fm1->ascent, fm2->ascent);
658 ok_(__FILE__, line)(abs(fm1->descent - fm2->descent) <= 1, "descent %u != %u\n", fm1->descent, fm2->descent);
659 ok(fm1->font_height > 0.0, "fm1->font_height should be positive, got %f\n", fm1->font_height);
660 ok(fm2->font_height > 0.0, "fm2->font_height should be positive, got %f\n", fm2->font_height);
661 ok_(__FILE__, line)(fm1->font_height == fm2->font_height, "font_height %f != %f\n", fm1->font_height, fm2->font_height);
662 ok(fm1->font_size > 0.0, "fm1->font_size should be positive, got %f\n", fm1->font_size);
663 ok(fm2->font_size > 0.0, "fm2->font_size should be positive, got %f\n", fm2->font_size);
664 ok_(__FILE__, line)(fm1->font_size == fm2->font_size, "font_size %f != %f\n", fm1->font_size, fm2->font_size);
665}
abs
#define abs(i)
Definition: fconv.c:206
font_metrics::em_height
UINT16 em_height
Definition: font.c:650
font_metrics::ascent
UINT16 ascent
Definition: font.c:650
font_metrics::line_spacing
UINT16 line_spacing
Definition: font.c:650
font_metrics::lfHeight
INT lfHeight
Definition: font.c:579
font_metrics::font_size
REAL font_size
Definition: font.c:578
font_metrics::descent
UINT16 descent
Definition: font.c:650
font_metrics::font_height
REAL font_height
Definition: font.c:578

Referenced by test_font_metrics().

◆ create_testfontfile()

static void create_testfontfile ( const WCHAR *  filename,
int  resource,
WCHAR  pathW[MAX_PATH] 
)
static

Definition at line 46 of file font.c.

47{
48 DWORD written;
49 HANDLE file;
50 HRSRC res;
51 void *ptr;
52
53 GetTempPathW(MAX_PATH, pathW);
54 lstrcatW(pathW, filename);
55
56 file = CreateFileW(pathW, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
57 ok(file != INVALID_HANDLE_VALUE, "file creation failed, at %s, error %d\n", wine_dbgstr_w(pathW), GetLastError());
58
59 res = FindResourceA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(resource), (LPCSTR)RT_RCDATA);
60 ok(res != 0, "couldn't find resource\n");
61 ptr = LockResource(LoadResource(GetModuleHandleA(NULL), res));
62 WriteFile(file, ptr, SizeofResource(GetModuleHandleA(NULL), res), &written, NULL);
63 ok(written == SizeofResource(GetModuleHandleA(NULL), res), "couldn't write resource\n");
64 CloseHandle(file);
65}
NULL
#define NULL
Definition: types.h:112
CloseHandle
#define CloseHandle
Definition: compat.h:739
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
CreateFileW
#define CreateFileW
Definition: compat.h:741
WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
GetTempPathW
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
FindResourceA
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
SizeofResource
DWORD WINAPI SizeofResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:568
LockResource
LPVOID WINAPI LockResource(HGLOBAL handle)
Definition: res.c:550
LoadResource
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
res
GLuint res
Definition: glext.h:9613
lstrcatW
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
CREATE_ALWAYS
#define CREATE_ALWAYS
Definition: disk.h:72
ptr
static PVOID ptr
Definition: dispmode.c:27
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
RT_RCDATA
#define RT_RCDATA
Definition: pedump.c:372
file
Definition: fci.c:127
MAKEINTRESOURCEA
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
LPCSTR
const char * LPCSTR
Definition: xmlstorage.h:183

Referenced by test_long_name().

◆ font_enum_proc()

static int CALLBACK font_enum_proc ( const LOGFONTW *  lfe,
const TEXTMETRICW *  ntme,
DWORD  type,
LPARAM  lparam 
)
static

Definition at line 564 of file font.c.

566{
567 NEWTEXTMETRICW *ntm = (NEWTEXTMETRICW *)lparam;
568
569 if (type != TRUETYPE_FONTTYPE) return 1;
570
571 *ntm = *(NEWTEXTMETRICW *)ntme;
572 return 0;
573}
lparam
@ lparam
Definition: SystemMenu.c:31
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
TRUETYPE_FONTTYPE
#define TRUETYPE_FONTTYPE
Definition: wingdi.h:1109

◆ gdi_get_font_metrics()

static void gdi_get_font_metrics ( LOGFONTW *  lf,
struct font_metrics *  fm 
)
static

Definition at line 582 of file font.c.

583{
584 HDC hdc;
585 HFONT hfont;
586 NEWTEXTMETRICW ntm;
587 OUTLINETEXTMETRICW otm;
588 int ret;
589
590 hdc = CreateCompatibleDC(0);
591
592 /* it's the only way to get extended NEWTEXTMETRIC fields */
593 ret = EnumFontFamiliesExW(hdc, lf, font_enum_proc, (LPARAM)&ntm, 0);
594 ok(!ret, "EnumFontFamiliesExW failed to find %s\n", wine_dbgstr_w(lf->lfFaceName));
595
596 hfont = CreateFontIndirectW(lf);
597 SelectObject(hdc, hfont);
598
599 otm.otmSize = sizeof(otm);
600 ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
601 ok(ret, "GetOutlineTextMetrics failed\n");
602
603 DeleteDC(hdc);
604 DeleteObject(hfont);
605
606 fm->lfHeight = -otm.otmTextMetrics.tmAscent;
607 fm->line_spacing = ntm.ntmCellHeight;
608 fm->font_size = (REAL)otm.otmTextMetrics.tmAscent;
609 fm->font_height = (REAL)fm->line_spacing * fm->font_size / (REAL)ntm.ntmSizeEM;
610 fm->em_height = ntm.ntmSizeEM;
611 fm->ascent = ntm.ntmSizeEM;
612 fm->descent = ntm.ntmCellHeight - ntm.ntmSizeEM;
613}
hfont
static HFONT hfont
Definition: NtGdiRestoreDC.c:13
REAL
float REAL
Definition: types.h:41
DeleteObject
pKey DeleteObject()
hdc
HDC hdc
Definition: main.c:9
HDC
static HDC
Definition: imagelist.c:88
font_enum_proc
static INT CALLBACK font_enum_proc(const LOGFONTA *elf, const TEXTMETRICA *ntm, DWORD type, LPARAM lParam)
Definition: font.c:273
HFONT
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
LOGFONTW::lfFaceName
WCHAR lfFaceName[LF_FACESIZE]
Definition: dimm.idl:72
_OUTLINETEXTMETRICW
Definition: wingdi.h:2512
_OUTLINETEXTMETRICW::otmSize
UINT otmSize
Definition: wingdi.h:2513
_OUTLINETEXTMETRICW::otmTextMetrics
TEXTMETRICW otmTextMetrics
Definition: wingdi.h:2514
tagNEWTEXTMETRICW::ntmCellHeight
UINT ntmCellHeight
Definition: wingdi.h:2666
tagTEXTMETRICW::tmAscent
LONG tmAscent
Definition: wingdi.h:2384
LPARAM
LONG_PTR LPARAM
Definition: windef.h:208
EnumFontFamiliesExW
int WINAPI EnumFontFamiliesExW(_In_ HDC, _In_ PLOGFONTW, _In_ FONTENUMPROCW, _In_ LPARAM, _In_ DWORD)
SelectObject
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1546
CreateCompatibleDC
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
GetOutlineTextMetricsW
UINT WINAPI GetOutlineTextMetricsW(_In_ HDC hdc, _In_ UINT cjCopy, _Out_writes_bytes_opt_(cjCopy) LPOUTLINETEXTMETRICW potm)
CreateFontIndirectW
HFONT WINAPI CreateFontIndirectW(_In_ const LOGFONTW *)
DeleteDC
BOOL WINAPI DeleteDC(_In_ HDC)

Referenced by test_font_metrics().

◆ gdip_get_font_metrics()

static void gdip_get_font_metrics ( GpFont *  font,
struct font_metrics *  fm 
)
static

Definition at line 615 of file font.c.

616{
617 INT style;
618 GpFontFamily *family;
619 GpStatus stat;
620
621 stat = GdipGetFontStyle(font, &style);
622 expect(Ok, stat);
623
624 stat = GdipGetFontHeight(NULL, NULL, &fm->font_height);
625 expect(InvalidParameter, stat);
626
627 stat = GdipGetFontHeight(font, NULL, NULL);
628 expect(InvalidParameter, stat);
629
630 stat = GdipGetFontHeight(font, NULL, &fm->font_height);
631 expect(Ok, stat);
632 stat = GdipGetFontSize(font, &fm->font_size);
633 expect(Ok, stat);
634
635 fm->lfHeight = (INT)(fm->font_size * -1.0);
636
637 stat = GdipGetFamily(font, &family);
638 expect(Ok, stat);
639
640 stat = GdipGetEmHeight(family, style, &fm->em_height);
641 expect(Ok, stat);
642 stat = GdipGetLineSpacing(family, style, &fm->line_spacing);
643 expect(Ok, stat);
644 stat = GdipGetCellAscent(family, style, &fm->ascent);
645 expect(Ok, stat);
646 stat = GdipGetCellDescent(family, style, &fm->descent);
647 expect(Ok, stat);
648
649 GdipDeleteFontFamily(family);
650}
style
Arabic default style
Definition: afstyles.h:94
GdipGetFontSize
GpStatus WINGDIPAPI GdipGetFontSize(GpFont *font, REAL *size)
Definition: font.c:350
GdipGetFontHeight
GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont *font, GDIPCONST GpGraphics *graphics, REAL *height)
Definition: font.c:552
GdipGetFamily
GpStatus WINGDIPAPI GdipGetFamily(GpFont *font, GpFontFamily **family)
Definition: font.c:319
GdipGetCellDescent
GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily *family, INT style, UINT16 *CellDescent)
Definition: font.c:891
GdipGetFontStyle
GpStatus WINGDIPAPI GdipGetFontStyle(GpFont *font, INT *style)
Definition: font.c:393
GdipGetCellAscent
GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily *family, INT style, UINT16 *CellAscent)
Definition: font.c:880
GdipGetLineSpacing
GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily *family, INT style, UINT16 *LineSpacing)
Definition: font.c:945
GdipGetEmHeight
GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily *family, INT style, UINT16 *EmHeight)
Definition: font.c:918
InvalidParameter
@ InvalidParameter
Definition: gdiplustypes.h:28
expect
#define expect(expected, got)
Definition: font.c:40
INT
#define INT
Definition: polytest.cpp:20
INT
int32_t INT
Definition: typedefs.h:58

Referenced by test_font_metrics().

◆ set_rect_empty()

static void set_rect_empty ( RectF *  rc)
static

Definition at line 38 of file font.c.

39{
40 rc->X = 0.0;
41 rc->Y = 0.0;
42 rc->Width = 0.0;
43 rc->Height = 0.0;
44}
RectF::Height
REAL Height
Definition: gdiplustypes.h:664
RectF::X
REAL X
Definition: gdiplustypes.h:661
RectF::Width
REAL Width
Definition: gdiplustypes.h:663
RectF::Y
REAL Y
Definition: gdiplustypes.h:662

Referenced by test_font_transform().

◆ START_TEST()

START_TEST ( font  )

Definition at line 1263 of file font.c.

1264{
1265 struct GdiplusStartupInput gdiplusStartupInput;
1266 ULONG_PTR gdiplusToken;
1267 HMODULE hmsvcrt;
1268 int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
1269
1270 /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
1271 hmsvcrt = LoadLibraryA("msvcrt");
1272 _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
1273 if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
1274
1275 gdiplusStartupInput.GdiplusVersion = 1;
1276 gdiplusStartupInput.DebugEventCallback = NULL;
1277 gdiplusStartupInput.SuppressBackgroundThread = 0;
1278 gdiplusStartupInput.SuppressExternalCodecs = 0;
1279
1280 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1281
1282 test_long_name();
1283 test_font_transform();
1284 test_font_substitution();
1285 test_font_metrics();
1286 test_createfont();
1287 test_logfont();
1288 test_fontfamily();
1289 test_fontfamily_properties();
1290 test_getgenerics();
1291 test_installedfonts();
1292 test_heightgivendpi();
1293 test_GdipGetFontCollectionFamilyList();
1294 test_GdipGetFontCollectionFamilyCount();
1295
1296 GdiplusShutdown(gdiplusToken);
1297}
_controlfp_s
int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
Definition: _controlfp_s.c:19
CDECL
#define CDECL
Definition: compat.h:29
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
cur
FxCollectionEntry * cur
Definition: fxresourceapi.cpp:412
GdiplusStartup
Status WINAPI GdiplusStartup(ULONG_PTR *token, const struct GdiplusStartupInput *input, struct GdiplusStartupOutput *output)
Definition: gdiplus.c:81
GdiplusShutdown
void WINAPI GdiplusShutdown(ULONG_PTR)
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
test_logfont
static void test_logfont(void)
Definition: font.c:246
test_font_substitution
static void test_font_substitution(void)
Definition: font.c:807
test_font_metrics
static void test_font_metrics(void)
Definition: font.c:667
test_fontfamily
static void test_fontfamily(void)
Definition: font.c:307
test_long_name
static void test_long_name(void)
Definition: font.c:74
test_GdipGetFontCollectionFamilyList
static void test_GdipGetFontCollectionFamilyList(void)
Definition: font.c:1188
test_GdipGetFontCollectionFamilyCount
static void test_GdipGetFontCollectionFamilyCount(void)
Definition: font.c:1242
test_font_transform
static void test_font_transform(void)
Definition: font.c:912
test_fontfamily_properties
static void test_fontfamily_properties(void)
Definition: font.c:354
test_createfont
static void test_createfont(void)
Definition: font.c:118
test_getgenerics
static void test_getgenerics(void)
Definition: font.c:426
test_heightgivendpi
static void test_heightgivendpi(void)
Definition: font.c:476
test_installedfonts
static void test_installedfonts(void)
Definition: font.c:463
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65

◆ test_createfont()

static void test_createfont ( void  )
static

Definition at line 118 of file font.c.

119{
120 GpFontFamily* fontfamily = NULL, *fontfamily2;
121 GpFont* font = NULL;
122 GpStatus stat;
123 Unit unit;
124 UINT i;
125 REAL size;
126 WCHAR familyname[LF_FACESIZE];
127
128 stat = GdipCreateFontFamilyFromName(nonexistent, NULL, &fontfamily);
129 expect (FontFamilyNotFound, stat);
130 stat = GdipDeleteFont(font);
131 expect (InvalidParameter, stat);
132 stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &fontfamily);
133 expect (Ok, stat);
134 stat = GdipCreateFont(fontfamily, 12, FontStyleRegular, UnitPoint, &font);
135 expect (Ok, stat);
136 stat = GdipGetFontUnit (font, &unit);
137 expect (Ok, stat);
138 expect (UnitPoint, unit);
139
140 stat = GdipGetFamily(font, &fontfamily2);
141 expect(Ok, stat);
142 stat = GdipGetFamilyName(fontfamily2, familyname, 0);
143 expect(Ok, stat);
144 ok (lstrcmpiW(Tahoma, familyname) == 0, "Expected Tahoma, got %s\n",
145 wine_dbgstr_w(familyname));
146 stat = GdipDeleteFontFamily(fontfamily2);
147 expect(Ok, stat);
148
149 /* Test to see if returned size is based on unit (it's not) */
150 GdipGetFontSize(font, &size);
151 ok (size == 12, "Expected 12, got %f\n", size);
152 GdipDeleteFont(font);
153
154 /* Make sure everything is converted correctly for all Units */
155 for (i = UnitWorld; i <=UnitMillimeter; i++)
156 {
157 if (i == UnitDisplay) continue; /* Crashes WindowsXP, wtf? */
158 stat = GdipCreateFont(fontfamily, 24, FontStyleRegular, i, &font);
159 expect(Ok, stat);
160 GdipGetFontSize (font, &size);
161 ok (size == 24, "Expected 24, got %f (with unit: %d)\n", size, i);
162 stat = GdipGetFontUnit (font, &unit);
163 ok (stat == Ok, "Failed to get font unit, %d.\n", stat);
164 expect (i, unit);
165 GdipDeleteFont(font);
166 }
167
168 GdipDeleteFontFamily(fontfamily);
169}
LF_FACESIZE
#define LF_FACESIZE
Definition: dimm.idl:39
GdipCreateFontFamilyFromName
GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name, GpFontCollection *fontCollection, GpFontFamily **FontFamily)
Definition: font.c:746
GdipGetFontUnit
GpStatus WINGDIPAPI GdipGetFontUnit(GpFont *font, Unit *unit)
Definition: font.c:417
lstrcmpiW
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4262
Unit
Unit
Definition: gdiplusenums.h:26
UnitMillimeter
@ UnitMillimeter
Definition: gdiplusenums.h:33
UnitDisplay
@ UnitDisplay
Definition: gdiplusenums.h:28
UnitWorld
@ UnitWorld
Definition: gdiplusenums.h:27
UnitPoint
@ UnitPoint
Definition: gdiplusenums.h:30
FontFamilyNotFound
@ FontFamilyNotFound
Definition: gdiplustypes.h:40
size
GLsizeiptr size
Definition: glext.h:5919
i
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
nonexistent
static const WCHAR nonexistent[]
Definition: font.c:33
Tahoma
static const WCHAR Tahoma[]
Definition: font.c:36
UINT
unsigned int UINT
Definition: ndis.h:50
unit
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by START_TEST().

◆ test_font_metrics()

static void test_font_metrics ( void  )
static

Definition at line 667 of file font.c.

668{
669 LOGFONTW lf;
670 GpFont *font;
671 GpFontFamily *family;
672 GpGraphics *graphics;
673 GpStatus stat;
674 Unit unit;
675 struct font_metrics fm_gdi, fm_gdip;
676 HDC hdc;
677
678 hdc = CreateCompatibleDC(0);
679 stat = GdipCreateFromHDC(hdc, &graphics);
680 expect(Ok, stat);
681
682 memset(&lf, 0, sizeof(lf));
683
684 /* Tahoma,-13 */
685 lstrcpyW(lf.lfFaceName, Tahoma);
686 lf.lfHeight = -13;
687 stat = GdipCreateFontFromLogfontW(hdc, &lf, &font);
688 expect(Ok, stat);
689
690 stat = GdipGetFontUnit(font, &unit);
691 expect(Ok, stat);
692 expect(UnitWorld, unit);
693
694 gdip_get_font_metrics(font, &fm_gdip);
695 trace("gdiplus:\n");
696 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
697 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
698 fm_gdip.em_height, fm_gdip.line_spacing, fm_gdip.ascent, fm_gdip.descent,
699 fm_gdip.font_height, fm_gdip.font_size);
700
701 gdi_get_font_metrics(&lf, &fm_gdi);
702 trace("gdi:\n");
703 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
704 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
705 fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
706 fm_gdi.font_height, fm_gdi.font_size);
707
708 cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
709
710 stat = GdipGetLogFontW(font, graphics, &lf);
711 expect(Ok, stat);
712 ok(lf.lfHeight < 0, "lf.lfHeight should be negative, got %d\n", lf.lfHeight);
713 gdi_get_font_metrics(&lf, &fm_gdi);
714 trace("gdi:\n");
715 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
716 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
717 fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
718 fm_gdi.font_height, fm_gdi.font_size);
719 ok((REAL)lf.lfHeight * -1.0 == fm_gdi.font_size, "expected %f, got %f\n", (REAL)lf.lfHeight * -1.0, fm_gdi.font_size);
720
721 cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
722
723 GdipDeleteFont(font);
724
725 /* Tahoma,13 */
726 lstrcpyW(lf.lfFaceName, Tahoma);
727 lf.lfHeight = 13;
728 stat = GdipCreateFontFromLogfontW(hdc, &lf, &font);
729 expect(Ok, stat);
730
731 stat = GdipGetFontUnit(font, &unit);
732 expect(Ok, stat);
733 expect(UnitWorld, unit);
734
735 gdip_get_font_metrics(font, &fm_gdip);
736 trace("gdiplus:\n");
737 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
738 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
739 fm_gdip.em_height, fm_gdip.line_spacing, fm_gdip.ascent, fm_gdip.descent,
740 fm_gdip.font_height, fm_gdip.font_size);
741
742 gdi_get_font_metrics(&lf, &fm_gdi);
743 trace("gdi:\n");
744 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
745 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
746 fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
747 fm_gdi.font_height, fm_gdi.font_size);
748
749 cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
750
751 stat = GdipGetLogFontW(font, graphics, &lf);
752 expect(Ok, stat);
753 ok(lf.lfHeight < 0, "lf.lfHeight should be negative, got %d\n", lf.lfHeight);
754 gdi_get_font_metrics(&lf, &fm_gdi);
755 trace("gdi:\n");
756 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
757 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
758 fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
759 fm_gdi.font_height, fm_gdi.font_size);
760 ok((REAL)lf.lfHeight * -1.0 == fm_gdi.font_size, "expected %f, got %f\n", (REAL)lf.lfHeight * -1.0, fm_gdi.font_size);
761
762 cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
763
764 GdipDeleteFont(font);
765
766 stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &family);
767 expect(Ok, stat);
768
769 /* Tahoma,13 */
770 stat = GdipCreateFont(family, 13.0, FontStyleRegular, UnitPixel, &font);
771 expect(Ok, stat);
772
773 gdip_get_font_metrics(font, &fm_gdip);
774 trace("gdiplus:\n");
775 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
776 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
777 fm_gdip.em_height, fm_gdip.line_spacing, fm_gdip.ascent, fm_gdip.descent,
778 fm_gdip.font_height, fm_gdip.font_size);
779
780 stat = GdipGetLogFontW(font, graphics, &lf);
781 expect(Ok, stat);
782 ok(lf.lfHeight < 0, "lf.lfHeight should be negative, got %d\n", lf.lfHeight);
783 gdi_get_font_metrics(&lf, &fm_gdi);
784 trace("gdi:\n");
785 trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
786 wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
787 fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
788 fm_gdi.font_height, fm_gdi.font_size);
789 ok((REAL)lf.lfHeight * -1.0 == fm_gdi.font_size, "expected %f, got %f\n", (REAL)lf.lfHeight * -1.0, fm_gdi.font_size);
790
791 cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
792
793 stat = GdipGetLogFontW(font, NULL, &lf);
794 expect(InvalidParameter, stat);
795
796 GdipDeleteFont(font);
797
798 stat = GdipCreateFont(family, -13.0, FontStyleRegular, UnitPixel, &font);
799 expect(InvalidParameter, stat);
800
801 GdipDeleteFontFamily(family);
802
803 GdipDeleteGraphics(graphics);
804 DeleteDC(hdc);
805}
trace
#define trace
Definition: atltest.h:70
lstrcpyW
#define lstrcpyW
Definition: compat.h:749
GdipCreateFontFromLogfontW
GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc, GDIPCONST LOGFONTW *logfont, GpFont **font)
Definition: font.c:203
GdipGetLogFontW
GpStatus WINGDIPAPI GdipGetLogFontW(GpFont *font, GpGraphics *graphics, LOGFONTW *lf)
Definition: font.c:455
GdipCreateFromHDC
GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
Definition: graphics.c:2395
GdipDeleteGraphics
GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
Definition: graphics.c:2581
cmp_font_metrics
static void cmp_font_metrics(struct font_metrics *fm1, struct font_metrics *fm2, int line)
Definition: font.c:652
gdip_get_font_metrics
static void gdip_get_font_metrics(GpFont *font, struct font_metrics *fm)
Definition: font.c:615
gdi_get_font_metrics
static void gdi_get_font_metrics(LOGFONTW *lf, struct font_metrics *fm)
Definition: font.c:582
memset
#define memset(x, y, z)
Definition: compat.h:39
LOGFONTW::lfHeight
LONG lfHeight
Definition: dimm.idl:59
font_metrics
Definition: font.c:648

Referenced by START_TEST(), test_bitmap_font(), and test_outline_font().

◆ test_font_substitution()

static void test_font_substitution ( void  )
static

Definition at line 807 of file font.c.

808{
809 WCHAR ms_shell_dlg[LF_FACESIZE];
810 char fallback_font[LF_FACESIZE];
811 HDC hdc;
812 HFONT hfont;
813 LOGFONTA lf;
814 GpStatus status;
815 GpGraphics *graphics;
816 GpFont *font;
817 GpFontFamily *family;
818 int ret;
819
820 hdc = CreateCompatibleDC(0);
821 status = GdipCreateFromHDC(hdc, &graphics);
822 expect(Ok, status);
823
824 hfont = GetStockObject(DEFAULT_GUI_FONT);
825 ok(hfont != 0, "GetStockObject(DEFAULT_GUI_FONT) failed\n");
826
827 memset(&lf, 0xfe, sizeof(lf));
828 ret = GetObjectA(hfont, sizeof(lf), &lf);
829 ok(ret == sizeof(lf), "GetObject failed\n");
830 ok(!lstrcmpA(lf.lfFaceName, "MS Shell Dlg"), "wrong face name %s\n", lf.lfFaceName);
831 MultiByteToWideChar(CP_ACP, 0, lf.lfFaceName, -1, ms_shell_dlg, LF_FACESIZE);
832
833 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
834 expect(Ok, status);
835 memset(&lf, 0xfe, sizeof(lf));
836 status = GdipGetLogFontA(font, graphics, &lf);
837 expect(Ok, status);
838 ok(!lstrcmpA(lf.lfFaceName, "Microsoft Sans Serif") ||
839 !lstrcmpA(lf.lfFaceName, "Tahoma"), "wrong face name %s\n", lf.lfFaceName);
840 GdipDeleteFont(font);
841
842 status = GdipCreateFontFamilyFromName(ms_shell_dlg, NULL, &family);
843 expect(Ok, status);
844 status = GdipCreateFont(family, 12, FontStyleRegular, UnitPoint, &font);
845 expect(Ok, status);
846 memset(&lf, 0xfe, sizeof(lf));
847 status = GdipGetLogFontA(font, graphics, &lf);
848 expect(Ok, status);
849 ok(!lstrcmpA(lf.lfFaceName, "Microsoft Sans Serif") ||
850 !lstrcmpA(lf.lfFaceName, "Tahoma"), "wrong face name %s\n", lf.lfFaceName);
851 GdipDeleteFont(font);
852 GdipDeleteFontFamily(family);
853
854 status = GdipCreateFontFamilyFromName(nonexistent, NULL, &family);
855 ok(status == FontFamilyNotFound, "expected FontFamilyNotFound, got %d\n", status);
856
857 /* nonexistent fonts fallback to Arial, or something else if it's missing */
858 strcpy(lf.lfFaceName,"Arial");
859 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
860 expect(Ok, status);
861 status = GdipGetLogFontA(font, graphics, &lf);
862 expect(Ok, status);
863 strcpy(fallback_font,lf.lfFaceName);
864 trace("fallback font %s\n", fallback_font);
865 GdipDeleteFont(font);
866
867 lstrcpyA(lf.lfFaceName, "ThisFontShouldNotExist");
868 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
869 expect(Ok, status);
870 memset(&lf, 0xfe, sizeof(lf));
871 status = GdipGetLogFontA(font, graphics, &lf);
872 expect(Ok, status);
873 ok(!lstrcmpA(lf.lfFaceName, fallback_font), "wrong face name %s / %s\n", lf.lfFaceName, fallback_font);
874 GdipDeleteFont(font);
875
876 /* empty FaceName */
877 lf.lfFaceName[0] = 0;
878 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
879 expect(Ok, status);
880 memset(&lf, 0xfe, sizeof(lf));
881 status = GdipGetLogFontA(font, graphics, &lf);
882 expect(Ok, status);
883 ok(!lstrcmpA(lf.lfFaceName, fallback_font), "wrong face name %s / %s\n", lf.lfFaceName, fallback_font);
884 GdipDeleteFont(font);
885
886 /* zeroing out lfWeight and lfCharSet leads to font creation failure */
887 lf.lfWeight = 0;
888 lf.lfCharSet = 0;
889 lstrcpyA(lf.lfFaceName, "ThisFontShouldNotExist");
890 font = NULL;
891 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
892todo_wine
893 ok(status == NotTrueTypeFont || broken(status == FileNotFound), /* before XP */
894 "expected NotTrueTypeFont, got %d\n", status);
895 /* FIXME: remove when wine is fixed */
896 if (font) GdipDeleteFont(font);
897
898 /* empty FaceName */
899 lf.lfFaceName[0] = 0;
900 font = NULL;
901 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
902todo_wine
903 ok(status == NotTrueTypeFont || broken(status == FileNotFound), /* before XP */
904 "expected NotTrueTypeFont, got %d\n", status);
905 /* FIXME: remove when wine is fixed */
906 if (font) GdipDeleteFont(font);
907
908 GdipDeleteGraphics(graphics);
909 DeleteDC(hdc);
910}
strcpy
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
broken
#define broken(x)
Definition: atltest.h:178
CP_ACP
#define CP_ACP
Definition: compat.h:109
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
GdipCreateFontFromLogfontA
GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc, GDIPCONST LOGFONTA *lfa, GpFont **font)
Definition: font.c:249
GdipGetLogFontA
GpStatus WINGDIPAPI GdipGetLogFontA(GpFont *font, GpGraphics *graphics, LOGFONTA *lfa)
Definition: font.c:432
lstrcmpA
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4195
FileNotFound
@ FileNotFound
Definition: gdiplustypes.h:36
NotTrueTypeFont
@ NotTrueTypeFont
Definition: gdiplustypes.h:42
lstrcpyA
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
todo_wine
#define todo_wine
Definition: custom.c:89
LOGFONTA::lfCharSet
BYTE lfCharSet
Definition: dimm.idl:50
LOGFONTA::lfWeight
LONG lfWeight
Definition: dimm.idl:46
LOGFONTA::lfFaceName
CHAR lfFaceName[LF_FACESIZE]
Definition: dimm.idl:55
status
Definition: ps.c:97
GetStockObject
HGDIOBJ WINAPI GetStockObject(_In_ int)
GetObjectA
int WINAPI GetObjectA(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
DEFAULT_GUI_FONT
#define DEFAULT_GUI_FONT
Definition: wingdi.h:909

Referenced by START_TEST().

◆ test_font_transform()

static void test_font_transform ( void  )
static

Definition at line 912 of file font.c.

913{
914 static const WCHAR string[] = { 'A',0 };
915 GpStatus status;
916 HDC hdc;
917 LOGFONTA lf;
918 GpFont *font;
919 GpGraphics *graphics;
920 GpMatrix *matrix;
921 GpStringFormat *format, *typographic;
922 PointF pos[1] = { { 0,0 } };
923 REAL height, margin_y;
924 RectF bounds, rect;
925
926 hdc = CreateCompatibleDC(0);
927 status = GdipCreateFromHDC(hdc, &graphics);
928 expect(Ok, status);
929
930 status = GdipSetPageUnit(graphics, UnitPixel);
931 expect(Ok, status);
932
933 status = GdipCreateStringFormat(0, LANG_NEUTRAL, &format);
934 expect(Ok, status);
935 status = GdipStringFormatGetGenericTypographic(&typographic);
936 expect(Ok, status);
937
938 memset(&lf, 0, sizeof(lf));
939 lstrcpyA(lf.lfFaceName, "Tahoma");
940 lf.lfHeight = -100;
941 lf.lfWidth = 100;
942 status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
943 expect(Ok, status);
944
945 margin_y = 100.0 / 8.0;
946
947 /* identity matrix */
948 status = GdipCreateMatrix(&matrix);
949 expect(Ok, status);
950 status = GdipSetWorldTransform(graphics, matrix);
951 expect(Ok, status);
952 status = GdipGetLogFontA(font, graphics, &lf);
953 expect(Ok, status);
954 expect(-100, lf.lfHeight);
955 expect(0, lf.lfWidth);
956 expect(0, lf.lfEscapement);
957 expect(0, lf.lfOrientation);
958 status = GdipGetFontHeight(font, graphics, &height);
959 expect(Ok, status);
960 expectf(120.703125, height);
961 set_rect_empty(&rect);
962 set_rect_empty(&bounds);
963 status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
964 expect(Ok, status);
965 expectf(0.0, bounds.X);
966 expectf(0.0, bounds.Y);
967todo_wine
968 expectf(height + margin_y, bounds.Height);
969 set_rect_empty(&rect);
970 set_rect_empty(&bounds);
971 status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
972 expect(Ok, status);
973 expectf(0.0, bounds.X);
974 expectf(0.0, bounds.Y);
975 expectf_(height, bounds.Height, 1.0);
976 set_rect_empty(&bounds);
977 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
978 DriverStringOptionsCmapLookup, NULL, &bounds);
979 expect(Ok, status);
980 expectf(0.0, bounds.X);
981 expectf_(-100.0, bounds.Y, 0.05);
982 expectf_(height, bounds.Height, 0.5);
983 set_rect_empty(&bounds);
984 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
985 DriverStringOptionsCmapLookup, matrix, &bounds);
986 expect(Ok, status);
987 expectf(0.0, bounds.X);
988 expectf_(-100.0, bounds.Y, 0.05);
989 expectf_(height, bounds.Height, 0.5);
990
991 /* scale matrix */
992 status = GdipScaleMatrix(matrix, 2.0, 3.0, MatrixOrderAppend);
993 expect(Ok, status);
994 status = GdipSetWorldTransform(graphics, matrix);
995 expect(Ok, status);
996 status = GdipGetLogFontA(font, graphics, &lf);
997 expect(Ok, status);
998 expect(-300, lf.lfHeight);
999 expect(0, lf.lfWidth);
1000 expect(0, lf.lfEscapement);
1001 expect(0, lf.lfOrientation);
1002 status = GdipGetFontHeight(font, graphics, &height);
1003 expect(Ok, status);
1004 expectf(120.703125, height);
1005 set_rect_empty(&rect);
1006 set_rect_empty(&bounds);
1007 status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
1008 expect(Ok, status);
1009 expectf(0.0, bounds.X);
1010 expectf(0.0, bounds.Y);
1011todo_wine
1012 expectf(height + margin_y, bounds.Height);
1013 set_rect_empty(&rect);
1014 set_rect_empty(&bounds);
1015 status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
1016 expect(Ok, status);
1017 expectf(0.0, bounds.X);
1018 expectf(0.0, bounds.Y);
1019 expectf_(height, bounds.Height, 0.05);
1020 set_rect_empty(&bounds);
1021 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1022 DriverStringOptionsCmapLookup, NULL, &bounds);
1023 expect(Ok, status);
1024 expectf(0.0, bounds.X);
1025 expectf_(-100.0, bounds.Y, 0.05);
1026 expectf_(height, bounds.Height, 0.2);
1027 set_rect_empty(&bounds);
1028 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1029 DriverStringOptionsCmapLookup, matrix, &bounds);
1030 expect(Ok, status);
1031 expectf(0.0, bounds.X);
1032todo_wine
1033 expectf_(-300.0, bounds.Y, 0.15);
1034todo_wine
1035 expectf(height * 3.0, bounds.Height);
1036
1037 /* scale + ratate matrix */
1038 status = GdipRotateMatrix(matrix, 45.0, MatrixOrderAppend);
1039 expect(Ok, status);
1040 status = GdipSetWorldTransform(graphics, matrix);
1041 expect(Ok, status);
1042 status = GdipGetLogFontA(font, graphics, &lf);
1043 expect(Ok, status);
1044 expect(-300, lf.lfHeight);
1045 expect(0, lf.lfWidth);
1046 expect_(3151, lf.lfEscapement, 1);
1047 expect_(3151, lf.lfOrientation, 1);
1048 status = GdipGetFontHeight(font, graphics, &height);
1049 expect(Ok, status);
1050 expectf(120.703125, height);
1051 set_rect_empty(&rect);
1052 set_rect_empty(&bounds);
1053 status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
1054 expect(Ok, status);
1055 expectf(0.0, bounds.X);
1056 expectf(0.0, bounds.Y);
1057todo_wine
1058 expectf(height + margin_y, bounds.Height);
1059 set_rect_empty(&rect);
1060 set_rect_empty(&bounds);
1061 status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
1062 expect(Ok, status);
1063 expectf(0.0, bounds.X);
1064 expectf(0.0, bounds.Y);
1065 expectf_(height, bounds.Height, 0.05);
1066 set_rect_empty(&bounds);
1067 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1068 DriverStringOptionsCmapLookup, NULL, &bounds);
1069 expect(Ok, status);
1070 expectf(0.0, bounds.X);
1071 expectf_(-100.0, bounds.Y, 0.05);
1072 expectf_(height, bounds.Height, 0.2);
1073 set_rect_empty(&bounds);
1074 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1075 DriverStringOptionsCmapLookup, matrix, &bounds);
1076 expect(Ok, status);
1077todo_wine
1078 expectf_(-43.814377, bounds.X, 0.05);
1079todo_wine
1080 expectf_(-212.235611, bounds.Y, 0.05);
1081todo_wine
1082 expectf_(340.847534, bounds.Height, 0.05);
1083
1084 /* scale + ratate + shear matrix */
1085 status = GdipShearMatrix(matrix, 4.0, 5.0, MatrixOrderAppend);
1086 expect(Ok, status);
1087 status = GdipSetWorldTransform(graphics, matrix);
1088 expect(Ok, status);
1089 status = GdipGetLogFontA(font, graphics, &lf);
1090 expect(Ok, status);
1091todo_wine
1092 expect(1032, lf.lfHeight);
1093 expect(0, lf.lfWidth);
1094 expect_(3099, lf.lfEscapement, 1);
1095 expect_(3099, lf.lfOrientation, 1);
1096 status = GdipGetFontHeight(font, graphics, &height);
1097 expect(Ok, status);
1098 expectf(120.703125, height);
1099 set_rect_empty(&rect);
1100 set_rect_empty(&bounds);
1101 status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
1102 expect(Ok, status);
1103 expectf(0.0, bounds.X);
1104 expectf(0.0, bounds.Y);
1105todo_wine
1106 expectf(height + margin_y, bounds.Height);
1107 set_rect_empty(&rect);
1108 set_rect_empty(&bounds);
1109 status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
1110 expect(Ok, status);
1111 expectf(0.0, bounds.X);
1112 expectf(0.0, bounds.Y);
1113 expectf_(height, bounds.Height, 0.2);
1114 set_rect_empty(&bounds);
1115 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1116 DriverStringOptionsCmapLookup, NULL, &bounds);
1117 expect(Ok, status);
1118 expectf(0.0, bounds.X);
1119 expectf_(-100.0, bounds.Y, 0.2);
1120 expectf_(height, bounds.Height, 0.2);
1121 set_rect_empty(&bounds);
1122 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1123 DriverStringOptionsCmapLookup, matrix, &bounds);
1124 expect(Ok, status);
1125todo_wine
1126 expectf_(-636.706848, bounds.X, 0.05);
1127todo_wine
1128 expectf_(-175.257523, bounds.Y, 0.05);
1129todo_wine
1130 expectf_(1532.984985, bounds.Height, 0.05);
1131
1132 /* scale + ratate + shear + translate matrix */
1133 status = GdipTranslateMatrix(matrix, 10.0, 20.0, MatrixOrderAppend);
1134 expect(Ok, status);
1135 status = GdipSetWorldTransform(graphics, matrix);
1136 expect(Ok, status);
1137 status = GdipGetLogFontA(font, graphics, &lf);
1138 expect(Ok, status);
1139todo_wine
1140 expect(1032, lf.lfHeight);
1141 expect(0, lf.lfWidth);
1142 expect_(3099, lf.lfEscapement, 1);
1143 expect_(3099, lf.lfOrientation, 1);
1144 status = GdipGetFontHeight(font, graphics, &height);
1145 expect(Ok, status);
1146 expectf(120.703125, height);
1147 set_rect_empty(&rect);
1148 set_rect_empty(&bounds);
1149 status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
1150 expect(Ok, status);
1151 expectf(0.0, bounds.X);
1152 expectf(0.0, bounds.Y);
1153todo_wine
1154 expectf(height + margin_y, bounds.Height);
1155 set_rect_empty(&rect);
1156 set_rect_empty(&bounds);
1157 status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
1158 expect(Ok, status);
1159 expectf(0.0, bounds.X);
1160 expectf(0.0, bounds.Y);
1161 expectf_(height, bounds.Height, 0.1);
1162 set_rect_empty(&bounds);
1163 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1164 DriverStringOptionsCmapLookup, NULL, &bounds);
1165 expect(Ok, status);
1166 expectf(0.0, bounds.X);
1167 expectf_(-100.0, bounds.Y, 0.2);
1168 expectf_(height, bounds.Height, 0.2);
1169 set_rect_empty(&bounds);
1170 status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1171 DriverStringOptionsCmapLookup, matrix, &bounds);
1172 expect(Ok, status);
1173todo_wine
1174 expectf_(-626.706848, bounds.X, 0.05);
1175todo_wine
1176 expectf_(-155.257523, bounds.Y, 0.05);
1177todo_wine
1178 expectf_(1532.984985, bounds.Height, 0.05);
1179
1180 GdipDeleteMatrix(matrix);
1181 GdipDeleteFont(font);
1182 GdipDeleteGraphics(graphics);
1183 GdipDeleteStringFormat(typographic);
1184 GdipDeleteStringFormat(format);
1185 DeleteDC(hdc);
1186}
UINT16
unsigned short UINT16
Definition: ProcessorBind.h:171
GdipMeasureString
GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds, INT *codepointsfitted, INT *linesfilled)
Definition: graphics.c:5550
GdipSetWorldTransform
GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
Definition: graphics.c:6362
GdipMeasureDriverString
GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length, GDIPCONST GpFont *font, GDIPCONST PointF *positions, INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
Definition: graphics.c:7063
GdipSetPageUnit
GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
Definition: graphics.c:6206
GdipScaleMatrix
GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY, GpMatrixOrder order)
Definition: matrix.c:289
GdipShearMatrix
GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix *matrix, REAL shearX, REAL shearY, GpMatrixOrder order)
Definition: matrix.c:335
GdipTranslateMatrix
GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX, REAL offsetY, GpMatrixOrder order)
Definition: matrix.c:418
GdipRotateMatrix
GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle, GpMatrixOrder order)
Definition: matrix.c:258
GdipDeleteMatrix
GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
Definition: matrix.c:160
GdipCreateMatrix
GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
Definition: matrix.c:140
GdipCreateStringFormat
GpStatus WINGDIPAPI GdipCreateStringFormat(INT attr, LANGID lang, GpStringFormat **format)
Definition: stringformat.c:76
GdipStringFormatGetGenericTypographic
GpStatus WINGDIPAPI GdipStringFormatGetGenericTypographic(GpStringFormat **format)
Definition: stringformat.c:408
GdipDeleteStringFormat
GpStatus WINGDIPAPI GdipDeleteStringFormat(GpStringFormat *format)
Definition: stringformat.c:105
MatrixOrderAppend
@ MatrixOrderAppend
Definition: gdiplusenums.h:189
DriverStringOptionsCmapLookup
@ DriverStringOptionsCmapLookup
Definition: gdiplusenums.h:47
height
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
matrix
GLuint GLenum matrix
Definition: glext.h:9407
expectf_
#define expectf_(expected, got, precision)
Definition: font.c:30
set_rect_empty
static void set_rect_empty(RectF *rc)
Definition: font.c:38
expect_
#define expect_(expected, got, precision)
Definition: font.c:29
expectf
#define expectf(expected, got)
Definition: font.c:31
rect
& rect
Definition: startmenu.cpp:1413
LOGFONTA::lfOrientation
LONG lfOrientation
Definition: dimm.idl:45
LOGFONTA::lfHeight
LONG lfHeight
Definition: dimm.idl:42
LOGFONTA::lfEscapement
LONG lfEscapement
Definition: dimm.idl:44
LOGFONTA::lfWidth
LONG lfWidth
Definition: dimm.idl:43
format
Definition: format.c:58

Referenced by START_TEST().

◆ test_fontfamily()

static void test_fontfamily ( void  )
static

Definition at line 307 of file font.c.

308{
309 GpFontFamily *family, *clonedFontFamily;
310 WCHAR itsName[LF_FACESIZE];
311 GpStatus stat;
312
313 /* FontFamily cannot be NULL */
314 stat = GdipCreateFontFamilyFromName (Tahoma , NULL, NULL);
315 expect (InvalidParameter, stat);
316
317 /* FontFamily must be able to actually find the family.
318 * If it can't, any subsequent calls should fail.
319 */
320 stat = GdipCreateFontFamilyFromName (nonexistent, NULL, &family);
321 expect (FontFamilyNotFound, stat);
322
323 /* Bitmap fonts are not found */
324 stat = GdipCreateFontFamilyFromName (MSSansSerif, NULL, &family);
325 expect (FontFamilyNotFound, stat);
326 if(stat == Ok) GdipDeleteFontFamily(family);
327
328 stat = GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
329 expect (Ok, stat);
330
331 stat = GdipGetFamilyName (family, itsName, LANG_NEUTRAL);
332 expect (Ok, stat);
333 expect (0, lstrcmpiW(itsName, Tahoma));
334
335 if (0)
336 {
337 /* Crashes on Windows XP SP2, Vista, and so Wine as well */
338 stat = GdipGetFamilyName (family, NULL, LANG_NEUTRAL);
339 expect (Ok, stat);
340 }
341
342 /* Make sure we don't read old data */
343 ZeroMemory (itsName, sizeof(itsName));
344 stat = GdipCloneFontFamily(family, &clonedFontFamily);
345 expect (Ok, stat);
346 GdipDeleteFontFamily(family);
347 stat = GdipGetFamilyName(clonedFontFamily, itsName, LANG_NEUTRAL);
348 expect(Ok, stat);
349 expect(0, lstrcmpiW(itsName, Tahoma));
350
351 GdipDeleteFontFamily(clonedFontFamily);
352}
GdipCloneFontFamily
GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily *FontFamily, GpFontFamily **clonedFontFamily)
Definition: font.c:803
MSSansSerif
static const WCHAR MSSansSerif[]
Definition: font.c:34
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1737

Referenced by START_TEST().

◆ test_fontfamily_properties()

static void test_fontfamily_properties ( void  )
static

Definition at line 354 of file font.c.

355{
356 GpFontFamily* FontFamily = NULL;
357 GpStatus stat;
358 UINT16 result = 0;
359
360 stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &FontFamily);
361 expect(Ok, stat);
362
363 stat = GdipGetLineSpacing(FontFamily, FontStyleRegular, &result);
364 expect(Ok, stat);
365 ok (result == 2472, "Expected 2472, got %d\n", result);
366 result = 0;
367 stat = GdipGetEmHeight(FontFamily, FontStyleRegular, &result);
368 expect(Ok, stat);
369 ok(result == 2048, "Expected 2048, got %d\n", result);
370 result = 0;
371 stat = GdipGetCellAscent(FontFamily, FontStyleRegular, &result);
372 expect(Ok, stat);
373 ok(result == 2049, "Expected 2049, got %d\n", result);
374 result = 0;
375 stat = GdipGetCellDescent(FontFamily, FontStyleRegular, &result);
376 expect(Ok, stat);
377 ok(result == 423, "Expected 423, got %d\n", result);
378 GdipDeleteFontFamily(FontFamily);
379
380 stat = GdipCreateFontFamilyFromName(TimesNewRoman, NULL, &FontFamily);
381 if(stat == FontFamilyNotFound)
382 skip("Times New Roman not installed\n");
383 else
384 {
385 result = 0;
386 stat = GdipGetLineSpacing(FontFamily, FontStyleRegular, &result);
387 expect(Ok, stat);
388 ok(result == 2355, "Expected 2355, got %d\n", result);
389 result = 0;
390 stat = GdipGetEmHeight(FontFamily, FontStyleRegular, &result);
391 expect(Ok, stat);
392 ok(result == 2048, "Expected 2048, got %d\n", result);
393 result = 0;
394 stat = GdipGetCellAscent(FontFamily, FontStyleRegular, &result);
395 expect(Ok, stat);
396 ok(result == 1825, "Expected 1825, got %d\n", result);
397 result = 0;
398 stat = GdipGetCellDescent(FontFamily, FontStyleRegular, &result);
399 expect(Ok, stat);
400 ok(result == 443, "Expected 443 got %d\n", result);
401 GdipDeleteFontFamily(FontFamily);
402 }
403}
skip
#define skip(...)
Definition: atltest.h:64
result
GLuint64EXT * result
Definition: glext.h:11304
TimesNewRoman
static const WCHAR TimesNewRoman[]
Definition: font.c:35

Referenced by START_TEST().

◆ test_GdipGetFontCollectionFamilyCount()

static void test_GdipGetFontCollectionFamilyCount ( void  )
static

Definition at line 1242 of file font.c.

1243{
1244 GpFontCollection *collection;
1245 GpStatus status;
1246 INT count;
1247
1248 status = GdipGetFontCollectionFamilyCount(NULL, NULL);
1249 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1250
1251 count = 123;
1252 status = GdipGetFontCollectionFamilyCount(NULL, &count);
1253 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1254 ok(count == 123, "Unexpected family count %d.\n", count);
1255
1256 status = GdipNewInstalledFontCollection(&collection);
1257 ok(status == Ok, "Failed to get system collection, status %d.\n", status);
1258
1259 status = GdipGetFontCollectionFamilyCount(collection, NULL);
1260 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1261}
GdipNewInstalledFontCollection
GpStatus WINGDIPAPI GdipNewInstalledFontCollection(GpFontCollection **fontCollection)
Definition: font.c:1679
GdipGetFontCollectionFamilyCount
GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(GpFontCollection *fontCollection, INT *numFound)
Definition: font.c:1559
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
collection
static ICollection collection
Definition: typelib.c:184

Referenced by START_TEST().

◆ test_GdipGetFontCollectionFamilyList()

static void test_GdipGetFontCollectionFamilyList ( void  )
static

Definition at line 1188 of file font.c.

1189{
1190 GpFontFamily *family, *family2;
1191 GpFontCollection *collection;
1192 INT found, count;
1193 GpStatus status;
1194
1195 status = GdipNewInstalledFontCollection(&collection);
1196 ok(status == Ok, "Failed to get system collection, status %d.\n", status);
1197
1198 count = 0;
1199 status = GdipGetFontCollectionFamilyCount(collection, &count);
1200 ok(status == Ok, "Failed to get family count, status %d.\n", status);
1201 ok(count > 0, "Unexpected empty collection.\n");
1202
1203 status = GdipGetFontCollectionFamilyList(NULL, 0, NULL, NULL);
1204 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1205
1206 found = 123;
1207 status = GdipGetFontCollectionFamilyList(NULL, 0, NULL, &found);
1208 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1209 ok(found == 123, "Unexpected list count %d.\n", found);
1210
1211 status = GdipGetFontCollectionFamilyList(collection, 0, NULL, NULL);
1212 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1213
1214 found = 123;
1215 status = GdipGetFontCollectionFamilyList(collection, 0, NULL, &found);
1216 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1217 ok(found == 123, "Unexpected list count %d.\n", found);
1218
1219 found = 123;
1220 status = GdipGetFontCollectionFamilyList(collection, 1, NULL, &found);
1221 ok(status == InvalidParameter, "Unexpected status %d.\n", status);
1222 ok(found == 123, "Unexpected list count %d.\n", found);
1223
1224 family = NULL;
1225 found = 0;
1226 status = GdipGetFontCollectionFamilyList(collection, 1, &family, &found);
1227 ok(status == Ok, "Failed to get family list, status %d.\n", status);
1228 ok(found == 1, "Unexpected list count %d.\n", found);
1229 ok(family != NULL, "Expected family instance.\n");
1230
1231 family = NULL;
1232 found = 0;
1233 status = GdipGetFontCollectionFamilyList(collection, 1, &family2, &found);
1234 ok(status == Ok, "Failed to get family list, status %d.\n", status);
1235 ok(found == 1, "Unexpected list count %d.\n", found);
1236 ok(family2 != family, "Unexpected family instance.\n");
1237
1238 GdipDeleteFontFamily(family);
1239 GdipDeleteFontFamily(family2);
1240}
GdipGetFontCollectionFamilyList
GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(GpFontCollection *fontCollection, INT numSought, GpFontFamily *gpfamilies[], INT *numFound)
Definition: font.c:1574

Referenced by START_TEST().

◆ test_getgenerics()

static void test_getgenerics ( void  )
static

Definition at line 426 of file font.c.

427{
428 GpStatus stat;
429 GpFontFamily *family;
430 WCHAR sansname[LF_FACESIZE], serifname[LF_FACESIZE], mononame[LF_FACESIZE];
431 int missingfonts = 0;
432
433 stat = GdipGetGenericFontFamilySansSerif(&family);
434 expect (Ok, stat);
435 if (stat == FontFamilyNotFound)
436 missingfonts = 1;
437 else
438 check_family("Sans Serif", family, sansname);
439
440 stat = GdipGetGenericFontFamilySerif(&family);
441 expect (Ok, stat);
442 if (stat == FontFamilyNotFound)
443 missingfonts = 1;
444 else
445 check_family("Serif", family, serifname);
446
447 stat = GdipGetGenericFontFamilyMonospace(&family);
448 expect (Ok, stat);
449 if (stat == FontFamilyNotFound)
450 missingfonts = 1;
451 else
452 check_family("Monospace", family, mononame);
453
454 if (missingfonts && strcmp(winetest_platform, "wine") == 0)
455 trace("You may need to install either the Microsoft Web Fonts or the Liberation Fonts\n");
456
457 /* Check that the family names are all different */
458 ok(lstrcmpiW(sansname, serifname) != 0, "Sans Serif and Serif families should be different: %s\n", wine_dbgstr_w(sansname));
459 ok(lstrcmpiW(sansname, mononame) != 0, "Sans Serif and Monospace families should be different: %s\n", wine_dbgstr_w(sansname));
460 ok(lstrcmpiW(serifname, mononame) != 0, "Serif and Monospace families should be different: %s\n", wine_dbgstr_w(serifname));
461}
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
GdipGetGenericFontFamilySerif
GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily)
Definition: font.c:1041
GdipGetGenericFontFamilySansSerif
GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily)
Definition: font.c:1074
GdipGetGenericFontFamilyMonospace
GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily)
Definition: font.c:1010
check_family
static void check_family(const char *context, GpFontFamily *family, WCHAR *name)
Definition: font.c:405
winetest_platform
const char * winetest_platform

Referenced by START_TEST().

◆ test_heightgivendpi()

static void test_heightgivendpi ( void  )
static

Definition at line 476 of file font.c.

477{
478 GpStatus stat;
479 GpFont* font = NULL;
480 GpFontFamily* fontfamily = NULL;
481 REAL height;
482 Unit unit;
483
484 stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &fontfamily);
485 expect(Ok, stat);
486
487 stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitPixel, &font);
488 expect(Ok, stat);
489
490 stat = GdipGetFontHeightGivenDPI(NULL, 96, &height);
491 expect(InvalidParameter, stat);
492
493 stat = GdipGetFontHeightGivenDPI(font, 96, NULL);
494 expect(InvalidParameter, stat);
495
496 stat = GdipGetFontHeightGivenDPI(font, 96, &height);
497 expect(Ok, stat);
498 expectf(36.210938, height);
499 GdipDeleteFont(font);
500
501 height = 12345;
502 stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitWorld, &font);
503 expect(Ok, stat);
504
505 stat = GdipGetFontUnit(font, &unit);
506 expect(Ok, stat);
507 expect(UnitWorld, unit);
508
509 stat = GdipGetFontHeightGivenDPI(font, 96, &height);
510 expect(Ok, stat);
511 expectf(36.210938, height);
512 GdipDeleteFont(font);
513
514 height = 12345;
515 stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitPoint, &font);
516 expect(Ok, stat);
517 stat = GdipGetFontHeightGivenDPI(font, 96, &height);
518 expect(Ok, stat);
519 expectf(48.281250, height);
520 GdipDeleteFont(font);
521
522 height = 12345;
523 stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitInch, &font);
524 expect(Ok, stat);
525
526 stat = GdipGetFontUnit(font, &unit);
527 expect(Ok, stat);
528 expect(UnitInch, unit);
529
530 stat = GdipGetFontHeightGivenDPI(font, 96, &height);
531 expect(Ok, stat);
532 expectf(3476.250000, height);
533 GdipDeleteFont(font);
534
535 height = 12345;
536 stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitDocument, &font);
537 expect(Ok, stat);
538
539 stat = GdipGetFontUnit(font, &unit);
540 expect(Ok, stat);
541 expect(UnitDocument, unit);
542
543 stat = GdipGetFontHeightGivenDPI(font, 96, &height);
544 expect(Ok, stat);
545 expectf(11.587500, height);
546 GdipDeleteFont(font);
547
548 height = 12345;
549 stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitMillimeter, &font);
550 expect(Ok, stat);
551
552 stat = GdipGetFontUnit(font, &unit);
553 expect(Ok, stat);
554 expect(UnitMillimeter, unit);
555
556 stat = GdipGetFontHeightGivenDPI(font, 96, &height);
557 expect(Ok, stat);
558 expectf(136.860245, height);
559 GdipDeleteFont(font);
560
561 GdipDeleteFontFamily(fontfamily);
562}
GdipGetFontHeightGivenDPI
GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height)
Definition: font.c:599
UnitDocument
@ UnitDocument
Definition: gdiplusenums.h:32
UnitInch
@ UnitInch
Definition: gdiplusenums.h:31

Referenced by START_TEST().

◆ test_installedfonts()

static void test_installedfonts ( void  )
static

Definition at line 463 of file font.c.

464{
465 GpStatus stat;
466 GpFontCollection* collection=NULL;
467
468 stat = GdipNewInstalledFontCollection(NULL);
469 expect (InvalidParameter, stat);
470
471 stat = GdipNewInstalledFontCollection(&collection);
472 expect (Ok, stat);
473 ok (collection != NULL, "got NULL font collection\n");
474}

Referenced by START_TEST().

◆ test_logfont()

static void test_logfont ( void  )
static

Definition at line 171 of file font.c.

172{
173 LOGFONTA lfa, lfa2;
174 GpFont *font;
175 GpFontFamily *family;
176 GpStatus stat;
177 GpGraphics *graphics;
178 HDC hdc = GetDC(0);
179 INT style;
180 REAL rval;
181 UINT16 em_height, line_spacing;
182 Unit unit;
183
184 stat = GdipCreateFromHDC(hdc, &graphics);
185 expect(Ok, stat);
186
187 memset(&lfa, 0, sizeof(LOGFONTA));
188 memset(&lfa2, 0xff, sizeof(LOGFONTA));
189 lstrcpyA(lfa.lfFaceName, "Tahoma");
190
191 stat = GdipCreateFontFromLogfontA(hdc, &lfa, &font);
192 expect(Ok, stat);
193 stat = GdipGetLogFontA(font, graphics, &lfa2);
194 expect(Ok, stat);
195
196 ok(lfa2.lfHeight < 0, "Expected negative height\n");
197 expect(0, lfa2.lfWidth);
198 expect(0, lfa2.lfEscapement);
199 expect(0, lfa2.lfOrientation);
200 ok((lfa2.lfWeight >= 100) && (lfa2.lfWeight <= 900), "Expected weight to be set\n");
201 expect(0, lfa2.lfItalic);
202 expect(0, lfa2.lfUnderline);
203 expect(0, lfa2.lfStrikeOut);
204 ok(lfa2.lfCharSet == GetTextCharset(hdc) || lfa2.lfCharSet == ANSI_CHARSET,
205 "Expected %x or %x, got %x\n", GetTextCharset(hdc), ANSI_CHARSET, lfa2.lfCharSet);
206 expect(0, lfa2.lfOutPrecision);
207 expect(0, lfa2.lfClipPrecision);
208 expect(0, lfa2.lfQuality);
209 expect(0, lfa2.lfPitchAndFamily);
210
211 GdipDeleteFont(font);
212
213 memset(&lfa, 0, sizeof(LOGFONTA));
214 lfa.lfHeight = 25;
215 lfa.lfWidth = 25;
216 lfa.lfEscapement = lfa.lfOrientation = 50;
217 lfa.lfItalic = lfa.lfUnderline = lfa.lfStrikeOut = TRUE;
218
219 memset(&lfa2, 0xff, sizeof(LOGFONTA));
220 lstrcpyA(lfa.lfFaceName, "Tahoma");
221
222 stat = GdipCreateFontFromLogfontA(hdc, &lfa, &font);
223 expect(Ok, stat);
224 stat = GdipGetLogFontA(font, graphics, &lfa2);
225 expect(Ok, stat);
226
227 ok(lfa2.lfHeight < 0, "Expected negative height\n");
228 expect(0, lfa2.lfWidth);
229 expect(0, lfa2.lfEscapement);
230 expect(0, lfa2.lfOrientation);
231 ok((lfa2.lfWeight >= 100) && (lfa2.lfWeight <= 900), "Expected weight to be set\n");
232 expect(TRUE, lfa2.lfItalic);
233 expect(TRUE, lfa2.lfUnderline);
234 expect(TRUE, lfa2.lfStrikeOut);
235 ok(lfa2.lfCharSet == GetTextCharset(hdc) || lfa2.lfCharSet == ANSI_CHARSET,
236 "Expected %x or %x, got %x\n", GetTextCharset(hdc), ANSI_CHARSET, lfa2.lfCharSet);
237 expect(0, lfa2.lfOutPrecision);
238 expect(0, lfa2.lfClipPrecision);
239 expect(0, lfa2.lfQuality);
240 expect(0, lfa2.lfPitchAndFamily);
241
242 stat = GdipGetFontStyle(font, &style);
243 expect(Ok, stat);
244 ok (style == (FontStyleItalic | FontStyleUnderline | FontStyleStrikeout),
245 "Expected , got %d\n", style);
246
247 stat = GdipGetFontUnit(font, &unit);
248 expect(Ok, stat);
249 expect(UnitWorld, unit);
250
251 stat = GdipGetFontHeight(font, graphics, &rval);
252 expect(Ok, stat);
253 expectf(25.347656, rval);
254 stat = GdipGetFontSize(font, &rval);
255 expect(Ok, stat);
256 expectf(21.0, rval);
257
258 stat = GdipGetFamily(font, &family);
259 expect(Ok, stat);
260 stat = GdipGetEmHeight(family, FontStyleRegular, &em_height);
261 expect(Ok, stat);
262 expect(2048, em_height);
263 stat = GdipGetLineSpacing(family, FontStyleRegular, &line_spacing);
264 expect(Ok, stat);
265 expect(2472, line_spacing);
266 GdipDeleteFontFamily(family);
267
268 GdipDeleteFont(font);
269
270 memset(&lfa, 0, sizeof(lfa));
271 lfa.lfHeight = -25;
272 lstrcpyA(lfa.lfFaceName, "Tahoma");
273 stat = GdipCreateFontFromLogfontA(hdc, &lfa, &font);
274 expect(Ok, stat);
275 memset(&lfa2, 0xff, sizeof(lfa2));
276 stat = GdipGetLogFontA(font, graphics, &lfa2);
277 expect(Ok, stat);
278 expect(lfa.lfHeight, lfa2.lfHeight);
279
280 stat = GdipGetFontUnit(font, &unit);
281 expect(Ok, stat);
282 expect(UnitWorld, unit);
283
284 stat = GdipGetFontHeight(font, graphics, &rval);
285 expect(Ok, stat);
286 expectf(30.175781, rval);
287 stat = GdipGetFontSize(font, &rval);
288 expect(Ok, stat);
289 expectf(25.0, rval);
290
291 stat = GdipGetFamily(font, &family);
292 expect(Ok, stat);
293 stat = GdipGetEmHeight(family, FontStyleRegular, &em_height);
294 expect(Ok, stat);
295 expect(2048, em_height);
296 stat = GdipGetLineSpacing(family, FontStyleRegular, &line_spacing);
297 expect(Ok, stat);
298 expect(2472, line_spacing);
299 GdipDeleteFontFamily(family);
300
301 GdipDeleteFont(font);
302
303 GdipDeleteGraphics(graphics);
304 ReleaseDC(0, hdc);
305}
rval
float rval
Definition: cylfrac.c:48
TRUE
#define TRUE
Definition: types.h:120
FontStyleUnderline
@ FontStyleUnderline
Definition: gdiplusenums.h:307
FontStyleStrikeout
@ FontStyleStrikeout
Definition: gdiplusenums.h:308
FontStyleItalic
@ FontStyleItalic
Definition: gdiplusenums.h:305
LOGFONTA::lfStrikeOut
BYTE lfStrikeOut
Definition: dimm.idl:49
LOGFONTA::lfClipPrecision
BYTE lfClipPrecision
Definition: dimm.idl:52
LOGFONTA::lfUnderline
BYTE lfUnderline
Definition: dimm.idl:48
LOGFONTA::lfQuality
BYTE lfQuality
Definition: dimm.idl:53
LOGFONTA::lfOutPrecision
BYTE lfOutPrecision
Definition: dimm.idl:51
LOGFONTA::lfItalic
BYTE lfItalic
Definition: dimm.idl:47
LOGFONTA::lfPitchAndFamily
BYTE lfPitchAndFamily
Definition: dimm.idl:54
GetTextCharset
int WINAPI GetTextCharset(_In_ HDC)
Definition: text.c:187
ANSI_CHARSET
#define ANSI_CHARSET
Definition: wingdi.h:383
ReleaseDC
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
GetDC
HDC WINAPI GetDC(_In_opt_ HWND)

◆ test_long_name()

static void test_long_name ( void  )
static

Definition at line 74 of file font.c.

75{
76 WCHAR path[MAX_PATH];
77 static const WCHAR path_longname[] = {'w','i','n','e','_','l','o','n','g','n','a','m','e','.','t','t','f',0};
78 GpStatus stat;
79 GpFontCollection *fonts;
80 INT num_families;
81 GpFontFamily *family;
82 WCHAR family_name[LF_FACESIZE];
83 GpFont *font;
84
85 stat = GdipNewPrivateFontCollection(&fonts);
86 ok(stat == Ok, "GdipNewPrivateFontCollection failed: %d\n", stat);
87
88 create_testfontfile(path_longname, 1, path);
89
90 stat = GdipPrivateAddFontFile(fonts, path);
91 ok(stat == Ok, "GdipPrivateAddFontFile failed: %d\n", stat);
92
93 stat = GdipGetFontCollectionFamilyCount(fonts, &num_families);
94 ok(stat == Ok, "GdipGetFontCollectionFamilyCount failed: %d\n", stat);
95
96 ok(num_families == 1, "expected num_families to be 1, got %d\n", num_families);
97
98 stat = GdipGetFontCollectionFamilyList(fonts, num_families, &family, &num_families);
99 ok(stat == Ok, "GdipGetFontCollectionFamilyList failed: %d\n", stat);
100
101 stat = GdipGetFamilyName(family, family_name, LANG_NEUTRAL);
102 ok(stat == Ok, "GdipGetFamilyName failed: %d\n", stat);
103
104 stat = GdipCreateFont(family, 256.0, FontStyleRegular, UnitPixel, &font);
105 ok(stat == Ok, "GdipCreateFont failed: %d\n", stat);
106
107 /* Cleanup */
108
109 stat = GdipDeleteFont(font);
110 ok(stat == Ok, "GdipDeleteFont failed: %d\n", stat);
111
112 stat = GdipDeletePrivateFontCollection(&fonts);
113 ok(stat == Ok, "GdipDeletePrivateFontCollection failed: %d\n", stat);
114
115 DELETE_FONTFILE(path);
116}
GdipDeletePrivateFontCollection
GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection **fontCollection)
Definition: font.c:1118
GdipPrivateAddFontFile
GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection *collection, GDIPCONST WCHAR *name)
Definition: font.c:1137
GdipNewPrivateFontCollection
GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection **fontCollection)
Definition: font.c:1096
DELETE_FONTFILE
#define DELETE_FONTFILE(filename)
Definition: font.c:67
create_testfontfile
static void create_testfontfile(const WCHAR *filename, int resource, WCHAR pathW[MAX_PATH])
Definition: font.c:46
family_name
T1_FIELD_DICT_FONTDICT family_name
Definition: t1tokens.h:30

Referenced by START_TEST().

Variable Documentation

◆ MSSansSerif

const WCHAR MSSansSerif[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'}
static

Definition at line 34 of file font.c.

Referenced by test_fontfamily().

◆ nonexistent

const WCHAR nonexistent[] = {'T','h','i','s','F','o','n','t','s','h','o','u','l','d','N','o','t','E','x','i','s','t','\0'}
static

Definition at line 33 of file font.c.

Referenced by test_createconfigstream(), test_createfont(), test_CryptCATCDF_params(), test_FindFirstFileA(), test_font_substitution(), and test_fontfamily().

◆ Tahoma

const WCHAR Tahoma[] = {'T','a','h','o','m','a',0}
static

Definition at line 36 of file font.c.

Referenced by GdipGetGenericFontFamilySansSerif(), test_createfont(), test_font_metrics(), test_fontfamily(), test_fontfamily_properties(), and test_heightgivendpi().

◆ TimesNewRoman

const WCHAR TimesNewRoman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'}
static

Definition at line 35 of file font.c.

Referenced by GdipGetGenericFontFamilySerif(), and test_fontfamily_properties().