Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-25 12:14:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

[GDI32_WINETEST]

Browse source 
* Sync with Wine 1.7.17.
CORE-8080

svn path=/trunk/; revision=62835
This commit is contained in:
Amine Khaldi 2014-04-20 13:01:01 +00:00
parent ca20207552
commit 52a7f09dd3
22 changed files with 3049 additions and 648 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
rostests/winetests/gdi32/CMakeLists.txt
View file

@ -19,7 +19,9 @@ list(APPEND SOURCE
testlist.c)
add_executable(gdi32_winetest ${SOURCE} resource.rc)
set_module_type(gdi32_winetest win32cui)
add_importlibs(gdi32_winetest gdi32 user32 advapi32 msvcrt kernel32 ntdll)
add_importlibs(gdi32_winetest gdi32 user32 advapi32 msvcrt kernel32)
if(MSVC)
add_importlibs(gdi32_winetest ntdll)
endif()
add_cd_file(TARGET gdi32_winetest DESTINATION reactos/bin FOR all)

139
rostests/winetests/gdi32/bitmap.c
View file

@ -59,7 +59,7 @@ static void test_bitmap_info(HBITMAP hbm, INT expected_depth, const BITMAPINFOHE
INT ret, width_bytes;
BYTE buf[512], buf_cmp[512];
ret = GetObject(hbm, sizeof(bm), &bm);
ret = GetObjectW(hbm, sizeof(bm), &bm);
ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
@ -88,19 +88,19 @@ static void test_bitmap_info(HBITMAP hbm, INT expected_depth, const BITMAPINFOHE
"buffers do not match, depth %d\n", bmih->biBitCount);
/* test various buffer sizes for GetObject */
ret = GetObject(hbm, sizeof(*bma) * 2, bma);
ret = GetObjectW(hbm, sizeof(*bma) * 2, bma);
ok(ret == sizeof(*bma), "wrong size %d\n", ret);
ret = GetObject(hbm, sizeof(bm) / 2, &bm);
ret = GetObjectW(hbm, sizeof(bm) / 2, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbm, 0, &bm);
ret = GetObjectW(hbm, 0, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbm, 1, &bm);
ret = GetObjectW(hbm, 1, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbm, 0, NULL);
ret = GetObjectW(hbm, 0, NULL);
ok(ret == sizeof(bm), "wrong size %d\n", ret);
}
@ -248,7 +248,7 @@ static void test_dib_info(HBITMAP hbm, const void *bits, const BITMAPINFOHEADER
INT ret, bm_width_bytes, dib_width_bytes;
BYTE *buf;
ret = GetObject(hbm, sizeof(bm), &bm);
ret = GetObjectW(hbm, sizeof(bm), &bm);
ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
@ -280,30 +280,30 @@ static void test_dib_info(HBITMAP hbm, const void *bits, const BITMAPINFOHEADER
/* test various buffer sizes for GetObject */
memset(&ds, 0xAA, sizeof(ds));
ret = GetObject(hbm, sizeof(*bma) * 2, bma);
ret = GetObjectW(hbm, sizeof(*bma) * 2, bma);
ok(ret == sizeof(*bma), "wrong size %d\n", ret);
ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
ok(bm.bmHeight == abs(bmih->biHeight), "wrong bm.bmHeight %d\n", bm.bmHeight);
ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);
ret = GetObject(hbm, sizeof(bm) / 2, &bm);
ret = GetObjectW(hbm, sizeof(bm) / 2, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbm, 0, &bm);
ret = GetObjectW(hbm, 0, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbm, 1, &bm);
ret = GetObjectW(hbm, 1, &bm);
ok(ret == 0, "%d != 0\n", ret);
/* test various buffer sizes for GetObject */
ret = GetObject(hbm, 0, NULL);
ret = GetObjectW(hbm, 0, NULL);
ok(ret == sizeof(bm), "wrong size %d\n", ret);
ret = GetObject(hbm, sizeof(*dsa) * 2, dsa);
ret = GetObjectW(hbm, sizeof(*dsa) * 2, dsa);
ok(ret == sizeof(*dsa), "wrong size %d\n", ret);
memset(&ds, 0xAA, sizeof(ds));
ret = GetObject(hbm, sizeof(ds), &ds);
ret = GetObjectW(hbm, sizeof(ds), &ds);
ok(ret == sizeof(ds), "wrong size %d\n", ret);
ok(ds.dsBm.bmBits == bits, "wrong bm.bmBits %p != %p\n", ds.dsBm.bmBits, bits);
@ -326,16 +326,16 @@ static void test_dib_info(HBITMAP hbm, const void *bits, const BITMAPINFOHEADER
ok(ds.dsBmih.biYPelsPerMeter == bmih->biYPelsPerMeter, "%d != %d\n", ds.dsBmih.biYPelsPerMeter, bmih->biYPelsPerMeter);
memset(&ds, 0xAA, sizeof(ds));
ret = GetObject(hbm, sizeof(ds) - 4, &ds);
ret = GetObjectW(hbm, sizeof(ds) - 4, &ds);
ok(ret == sizeof(ds.dsBm), "wrong size %d\n", ret);
ok(ds.dsBm.bmWidth == bmih->biWidth, "%d != %d\n", ds.dsBmih.biWidth, bmih->biWidth);
ok(ds.dsBm.bmHeight == abs(bmih->biHeight), "%d != %d\n", ds.dsBmih.biHeight, abs(bmih->biHeight));
ok(ds.dsBm.bmBits == bits, "%p != %p\n", ds.dsBm.bmBits, bits);
ret = GetObject(hbm, 0, &ds);
ret = GetObjectW(hbm, 0, &ds);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbm, 1, &ds);
ret = GetObjectW(hbm, 1, &ds);
ok(ret == 0, "%d != 0\n", ret);
}
@ -457,7 +457,7 @@ static void test_dibsections(void)
hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
ok(dibsec.dsBm.bmBits == bits, "dibsec.dsBits %p != bits %p\n", dibsec.dsBm.bmBits, bits);
/* test the DIB memory */
@ -530,7 +530,7 @@ static void test_dibsections(void)
hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
ok(dibsec.dsBmih.biClrUsed == 2,
"created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
@ -626,7 +626,7 @@ static void test_dibsections(void)
}
hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(dibsec.dsBmih.biClrUsed == 16,
"created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 16);
test_dib_info(hdib, bits, &pbmi->bmiHeader);
@ -644,7 +644,7 @@ static void test_dibsections(void)
}
hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(dibsec.dsBmih.biClrUsed == 256,
"created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
@ -678,7 +678,7 @@ static void test_dibsections(void)
oldpal = SelectPalette(hdc, hpal, TRUE);
hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(dibsec.dsBmih.biClrUsed == 2, "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
/* The colour table has already been grabbed from the dc, so we select back the
@ -767,7 +767,7 @@ static void test_dibsections(void)
oldpal = SelectPalette(hdc, hpal, TRUE);
hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(dibsec.dsBmih.biClrUsed == 256, "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
test_dib_info(hdib, bits, &pbmi->bmiHeader);
@ -805,7 +805,7 @@ static void test_dibsections(void)
pbmi->bmiHeader.biClrUsed = 142;
hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(dibsec.dsBmih.biClrUsed == 256, "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
test_dib_info(hdib, bits, &pbmi->bmiHeader);
@ -863,7 +863,7 @@ static void test_dibsections(void)
pbmi->bmiHeader.biClrUsed = 37;
hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
ok(hdib != NULL, "CreateDIBSection failed\n");
ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
ok(dibsec.dsBmih.biClrUsed == 0, "created DIBSection: wrong biClrUsed field: %u\n", dibsec.dsBmih.biClrUsed);
oldbm = SelectObject(hdcmem, hdib);
ret = GetDIBColorTable(hdcmem, 0, 256, rgb);
@ -1209,6 +1209,49 @@ static void test_dib_formats(void)
ret = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS+2);
ok( !ret, "GetDIBits succeeded with DIB_PAL_COLORS+2\n" );
bi->bmiHeader.biWidth = 0x4000;
bi->bmiHeader.biHeight = 0x4000;
bi->bmiHeader.biBitCount = 1;
bi->bmiHeader.biCompression = BI_RGB;
hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
ok( hdib != NULL, "CreateDIBSection failed with large size\n" );
DeleteObject( hdib );
bi->bmiHeader.biWidth = 0x8001;
bi->bmiHeader.biHeight = 0x8001;
bi->bmiHeader.biBitCount = 32;
bi->bmiHeader.biCompression = BI_RGB;
hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );
bi->bmiHeader.biWidth = 1;
bi->bmiHeader.biHeight = 0x40000001;
bi->bmiHeader.biBitCount = 32;
bi->bmiHeader.biCompression = BI_RGB;
hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );
bi->bmiHeader.biWidth = 2;
bi->bmiHeader.biHeight = 0x40000001;
bi->bmiHeader.biBitCount = 16;
bi->bmiHeader.biCompression = BI_RGB;
hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );
bi->bmiHeader.biWidth = 0x40000001;
bi->bmiHeader.biHeight = 1;
bi->bmiHeader.biBitCount = 32;
bi->bmiHeader.biCompression = BI_RGB;
hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );
bi->bmiHeader.biWidth = 0x40000001;
bi->bmiHeader.biHeight = 4;
bi->bmiHeader.biBitCount = 8;
bi->bmiHeader.biCompression = BI_RGB;
hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );
DeleteDC( memdc );
DeleteObject( hbmp );
ReleaseDC( 0, hdc );
@ -1305,7 +1348,7 @@ static void test_mono_dibsection(void)
SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
/* SetDIBitsToDevice with a inverted bmi -> normal dib section */
/* SetDIBitsToDevice with an inverted bmi -> normal dib section */
colors[0].rgbRed = 0xff;
colors[0].rgbGreen = 0xff;
@ -1390,7 +1433,7 @@ static void test_mono_dibsection(void)
SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
/* SetDIBitsToDevice with a inverted bmi -> inverted dib section */
/* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
colors[0].rgbRed = 0xff;
colors[0].rgbGreen = 0xff;
@ -1455,7 +1498,7 @@ static void test_bitmap(void)
hbmp = CreateBitmap(15, 15, 1, 1, NULL);
assert(hbmp != NULL);
ret = GetObject(hbmp, sizeof(bm), &bm);
ret = GetObjectW(hbmp, sizeof(bm), &bm);
ok(ret == sizeof(bm), "wrong size %d\n", ret);
ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
@ -1482,7 +1525,7 @@ static void test_bitmap(void)
hbmp_old = SelectObject(hdc, hbmp);
ret = GetObject(hbmp, sizeof(bm), &bm);
ret = GetObjectW(hbmp, sizeof(bm), &bm);
ok(ret == sizeof(bm), "wrong size %d\n", ret);
ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
@ -1502,16 +1545,16 @@ static void test_bitmap(void)
ok(hbmp_old == hbmp, "wrong old bitmap %p\n", hbmp_old);
/* test various buffer sizes for GetObject */
ret = GetObject(hbmp, sizeof(*bma) * 2, bma);
ret = GetObjectW(hbmp, sizeof(*bma) * 2, bma);
ok(ret == sizeof(*bma), "wrong size %d\n", ret);
ret = GetObject(hbmp, sizeof(bm) / 2, &bm);
ret = GetObjectW(hbmp, sizeof(bm) / 2, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbmp, 0, &bm);
ret = GetObjectW(hbmp, 0, &bm);
ok(ret == 0, "%d != 0\n", ret);
ret = GetObject(hbmp, 1, &bm);
ret = GetObjectW(hbmp, 1, &bm);
ok(ret == 0, "%d != 0\n", ret);
DeleteObject(hbmp);
@ -1523,7 +1566,7 @@ static COLORREF get_nearest( int r, int g, int b )
return (r*r + g*g + b*b < (255-r)*(255-r) + (255-g)*(255-g) + (255-b)*(255-b)) ? 0x000000 : 0xffffff;
}
static int is_black_pen( COLORREF fg, COLORREF bg, int r, int g, int b )
static BOOL is_black_pen( COLORREF fg, COLORREF bg, int r, int g, int b )
{
if (fg == 0 || bg == 0xffffff) return RGB(r,g,b) != 0xffffff && RGB(r,g,b) != bg;
return RGB(r,g,b) == 0x000000 || RGB(r,g,b) == bg;
@ -1532,8 +1575,9 @@ static int is_black_pen( COLORREF fg, COLORREF bg, int r, int g, int b )
static void test_bitmap_colors( HDC hdc, COLORREF fg, COLORREF bg, int r, int g, int b )
{
static const WORD pattern_bits[] = { 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa };
BITMAPINFO *info;
RGBQUAD *colors;
char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors ) + 256 * sizeof(RGBQUAD)];
BITMAPINFO *info = (BITMAPINFO *)buffer;
RGBQUAD *colors = info->bmiColors;
WORD bits[16];
void *bits_ptr;
COLORREF res;
@ -1569,7 +1613,7 @@ static void test_bitmap_colors( HDC hdc, COLORREF fg, COLORREF bg, int r, int g,
old_brush = SelectObject( hdc, CreatePatternBrush( bitmap ));
PatBlt( hdc, 0, 0, 16, 16, PATCOPY );
GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
ok( bits[0] == 0x5555,
ok( bits[0] == 0x5555 || broken(bits[0] == 0xaada) /* XP SP1 & 2003 SP0 */,
"wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
DeleteObject( SelectObject( hdc, old_brush ));
@ -1588,8 +1632,7 @@ static void test_bitmap_colors( HDC hdc, COLORREF fg, COLORREF bg, int r, int g,
"wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
/* mono DIB section */
info = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET( BITMAPINFO, bmiColors[256] ) );
colors = info->bmiColors;
memset( buffer, 0, sizeof(buffer) );
info->bmiHeader.biSize = sizeof(info->bmiHeader);
info->bmiHeader.biHeight = -16;
info->bmiHeader.biWidth = 16;
@ -1639,7 +1682,6 @@ static void test_bitmap_colors( HDC hdc, COLORREF fg, COLORREF bg, int r, int g,
"wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
DeleteDC( memdc );
DeleteObject( bitmap );
HeapFree( GetProcessHeap(), 0, info );
}
static void test_mono_bitmap(void)
@ -1691,6 +1733,7 @@ static void test_mono_bitmap(void)
test_color( hdc, PALETTEINDEX(i), get_nearest( ent.peRed, ent.peGreen, ent.peBlue ));
test_color( hdc, DIBINDEX(i), (i == 1) ? 0xffffff : 0x000000 );
}
for (r = 0; r < 256; r += 15)
for (g = 0; g < 256; g += 15)
for (b = 0; b < 256; b += 15)
@ -1712,7 +1755,7 @@ static void test_bmBits(void)
ok(hbmp != NULL, "CreateBitmap failed\n");
memset(&bmp, 0xFF, sizeof(bmp));
ok(GetObject(hbmp, sizeof(bmp), &bmp) == sizeof(bmp),
ok(GetObjectW(hbmp, sizeof(bmp), &bmp) == sizeof(bmp),
"GetObject failed or returned a wrong structure size\n");
ok(!bmp.bmBits, "bmBits must be NULL for device-dependent bitmaps\n");
@ -2048,7 +2091,7 @@ static void test_GetDIBits(void)
ok(hbmp != 0, "CreateBitmap failed\n");
memset(&bm, 0xAA, sizeof(bm));
bytes = GetObject(hbmp, sizeof(bm), &bm);
bytes = GetObjectW(hbmp, sizeof(bm), &bm);
ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
@ -2164,7 +2207,7 @@ static void test_GetDIBits(void)
lines, bm.bmHeight, GetLastError());
memset(&bm, 0xAA, sizeof(bm));
bytes = GetObject(hbmp, sizeof(bm), &bm);
bytes = GetObjectW(hbmp, sizeof(bm), &bm);
ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
@ -2640,7 +2683,7 @@ static void test_select_object(void)
}
memset(&bm, 0xAA, sizeof(bm));
bytes = GetObject(hbm, sizeof(bm), &bm);
bytes = GetObjectW(hbm, sizeof(bm), &bm);
ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
ok(bm.bmWidth == 10, "wrong bmWidth %d\n", bm.bmWidth);
@ -2668,12 +2711,12 @@ static void test_mono_1x1_bmp_dbg(HBITMAP hbmp, int line)
ret = GetObjectType(hbmp);
ok_(__FILE__, line)(ret == OBJ_BITMAP, "the object %p is not bitmap\n", hbmp);
ret = GetObject(hbmp, 0, 0);
ret = GetObjectW(hbmp, 0, 0);
ok_(__FILE__, line)(ret == sizeof(BITMAP), "object size %d\n", ret);
memset(&bm, 0xDA, sizeof(bm));
SetLastError(0xdeadbeef);
ret = GetObject(hbmp, sizeof(bm), &bm);
ret = GetObjectW(hbmp, sizeof(bm), &bm);
if (!ret) /* XP, only for curObj2 */ return;
ok_(__FILE__, line)(ret == sizeof(BITMAP), "GetObject returned %d, error %u\n", ret, GetLastError());
ok_(__FILE__, line)(bm.bmType == 0, "wrong bmType, expected 0 got %d\n", bm.bmType);
@ -2770,7 +2813,7 @@ todo_wine
continue;
}
ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
GetObject(bm, sizeof(bmp), &bmp);
GetObjectW(bm, sizeof(bmp), &bmp);
if(i == 1) {
expect = 1;
} else if(i <= 4) {
@ -5585,7 +5628,7 @@ START_TEST(bitmap)
{
HMODULE hdll;
hdll = GetModuleHandle("gdi32.dll");
hdll = GetModuleHandleA("gdi32.dll");
pGdiAlphaBlend = (void*)GetProcAddress(hdll, "GdiAlphaBlend");
pGdiGradientFill = (void*)GetProcAddress(hdll, "GdiGradientFill");
pSetLayout = (void*)GetProcAddress(hdll, "SetLayout");

8
rostests/winetests/gdi32/brush.c
View file

@ -59,20 +59,20 @@ static void test_solidbrush(void)
else
stockBrush = NULL;
memset(&br, 0, sizeof(br));
ret = GetObject(solidBrush, sizeof(br), &br);
ret = GetObjectW(solidBrush, sizeof(br), &br);
ok( ret !=0, "GetObject on solid %s brush failed, error=%d\n", stock[i].name, GetLastError());
ok(br.lbStyle==BS_SOLID, "%s brush has wrong style, got %d expected %d\n", stock[i].name, br.lbStyle, BS_SOLID);
ok(br.lbColor==stock[i].color, "%s brush has wrong color, got 0x%08x expected 0x%08x\n", stock[i].name, br.lbColor, stock[i].color);
if(stockBrush) {
/* Sanity check, make sure the colors being compared do in fact have a stock brush */
ret = GetObject(stockBrush, sizeof(br), &br);
ret = GetObjectW(stockBrush, sizeof(br), &br);
ok( ret !=0, "GetObject on stock %s brush failed, error=%d\n", stock[i].name, GetLastError());
ok(br.lbColor==stock[i].color, "stock %s brush unexpected color, got 0x%08x expected 0x%08x\n", stock[i].name, br.lbColor, stock[i].color);
}
DeleteObject(solidBrush);
ret = GetObject(solidBrush, sizeof(br), &br);
ret = GetObjectW(solidBrush, sizeof(br), &br);
ok(ret==0 ||
broken(ret!=0), /* win9x */
"GetObject succeeded on a deleted %s brush\n", stock[i].name);
@ -92,7 +92,7 @@ static void test_hatch_brush(void)
if (i < HS_API_MAX)
{
ok( brush != 0, "%u: CreateHatchBrush failed err %u\n", i, GetLastError() );
size = GetObject( brush, sizeof(lb), &lb );
size = GetObjectW( brush, sizeof(lb), &lb );
ok( size == sizeof(lb), "wrong size %u\n", size );
ok( lb.lbColor == RGB(12,34,56), "wrong color %08x\n", lb.lbColor );
if (i <= HS_DIAGCROSS)

44
rostests/winetests/gdi32/clipping.c
View file

@ -2,6 +2,7 @@
* Unit test suite for clipping
*
* Copyright 2005 Huw Davies
* Copyright 2008,2011,2013 Dmitry Timoshkov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -388,6 +389,12 @@ static void test_memory_dc_clipping(void)
ret = GetClipRgn(hdc, hrgn);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = ExtSelectClipRgn(hdc, 0, RGN_DIFF);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = GetClipRgn(hdc, hrgn);
ok(ret == 0, "expected 0, got %d\n", ret);
SelectObject(hdc, hbmp);
ret = ExtSelectClipRgn(hdc, hrgn_empty, RGN_DIFF);
@ -409,6 +416,17 @@ static void test_memory_dc_clipping(void)
ret = RectVisible( hdc, &rc );
ok( ret, "RectVisible failed for %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom );
ret = ExtSelectClipRgn(hdc, 0, RGN_DIFF);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = GetClipRgn(hdc, hrgn);
ok(ret == 1, "expected 1, got %d\n", ret);
ret = GetRgnBox(hrgn, &rc);
ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
ok(rc.left == 0 && rc.top == 0 && rc.right == 100 && rc.bottom == 100,
"expected 0,0-100,100, got %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
DeleteDC(hdc);
DeleteObject(hrgn);
DeleteObject(hrgn_empty);
@ -420,7 +438,7 @@ static void test_window_dc_clipping(void)
HDC hdc;
HRGN hrgn, hrgn_empty;
HWND hwnd;
RECT rc;
RECT rc, virtual_rect;
int ret, screen_width, screen_height;
/* Windows versions earlier than Win2k do not support the virtual screen metrics,
@ -429,6 +447,8 @@ static void test_window_dc_clipping(void)
if(!screen_width) screen_width = GetSystemMetrics(SM_CXSCREEN);
screen_height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
if(!screen_height) screen_height = GetSystemMetrics(SM_CYSCREEN);
SetRect(&virtual_rect, GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN),
GetSystemMetrics(SM_XVIRTUALSCREEN) + screen_width, GetSystemMetrics(SM_YVIRTUALSCREEN) + screen_height);
trace("screen resolution %d x %d\n", screen_width, screen_height);
@ -441,6 +461,12 @@ static void test_window_dc_clipping(void)
ret = GetClipRgn(hdc, hrgn);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = ExtSelectClipRgn(hdc, 0, RGN_DIFF);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = GetClipRgn(hdc, hrgn);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = ExtSelectClipRgn(hdc, hrgn_empty, RGN_DIFF);
ok(ret == SIMPLEREGION || (ret == COMPLEXREGION && GetSystemMetrics(SM_CMONITORS) > 1),
"expected SIMPLEREGION, got %d\n", ret);
@ -450,8 +476,8 @@ static void test_window_dc_clipping(void)
ret = GetRgnBox(hrgn, &rc);
ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
ok(rc.left == 0 && rc.top == 0 && rc.right == screen_width && rc.bottom == screen_height,
"expected 0,0-%d,%d, got %d,%d-%d,%d\n", screen_width, screen_height,
ok(EqualRect(&rc, &virtual_rect), "expected %d,%d-%d,%d, got %d,%d-%d,%d\n",
virtual_rect.left, virtual_rect.top, virtual_rect.right, virtual_rect.bottom,
rc.left, rc.top, rc.right, rc.bottom);
SetRect( &rc, 10, 10, 20, 20 );
@ -462,6 +488,18 @@ static void test_window_dc_clipping(void)
ret = RectVisible( hdc, &rc );
ok( ret, "RectVisible failed for %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom );
ret = ExtSelectClipRgn(hdc, 0, RGN_DIFF);
ok(ret == 0, "expected 0, got %d\n", ret);
ret = GetClipRgn(hdc, hrgn);
ok(ret == 1, "expected 1, got %d\n", ret);
ret = GetRgnBox(hrgn, &rc);
ok(ret == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", ret);
ok(EqualRect(&rc, &virtual_rect), "expected %d,%d-%d,%d, got %d,%d-%d,%d\n",
virtual_rect.left, virtual_rect.top, virtual_rect.right, virtual_rect.bottom,
rc.left, rc.top, rc.right, rc.bottom);
ret = ExtSelectClipRgn(hdc, 0, RGN_COPY);
ok(ret == SIMPLEREGION || (ret == COMPLEXREGION && GetSystemMetrics(SM_CMONITORS) > 1),
"expected SIMPLEREGION, got %d\n", ret);

70
rostests/winetests/gdi32/dc.c
View file

@ -457,11 +457,45 @@ static void test_device_caps( HDC hdc, HDC ref_dc, const char *descr, int scale
type = GetClipBox( ref_dc, &rect );
if (type != COMPLEXREGION && type != ERROR) /* region can be complex on multi-monitor setups */
{
RECT ref_rect;
ok( type == SIMPLEREGION, "GetClipBox returned %d on %s\n", type, descr );
ok( rect.left == 0 && rect.top == 0 &&
rect.right == GetDeviceCaps( ref_dc, DESKTOPHORZRES ) &&
rect.bottom == GetDeviceCaps( ref_dc, DESKTOPVERTRES ),
"GetClipBox returned %d,%d,%d,%d on %s\n",
if (GetDeviceCaps( ref_dc, TECHNOLOGY ) == DT_RASDISPLAY)
{
if (GetSystemMetrics( SM_CXSCREEN ) != GetSystemMetrics( SM_CXVIRTUALSCREEN ))
todo_wine ok( GetDeviceCaps( ref_dc, DESKTOPHORZRES ) == GetSystemMetrics( SM_CXSCREEN ),
"Got DESKTOPHORZRES %d on %s, expected %d\n",
GetDeviceCaps( ref_dc, DESKTOPHORZRES ), descr, GetSystemMetrics( SM_CXSCREEN ) );
else
ok( GetDeviceCaps( ref_dc, DESKTOPHORZRES ) == GetSystemMetrics( SM_CXSCREEN ),
"Got DESKTOPHORZRES %d on %s, expected %d\n",
GetDeviceCaps( ref_dc, DESKTOPHORZRES ), descr, GetSystemMetrics( SM_CXSCREEN ) );
if (GetSystemMetrics( SM_CYSCREEN ) != GetSystemMetrics( SM_CYVIRTUALSCREEN ))
todo_wine ok( GetDeviceCaps( ref_dc, DESKTOPVERTRES ) == GetSystemMetrics( SM_CYSCREEN ),
"Got DESKTOPVERTRES %d on %s, expected %d\n",
GetDeviceCaps( ref_dc, DESKTOPVERTRES ), descr, GetSystemMetrics( SM_CYSCREEN ) );
else
ok( GetDeviceCaps( ref_dc, DESKTOPVERTRES ) == GetSystemMetrics( SM_CYSCREEN ),
"Got DESKTOPVERTRES %d on %s, expected %d\n",
GetDeviceCaps( ref_dc, DESKTOPVERTRES ), descr, GetSystemMetrics( SM_CYSCREEN ) );
SetRect( &ref_rect, GetSystemMetrics( SM_XVIRTUALSCREEN ), GetSystemMetrics( SM_YVIRTUALSCREEN ),
GetSystemMetrics( SM_XVIRTUALSCREEN ) + GetSystemMetrics( SM_CXVIRTUALSCREEN ),
GetSystemMetrics( SM_YVIRTUALSCREEN ) + GetSystemMetrics( SM_CYVIRTUALSCREEN ) );
}
else
{
SetRect( &ref_rect, 0, 0, GetDeviceCaps( ref_dc, DESKTOPHORZRES ),
GetDeviceCaps( ref_dc, DESKTOPVERTRES ) );
}
if (GetDeviceCaps( ref_dc, TECHNOLOGY ) == DT_RASDISPLAY && GetObjectType( hdc ) != OBJ_ENHMETADC &&
(GetSystemMetrics( SM_XVIRTUALSCREEN ) || GetSystemMetrics( SM_YVIRTUALSCREEN )))
todo_wine ok( EqualRect( &rect, &ref_rect ), "GetClipBox returned %d,%d,%d,%d on %s\n",
rect.left, rect.top, rect.right, rect.bottom, descr );
else
ok( EqualRect( &rect, &ref_rect ), "GetClipBox returned %d,%d,%d,%d on %s\n",
rect.left, rect.top, rect.right, rect.bottom, descr );
}
@ -531,19 +565,19 @@ static void test_CreateCompatibleDC(void)
HDC hdc, hNewDC, hdcMetafile, screen_dc;
HBITMAP bitmap;
INT caps;
DEVMODE dm;
DEVMODEA dm;
bitmap = CreateBitmap( 10, 10, 1, 1, NULL );
bRet = EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm);
bRet = EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &dm);
ok(bRet, "EnumDisplaySettingsEx failed\n");
dm.u1.s1.dmScale = 200;
dm.dmFields |= DM_SCALE;
hdc = CreateDC( "DISPLAY", NULL, NULL, &dm );
hdc = CreateDCA( "DISPLAY", NULL, NULL, &dm );
screen_dc = CreateDC( "DISPLAY", NULL, NULL, NULL );
screen_dc = CreateDCA( "DISPLAY", NULL, NULL, NULL );
test_device_caps( hdc, screen_dc, "display dc", 1 );
ResetDC( hdc, &dm );
ResetDCA( hdc, &dm );
test_device_caps( hdc, screen_dc, "display dc", 1 );
DeleteDC( hdc );
@ -573,7 +607,7 @@ static void test_CreateCompatibleDC(void)
caps = GetDeviceCaps( hdcMetafile, TECHNOLOGY );
ok( caps == DT_RASDISPLAY, "wrong caps %u\n", caps );
test_device_caps( hdcMetafile, hdc, "enhmetafile dc", 1 );
ResetDC( hdcMetafile, &dm );
ResetDCA( hdcMetafile, &dm );
test_device_caps( hdcMetafile, hdc, "enhmetafile dc", 1 );
DeleteDC( hNewDC );
DeleteEnhMetaFile( CloseEnhMetaFile( hdcMetafile ));
@ -586,7 +620,7 @@ static void test_CreateCompatibleDC(void)
caps = GetDeviceCaps( hdcMetafile, TECHNOLOGY );
ok( caps == DT_METAFILE, "wrong caps %u\n", caps );
test_device_caps( hdcMetafile, screen_dc, "metafile dc", 1 );
ResetDC( hdcMetafile, &dm );
ResetDCA( hdcMetafile, &dm );
test_device_caps( hdcMetafile, screen_dc, "metafile dc", 1 );
DeleteMetaFile( CloseMetaFile( hdcMetafile ));
@ -673,7 +707,7 @@ static void test_DeleteDC(void)
{
HWND hwnd;
HDC hdc, hdc_test;
WNDCLASSEX cls;
WNDCLASSEXA cls;
int ret;
/* window DC */
@ -727,7 +761,7 @@ static void test_DeleteDC(void)
memset(&cls, 0, sizeof(cls));
cls.cbSize = sizeof(cls);
cls.style = CS_CLASSDC;
cls.hInstance = GetModuleHandle(0);
cls.hInstance = GetModuleHandleA(NULL);
cls.lpszClassName = "Wine class DC";
cls.lpfnWndProc = DefWindowProcA;
ret = RegisterClassExA(&cls);
@ -766,7 +800,7 @@ static void test_DeleteDC(void)
ret = GetObjectType(hdc_test);
ok(ret == OBJ_DC, "expected OBJ_DC, got %d\n", ret);
ret = UnregisterClassA("Wine class DC", GetModuleHandle(NULL));
ret = UnregisterClassA("Wine class DC", GetModuleHandleA(NULL));
ok(ret, "UnregisterClassA failed\n");
ret = GetObjectType(hdc_test);
@ -777,7 +811,7 @@ todo_wine
memset(&cls, 0, sizeof(cls));
cls.cbSize = sizeof(cls);
cls.style = CS_OWNDC;
cls.hInstance = GetModuleHandle(0);
cls.hInstance = GetModuleHandleA(NULL);
cls.lpszClassName = "Wine own DC";
cls.lpfnWndProc = DefWindowProcA;
ret = RegisterClassExA(&cls);
@ -811,7 +845,7 @@ todo_wine
DestroyWindow(hwnd);
ret = UnregisterClassA("Wine own DC", GetModuleHandle(NULL));
ret = UnregisterClassA("Wine own DC", GetModuleHandleA(NULL));
ok(ret, "UnregisterClassA failed\n");
}
@ -1262,7 +1296,7 @@ static HDC create_printer_dc(int scale, BOOL reset)
dbuf->pDriverPath, pbuf->pPrinterName, pbuf->pPortName,
is_postscript_printer(hdc) ? "" : "NOT " );
if (reset) ResetDC( hdc, pbuf->pDevMode );
if (reset) ResetDCA( hdc, pbuf->pDevMode );
done:
HeapFree( GetProcessHeap(), 0, dbuf );
HeapFree( GetProcessHeap(), 0, pbuf );
@ -1346,7 +1380,7 @@ static void test_printer_dc(void)
START_TEST(dc)
{
pSetLayout = (void *)GetProcAddress( GetModuleHandle("gdi32.dll"), "SetLayout");
pSetLayout = (void *)GetProcAddress( GetModuleHandleA("gdi32.dll"), "SetLayout");
test_dc_values();
test_savedc();
test_savedc_2();

235
rostests/winetests/gdi32/dib.c
View file

@ -136,8 +136,8 @@ static const char *sha1_graphics_a8r8g8b8[] =
"d7dd4700f49808541bba99244b7eb5840e0a2439",
"af99228aa4cfbd1f61bd824db046144a3c6c2ed7",
"568f87f0194ca19b69a5b2bcdef795d89c5721ce",
"50d19fe68b2ab4fdbb5d590cdca6dc84a95bab68",
"a1fde1094d2c19ddb20871842dae1da73618709e",
"a37810f46dee8741fe5adbb3f1f2e87012ffc929",
"50a09678c49c208f71d40452daca5411279aa674",
"e462052a03dbe4ec3814db7700e166d00d4d686f",
"a27917d4db49ce77989fae246015aeb2a28520ee",
"657514a4ca1f2b6ca7a125ad58dfed82099a37d1",
@ -209,8 +209,8 @@ static const char *sha1_graphics_a8r8g8b8_bitfields[] =
"d7dd4700f49808541bba99244b7eb5840e0a2439",
"af99228aa4cfbd1f61bd824db046144a3c6c2ed7",
"568f87f0194ca19b69a5b2bcdef795d89c5721ce",
"50d19fe68b2ab4fdbb5d590cdca6dc84a95bab68",
"a1fde1094d2c19ddb20871842dae1da73618709e",
"a37810f46dee8741fe5adbb3f1f2e87012ffc929",
"50a09678c49c208f71d40452daca5411279aa674",
"0cda6b3297003b3ccd6d5baa17e1ca9bb7c56f08",
"b2c8e1ebb9435031fe068442f479d1304096e79f",
"657514a4ca1f2b6ca7a125ad58dfed82099a37d1",
@ -282,8 +282,8 @@ static const char *sha1_graphics_a8b8g8r8[] =
"86c84cc8306975edecc6d4a89a8aff29f59b55a7",
"af99228aa4cfbd1f61bd824db046144a3c6c2ed7",
"25675c30adfe24d6cae60793b156dfdaa36ac3ba",
"1cb1810b127f509117b38d62a15b67b2347b9145",
"f05b3294f25de5fa6d1114104bca97871052ea5a",
"849d4abf4b690128a5f70e9b8ac78f20c437de06",
"e768fc9f3167ef3144a4cfb1e20126a577f7dd5b",
"87f57a31253a38dbf3dc3070473328fa04b68a48",
"db64cc4d830fc35ed170b53943e722b2342954d4",
"9988ceca44dafbee247aece1f027c06c27c01652",
@ -355,8 +355,8 @@ static const char *sha1_graphics_r10g10b10[] =
"fc0c32afb719295f28bcfef22803bef94f798e20",
"36f6db4fbe2a1630a7597d3a446f2902755c96ef",
"d3f08946300e1700865042aed121870e292d1095",
"467ff4af1e105855874f27fbf84d1d2b0417ab5d",
"fb0dcff8a67a88313557ee8b588aaa2004fe7b8b",
"4782df8e24127e66a434b4e839adebf2dbb223fb",
"739707cc85ca63e0580c79618dc0bb8a4a338d95",
"8ea5d7e4bebc40a1d91b04b12e1c11a42c188095",
"317521e576801acaea62c76fe16813cdfe20f4ad",
"ce0fc29bb0281d6c955d64e239254ef9e6dbc06d",
@ -428,8 +428,8 @@ static const char *sha1_graphics_r6g6b6[] =
"49341c297a887186bd47d7465d827ab3147f05e3",
"325279e76367200d3fd7194d81c09fd139988ece",
"c3def160a1e847605ff0fc7edd30397fa90635a0",
"a9c2158329c207638cfd2c82cd8a6218efdb28d2",
"7f0c4e6874f0c36cee64ff5dec76258ca8822cb2",
"2b3e87e0b705b03c7c08f403409ab82cce095ba1",
"45c08e11fffc78b2a3574263419e0cb7f8cd9b45",
"aecb242c31f31a90f071b6455ea7d808d4ea22e3",
"77ea86e51a94b11a8081b29696cb4115687843e3",
"d67b897cad72d31e75359094007b1346fd8806ea",
@ -501,8 +501,8 @@ static const char *sha1_graphics_24[] =
"b25ba91487ec945410deb2b51bc1156890c032a8",
"d347ca5c6c4b6a61389247c3b6f61564033e8c25",
"ee315634ed92da3a32c2675ecd1b369471c60936",
"6776e0612410e7e200c853721b4ab6ad8b6b81f5",
"620a5a520d81971a2d9c30b8d836ba696e11b8dd",
"099c688a920f606655b485e8f0a433dc811bc976",
"9c044a733335bca43766bda2b317249309155079",
"354b92008a8409c62d0fa1dff1532c5943aa37a2",
"8dc9cb7deae5c24d1eae004d53893fa6caf4723c",
"cf311a96d41bd98fdbdfb5dfaac4ba1ba9b7d6da",
@ -578,8 +578,8 @@ static const char *sha1_graphics_r5g5b5[] =
"3772003c7fb420003512d0c437b3659d96d89ce4",
"dab47c9dc149e570045d699598b14a613bf319b3",
"2daca4d26a086ed34894693be0b0374402232809",
"e313ae8f7261b88999757ed0c6f26df85b4f01a5",
"47d0bab8664ae0aaa927495d07bb3537cce35f16",
"904f1d82159bcf5485f323bd12b859dc5e83f8eb",
"5bd29f94844351e9a5bd01f25d85608b9b0701b2",
"295ec16530126046790fb734e99f86f5b3b74ed8",
"d98b0561010606b55a1b9b85fbc93640f681d256",
"1c1499051860b7caa25173b328ca9c862f01dd1a",
@ -650,8 +650,8 @@ static const char *sha1_graphics_r4g4b4[] =
"f0acb3cfcda62e95bee5f7bc8830ffeb3dd7e5a7",
"07b10c3f191d0a93e5e5694aae37dcad407e10f5",
"f7900e60347029876ba55e8f0c4c02e89deb36b6",
"7d80b8289da8a65931f03c74a9ef0aff5f8eb551",
"a7a986097e5b553c71bd93fd0ec6037e6bd0f2d1",
"f373a5f37b82e7523c64c08eb509b6191e49b173",
"9f0760a05190c9edf9ce2e8be6aaa5557601fe91",
"7587a9c87cab1eca827807f351bb67ca184d1ac5",
"b53ef0b5c674822e784903a9dbdd3b386d9f2350",
"5505d2ed20dc61ffe48832ecf5329162a5ceb734",
@ -728,8 +728,8 @@ static const char *sha1_graphics_8_color[] =
"9ae38bb94c7b4c0c6dfebbee23d1de4db9b77488",
"678979a45126a76eb629992cd64734862f53a555",
"2f7ba8803604c032cb1a1228bc021f0f1c03e245",
"9b1cc7b24f8ce15db2af7f4aa8cde8687784dfa2",
"cc4a4cea622d825700bccef7d90a5a447d9ca39d",
"52e7c2f8b01592898c13f1e7633881e350244209",
"d9d5556b77301952b4caf113337720966bc8e1f5",
"e58d9c0acf0219d0839e1dbd162e08a765ed7f0f",
"34ca0f9660e1889f9f2c0deb80535d3c4f349fa4",
"2c07272462c68cf5944b03e2aa049475b99143c5",
@ -810,9 +810,9 @@ static const char *sha1_graphics_8_grayscale[] =
"fb63bbb2f944fb63ed2d7399f07b168740c1034b",
"3685c9ae95118a83db3569832c29753276fa1264",
"09640bad951c33e7d70a1fced83b1869f65b3fc5",
"cb9ea8137eca1450e049879772f5c11a0e11ff0a",
"a4b04ed35484de0de61832a8a28bbc7def645622",
"515897610714251dd3b54f54fe76a9ed3fd12c53",
"5eb00252664ec39e61359adb1dade4906a87a248",
"ee7b9b292ea9fb559ef5ebf6a2a5586d38c7f854",
"dcad1a146c1d0ec2c4cc7f64bd4f45c57a604bfe",
"0ca8775d9a61ccc251d1e6f2e3cfd26a24ae24a2",
"17ae603c199a5d6695d198a7f36e6d7263990951",
"1918a33f59d3500204ffc573318a39e9ff754221",
@ -887,8 +887,8 @@ static const char *sha1_graphics_8[] =
"31e667c2dbb81dcf81d01cb88f794e88ddb90ff2",
"465d9cd0a77ab4fcf035aa67544b2a26269e0b09",
"600d6b2713d5e4c0d90c02660245ed26c7ae3033",
"d4f3a5ea033adc405c44e1ca137dc908c606dad6",
"7103d428ec9a959778120fd6f0dc62dd608ddd63",
"0025a440866a404523a8a20e79a8891e45a2ff56",
"c04d335933895f836f0a28c1e3f7f444352c3b8e",
"bd28d77cd85b20a2384d6b25082cfd884bba683e",
"7e591ec8ae9bb61c3a443c93f071cab2b8978394",
"f81c70b6ee2d4690f9f7c797c66582b176f8dcef",
@ -959,8 +959,8 @@ static const char *sha1_graphics_4[] =
"df5feb905a31c288008cf5e82d73ac818a160d82",
"d8af3868c66c7d6dac35ec8ee0317b38a6910bb1",
"ec8e2aebfb4a1c28ebcd0e053b9e4d8638b50951",
"1a23839d71d2379ed4e709a5ae6c14639fbe3ab8",
"09f8416a780d80be61cbda3d8a05aee418d0ea00",
"ccf8d11b1e81895e9781f17c227c821228d8714b",
"f751e26578193afe6a727ee2a52318c404c56555",
"28a6b9f7927e99e53cf46f0333d29168cb10e920",
"029552113292cc110fd6b7888e766628950aaeef",
"297f6ad15200bffbf15198324ee8f27a61a6f2d4",
@ -1031,8 +1031,8 @@ static const char *sha1_graphics_4_grayscale[] =
"f8681c09f1abfc38d31e47622cb8798cd896a00e",
"b5ee51cfc73acb59a2f6124509ea236f8fc7f9f7",
"d374d4d92c940ae42a9b42c14d744341b68a8c14",
"43560b856907f552df3b9dd1f91e1aa8ab9ff17e",
"8cefa6dcb658487d0715598d5d120677dbfdab42",
"06a6a224be0f5cdc51ac4704f9f57fc1f3813d6f",
"c47c2dc806b6b8ff28f300949695d013a46c0083",
"ada3b7c34946e584dcdf4203e07cfa3dad02bc63",
"c2f61571b067a44b30f56b4658c9606f0edfc0f3",
"58f400c9bb78e49a879276fb049edfc9c981740a",
@ -1052,14 +1052,14 @@ static const char *sha1_graphics_4_grayscale[] =
static const char *sha1_graphics_1[] =
{
"23366004515f3bc46796ea505d748f8d0f97fbe1",
"ad674a4104c6a1eacaee8f20effdfe31775b4409",
"a7cc69f957d7b533a0a330859a143d701daac73c",
"a955bf088c5edb129289ce65caace48ec95632e4",
"5316d3c558c254479883133cf58cd07ab521d3f0",
"fcbfdb5d60716ea05f2d1896fae7a6e7a8249d35",
"2c140b39cc8d21358fded8959cd655f03d7f0f89",
"121423a38b4ac4743bd516e0a7e88a3863796313",
"7c17635c6c7f62dbf8fd4773d0c503358553d2c7",
"61ade9054d4477fb89cf830539a5e8b4e45f0688",
"ac530c5dbaf837e15b2337347e974184fad73643",
"95fdcda26262d5948a9ade77d83fd698e0031050",
"1dd5cee06af78d026e5da8bfe3f45e1cf51faa13",
"f6b61ecf03ad11752775faca1d4404c6bb5065f5",
"d7ad44d6f377598268e9968333ae2cf23a0715ca",
"5871339cd7e6cee12d4dc45934a89071c73efe6b",
"69e9b85b34caf736069ba91e57a5c3fa7c891653",
"21d5d9e47bb07de2cf7bc99b7725390d03a6cde6",
"f69ee65ea25676429a28eea79b5b9cb9206b8d01",
"39ff81f77ef4ee772367ed1a63785987c060126e",
@ -1122,7 +1122,7 @@ static const char *sha1_graphics_1[] =
"88763f8e8fcf4f78fa864325791a9dd35a0bd279",
"013cee26bac8f815eadad4bfc012d9b5d01c3b7f",
"44a28536466dc895feb824b23dfd4a47c6948af8",
"f0316a5765a0404760e94cd05b7dc956cae07d26",
"17468a3789f0a6d65c302bda735a01dc2c1a74d9",
"781d8c5cbc28591fd48fce06f984c502fdc6b363",
"df510792a7790cc699532b1420d43c6d4da2ae2f",
"55c26d22f11d80b73383fa57d0fac552d705b092",
@ -1131,14 +1131,14 @@ static const char *sha1_graphics_1[] =
"4842a30dd7fdf38ddc3ddec85c08efe13a0e2e0b",
"cc76db6da5ba1776f20240a5ad97a26a9cdf96b0",
"014f477664a7f4ce4a948d6359a2707119afc8e2",
"1ee4e951743efc8764249fbc7adecefbfec0428e",
"74d01690e344bc22e7a0478e7a09ccd92354c486",
"9ab50a663b74577b656e9849484a909d7ac52eeb",
"128eefd2ee043d59dc37918065f687e378e5ca95",
"c642abc651f525332d9d635049646d309e877839",
"d7e2daab98ce1f698c4bfedfc01c0d79fcb76b8e",
"8d34215487088b5d4ef63062270ce25c2862643d",
"3dc3075b0c87fdcaabbbae8928303fb2358c15c2",
"826562eb11a0d0bba77fa21245f7406a194e9225",
"bbae6f0659e095a42b420082079663f937065813",
"ca711c69165e1fa5be72993b9a7870ef6d485249",
"bbabe686a6955402c90530e7c67f1428868369b3",
NULL
};
@ -1488,6 +1488,129 @@ static const DWORD four_by_four_data[16] = { 0x000000, 0xff0000, 0x00ff00, 0x000
static const DWORD ddb_brush_bits[8] = { 0x11112222, 0x33334444, 0x55556666, 0x77778888,
0xaaaaaaaa, 0x00000000, 0x98765432, 0xabcdef00 };
static const RGBQUAD default_palette_1[2] =
{
{ 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff }
};
static const RGBQUAD default_palette_4[16] =
{
{ 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 },
{ 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x80 },
{ 0xc0, 0xc0, 0xc0 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff },
{ 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff },
};
static const RGBQUAD default_palette_8[256] =
{
{ 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 },
{ 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0xc0, 0xc0, 0xc0 },
{ 0xc0, 0xdc, 0xc0 }, { 0xf0, 0xca, 0xa6 }, { 0x00, 0x20, 0x40 }, { 0x00, 0x20, 0x60 },
{ 0x00, 0x20, 0x80 }, { 0x00, 0x20, 0xa0 }, { 0x00, 0x20, 0xc0 }, { 0x00, 0x20, 0xe0 },
{ 0x00, 0x40, 0x00 }, { 0x00, 0x40, 0x20 }, { 0x00, 0x40, 0x40 }, { 0x00, 0x40, 0x60 },
{ 0x00, 0x40, 0x80 }, { 0x00, 0x40, 0xa0 }, { 0x00, 0x40, 0xc0 }, { 0x00, 0x40, 0xe0 },
{ 0x00, 0x60, 0x00 }, { 0x00, 0x60, 0x20 }, { 0x00, 0x60, 0x40 }, { 0x00, 0x60, 0x60 },
{ 0x00, 0x60, 0x80 }, { 0x00, 0x60, 0xa0 }, { 0x00, 0x60, 0xc0 }, { 0x00, 0x60, 0xe0 },
{ 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x20 }, { 0x00, 0x80, 0x40 }, { 0x00, 0x80, 0x60 },
{ 0x00, 0x80, 0x80 }, { 0x00, 0x80, 0xa0 }, { 0x00, 0x80, 0xc0 }, { 0x00, 0x80, 0xe0 },
{ 0x00, 0xa0, 0x00 }, { 0x00, 0xa0, 0x20 }, { 0x00, 0xa0, 0x40 }, { 0x00, 0xa0, 0x60 },
{ 0x00, 0xa0, 0x80 }, { 0x00, 0xa0, 0xa0 }, { 0x00, 0xa0, 0xc0 }, { 0x00, 0xa0, 0xe0 },
{ 0x00, 0xc0, 0x00 }, { 0x00, 0xc0, 0x20 }, { 0x00, 0xc0, 0x40 }, { 0x00, 0xc0, 0x60 },
{ 0x00, 0xc0, 0x80 }, { 0x00, 0xc0, 0xa0 }, { 0x00, 0xc0, 0xc0 }, { 0x00, 0xc0, 0xe0 },
{ 0x00, 0xe0, 0x00 }, { 0x00, 0xe0, 0x20 }, { 0x00, 0xe0, 0x40 }, { 0x00, 0xe0, 0x60 },
{ 0x00, 0xe0, 0x80 }, { 0x00, 0xe0, 0xa0 }, { 0x00, 0xe0, 0xc0 }, { 0x00, 0xe0, 0xe0 },
{ 0x40, 0x00, 0x00 }, { 0x40, 0x00, 0x20 }, { 0x40, 0x00, 0x40 }, { 0x40, 0x00, 0x60 },
{ 0x40, 0x00, 0x80 }, { 0x40, 0x00, 0xa0 }, { 0x40, 0x00, 0xc0 }, { 0x40, 0x00, 0xe0 },
{ 0x40, 0x20, 0x00 }, { 0x40, 0x20, 0x20 }, { 0x40, 0x20, 0x40 }, { 0x40, 0x20, 0x60 },
{ 0x40, 0x20, 0x80 }, { 0x40, 0x20, 0xa0 }, { 0x40, 0x20, 0xc0 }, { 0x40, 0x20, 0xe0 },
{ 0x40, 0x40, 0x00 }, { 0x40, 0x40, 0x20 }, { 0x40, 0x40, 0x40 }, { 0x40, 0x40, 0x60 },
{ 0x40, 0x40, 0x80 }, { 0x40, 0x40, 0xa0 }, { 0x40, 0x40, 0xc0 }, { 0x40, 0x40, 0xe0 },
{ 0x40, 0x60, 0x00 }, { 0x40, 0x60, 0x20 }, { 0x40, 0x60, 0x40 }, { 0x40, 0x60, 0x60 },
{ 0x40, 0x60, 0x80 }, { 0x40, 0x60, 0xa0 }, { 0x40, 0x60, 0xc0 }, { 0x40, 0x60, 0xe0 },
{ 0x40, 0x80, 0x00 }, { 0x40, 0x80, 0x20 }, { 0x40, 0x80, 0x40 }, { 0x40, 0x80, 0x60 },
{ 0x40, 0x80, 0x80 }, { 0x40, 0x80, 0xa0 }, { 0x40, 0x80, 0xc0 }, { 0x40, 0x80, 0xe0 },
{ 0x40, 0xa0, 0x00 }, { 0x40, 0xa0, 0x20 }, { 0x40, 0xa0, 0x40 }, { 0x40, 0xa0, 0x60 },
{ 0x40, 0xa0, 0x80 }, { 0x40, 0xa0, 0xa0 }, { 0x40, 0xa0, 0xc0 }, { 0x40, 0xa0, 0xe0 },
{ 0x40, 0xc0, 0x00 }, { 0x40, 0xc0, 0x20 }, { 0x40, 0xc0, 0x40 }, { 0x40, 0xc0, 0x60 },
{ 0x40, 0xc0, 0x80 }, { 0x40, 0xc0, 0xa0 }, { 0x40, 0xc0, 0xc0 }, { 0x40, 0xc0, 0xe0 },
{ 0x40, 0xe0, 0x00 }, { 0x40, 0xe0, 0x20 }, { 0x40, 0xe0, 0x40 }, { 0x40, 0xe0, 0x60 },
{ 0x40, 0xe0, 0x80 }, { 0x40, 0xe0, 0xa0 }, { 0x40, 0xe0, 0xc0 }, { 0x40, 0xe0, 0xe0 },
{ 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x20 }, { 0x80, 0x00, 0x40 }, { 0x80, 0x00, 0x60 },
{ 0x80, 0x00, 0x80 }, { 0x80, 0x00, 0xa0 }, { 0x80, 0x00, 0xc0 }, { 0x80, 0x00, 0xe0 },
{ 0x80, 0x20, 0x00 }, { 0x80, 0x20, 0x20 }, { 0x80, 0x20, 0x40 }, { 0x80, 0x20, 0x60 },
{ 0x80, 0x20, 0x80 }, { 0x80, 0x20, 0xa0 }, { 0x80, 0x20, 0xc0 }, { 0x80, 0x20, 0xe0 },
{ 0x80, 0x40, 0x00 }, { 0x80, 0x40, 0x20 }, { 0x80, 0x40, 0x40 }, { 0x80, 0x40, 0x60 },
{ 0x80, 0x40, 0x80 }, { 0x80, 0x40, 0xa0 }, { 0x80, 0x40, 0xc0 }, { 0x80, 0x40, 0xe0 },
{ 0x80, 0x60, 0x00 }, { 0x80, 0x60, 0x20 }, { 0x80, 0x60, 0x40 }, { 0x80, 0x60, 0x60 },
{ 0x80, 0x60, 0x80 }, { 0x80, 0x60, 0xa0 }, { 0x80, 0x60, 0xc0 }, { 0x80, 0x60, 0xe0 },
{ 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x20 }, { 0x80, 0x80, 0x40 }, { 0x80, 0x80, 0x60 },
{ 0x80, 0x80, 0x80 }, { 0x80, 0x80, 0xa0 }, { 0x80, 0x80, 0xc0 }, { 0x80, 0x80, 0xe0 },
{ 0x80, 0xa0, 0x00 }, { 0x80, 0xa0, 0x20 }, { 0x80, 0xa0, 0x40 }, { 0x80, 0xa0, 0x60 },
{ 0x80, 0xa0, 0x80 }, { 0x80, 0xa0, 0xa0 }, { 0x80, 0xa0, 0xc0 }, { 0x80, 0xa0, 0xe0 },
{ 0x80, 0xc0, 0x00 }, { 0x80, 0xc0, 0x20 }, { 0x80, 0xc0, 0x40 }, { 0x80, 0xc0, 0x60 },
{ 0x80, 0xc0, 0x80 }, { 0x80, 0xc0, 0xa0 }, { 0x80, 0xc0, 0xc0 }, { 0x80, 0xc0, 0xe0 },
{ 0x80, 0xe0, 0x00 }, { 0x80, 0xe0, 0x20 }, { 0x80, 0xe0, 0x40 }, { 0x80, 0xe0, 0x60 },
{ 0x80, 0xe0, 0x80 }, { 0x80, 0xe0, 0xa0 }, { 0x80, 0xe0, 0xc0 }, { 0x80, 0xe0, 0xe0 },
{ 0xc0, 0x00, 0x00 }, { 0xc0, 0x00, 0x20 }, { 0xc0, 0x00, 0x40 }, { 0xc0, 0x00, 0x60 },
{ 0xc0, 0x00, 0x80 }, { 0xc0, 0x00, 0xa0 }, { 0xc0, 0x00, 0xc0 }, { 0xc0, 0x00, 0xe0 },
{ 0xc0, 0x20, 0x00 }, { 0xc0, 0x20, 0x20 }, { 0xc0, 0x20, 0x40 }, { 0xc0, 0x20, 0x60 },
{ 0xc0, 0x20, 0x80 }, { 0xc0, 0x20, 0xa0 }, { 0xc0, 0x20, 0xc0 }, { 0xc0, 0x20, 0xe0 },
{ 0xc0, 0x40, 0x00 }, { 0xc0, 0x40, 0x20 }, { 0xc0, 0x40, 0x40 }, { 0xc0, 0x40, 0x60 },
{ 0xc0, 0x40, 0x80 }, { 0xc0, 0x40, 0xa0 }, { 0xc0, 0x40, 0xc0 }, { 0xc0, 0x40, 0xe0 },
{ 0xc0, 0x60, 0x00 }, { 0xc0, 0x60, 0x20 }, { 0xc0, 0x60, 0x40 }, { 0xc0, 0x60, 0x60 },
{ 0xc0, 0x60, 0x80 }, { 0xc0, 0x60, 0xa0 }, { 0xc0, 0x60, 0xc0 }, { 0xc0, 0x60, 0xe0 },
{ 0xc0, 0x80, 0x00 }, { 0xc0, 0x80, 0x20 }, { 0xc0, 0x80, 0x40 }, { 0xc0, 0x80, 0x60 },
{ 0xc0, 0x80, 0x80 }, { 0xc0, 0x80, 0xa0 }, { 0xc0, 0x80, 0xc0 }, { 0xc0, 0x80, 0xe0 },
{ 0xc0, 0xa0, 0x00 }, { 0xc0, 0xa0, 0x20 }, { 0xc0, 0xa0, 0x40 }, { 0xc0, 0xa0, 0x60 },
{ 0xc0, 0xa0, 0x80 }, { 0xc0, 0xa0, 0xa0 }, { 0xc0, 0xa0, 0xc0 }, { 0xc0, 0xa0, 0xe0 },
{ 0xc0, 0xc0, 0x00 }, { 0xc0, 0xc0, 0x20 }, { 0xc0, 0xc0, 0x40 }, { 0xc0, 0xc0, 0x60 },
{ 0xc0, 0xc0, 0x80 }, { 0xc0, 0xc0, 0xa0 }, { 0xf0, 0xfb, 0xff }, { 0xa4, 0xa0, 0xa0 },
{ 0x80, 0x80, 0x80 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff },
{ 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff }
};
static HPALETTE create_default_palette( int bpp )
{
char pal_buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)];
LOGPALETTE *pal = (LOGPALETTE *)pal_buffer;
PALETTEENTRY *entries = pal->palPalEntry;
int i;
pal->palVersion = 0x300;
pal->palNumEntries = 1 << bpp;
switch (bpp)
{
case 1:
for (i = 0; i < 2; i++)
{
entries[i].peRed = default_palette_1[i].rgbRed;
entries[i].peGreen = default_palette_1[i].rgbGreen;
entries[i].peBlue = default_palette_1[i].rgbBlue;
entries[i].peFlags = 0;
}
break;
case 4:
for (i = 0; i < 16; i++)
{
entries[i].peRed = default_palette_4[i].rgbRed;
entries[i].peGreen = default_palette_4[i].rgbGreen;
entries[i].peBlue = default_palette_4[i].rgbBlue;
entries[i].peFlags = 0;
}
break;
case 8:
for (i = 0; i < 256; i++)
{
entries[i].peRed = default_palette_8[i].rgbRed;
entries[i].peGreen = default_palette_8[i].rgbGreen;
entries[i].peBlue = default_palette_8[i].rgbBlue;
entries[i].peFlags = 0;
}
break;
}
return CreatePalette( pal );
}
static inline void solid_patblt( HDC hdc, int x, int y, int width, int height, COLORREF color )
{
HBRUSH brush = CreateSolidBrush( color );
@ -1518,7 +1641,7 @@ static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits)
BOOL dib_is_8bpp_gray = (bmi->bmiHeader.biBitCount == 8 && bmi->bmiColors[1].rgbRed == 1);
BLENDFUNCTION blend;
COLORREF old_text, old_bkgnd;
HPALETTE hpal;
HPALETTE hpal, old_hpal;
blend.BlendOp = AC_SRC_OVER;
blend.BlendFlags = 0;
@ -2605,7 +2728,7 @@ static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits)
entries[i].peFlags = 0;
}
hpal = CreatePalette( pal );
SelectPalette( hdc, hpal, FALSE );
old_hpal = SelectPalette( hdc, hpal, FALSE );
solid_patblt( hdc, 20, 10, 10, 10, PALETTEINDEX(15) );
Rectangle( hdc, 0, 0, 10, 10 );
@ -2632,7 +2755,7 @@ static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits)
SelectObject( hdc, orig_brush );
DeleteObject( dib_brush );
SelectPalette( hdc, GetStockObject(DEFAULT_PALETTE), FALSE );
SelectPalette( hdc, old_hpal, FALSE );
DeleteObject( hpal );
/* NT4 broken for all cases, W2K for 1 bpp only */
@ -2655,7 +2778,7 @@ static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits)
SelectObject( hdc, solid_brush );
ret = ExtFloodFill( hdc, 100, 100, RGB( 0, 0xff, 0 ), FLOODFILLSURFACE );
ok (!ret == !!dib_is_1bpp, "got ret %d\n", ret);
ok (ret, "got ret %d\n", ret);
compare_hash(hdc, bmi, bits, "flood fill" );
ExtSelectClipRgn( hdc, NULL, RGN_COPY );
@ -2724,17 +2847,17 @@ static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
static void draw_text_2( HDC hdc, BITMAPINFO *bmi, BYTE *bits, BOOL aa )
{
DWORD dib_size = get_dib_size(bmi), ret;
LOGFONT lf;
LOGFONTA lf;
HFONT font;
GLYPHMETRICS gm;
BYTE g_buf[10000];
int i, stride, x, y;
static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
char *eto_hash = NULL, *diy_hash = NULL;
static const char *str = "Hello Wine";
static const char str[] = "Hello Wine";
POINT origin, g_org;
static const BYTE vals[4] = { 0x00, 0x00, 0x00, 0x00 };
TEXTMETRIC tm;
TEXTMETRICA tm;
COLORREF text_color;
for(i = 0; i < dib_size; i++)
@ -2745,10 +2868,10 @@ static void draw_text_2( HDC hdc, BITMAPINFO *bmi, BYTE *bits, BOOL aa )
lf.lfHeight = 24;
lf.lfQuality = aa ? ANTIALIASED_QUALITY : NONANTIALIASED_QUALITY;
font = CreateFontIndirect( &lf );
font = CreateFontIndirectA( &lf );
font = SelectObject( hdc, font );
GetTextMetrics( hdc, &tm );
GetTextMetricsA( hdc, &tm );
if (!(tm.tmPitchAndFamily & TMPF_VECTOR))
{
skip( "skipping as a bitmap font has been selected for Tahoma.\n" );
@ -2762,7 +2885,7 @@ static void draw_text_2( HDC hdc, BITMAPINFO *bmi, BYTE *bits, BOOL aa )
origin.x = 10;
origin.y = 100;
ExtTextOut( hdc, origin.x, origin.y, 0, NULL, str, strlen(str), NULL );
ExtTextOutA( hdc, origin.x, origin.y, 0, NULL, str, strlen(str), NULL );
eto_hash = hash_dib( bmi, bits );
for(i = 0; i < dib_size; i++)
@ -2775,11 +2898,11 @@ static void draw_text_2( HDC hdc, BITMAPINFO *bmi, BYTE *bits, BOOL aa )
{
DWORD ggo_flags = aa ? GGO_GRAY4_BITMAP : GGO_BITMAP;
ret = GetGlyphOutline( hdc, str[i], ggo_flags, &gm, 0, NULL, &identity );
ret = GetGlyphOutlineA( hdc, str[i], ggo_flags, &gm, 0, NULL, &identity );
if (ret == GDI_ERROR) continue;
if (ret) GetGlyphOutline( hdc, str[i], ggo_flags, &gm, sizeof(g_buf), g_buf, &identity );
if (ret) GetGlyphOutlineA( hdc, str[i], ggo_flags, &gm, sizeof(g_buf), g_buf, &identity );
g_org.x = origin.x + gm.gmptGlyphOrigin.x;
g_org.y = origin.y - gm.gmptGlyphOrigin.y;
@ -2859,6 +2982,7 @@ static void test_simple_graphics(void)
BYTE *bits;
HBITMAP dib, orig_bm;
DIBSECTION ds;
HPALETTE default_palette, old_hpal;
int i;
mem_dc = CreateCompatibleDC(NULL);
@ -2885,6 +3009,9 @@ static void test_simple_graphics(void)
orig_bm = SelectObject(mem_dc, dib);
default_palette = create_default_palette( 8 );
old_hpal = SelectPalette( mem_dc, default_palette, FALSE );
dst_format = "8888";
current_sha1 = sha1_graphics_a8r8g8b8;
draw_graphics(mem_dc, bmi, bits);
@ -2910,6 +3037,7 @@ static void test_simple_graphics(void)
ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
orig_bm = SelectObject(mem_dc, dib);
SelectPalette( mem_dc, default_palette, FALSE );
dst_format = "8888 - bitfields";
current_sha1 = sha1_graphics_a8r8g8b8_bitfields;
@ -3148,6 +3276,7 @@ static void test_simple_graphics(void)
ok(dib != NULL, "ret NULL\n");
orig_bm = SelectObject(mem_dc, dib);
DeleteObject( SelectPalette( mem_dc, create_default_palette(4), FALSE ));
dst_format = "4";
current_sha1 = sha1_graphics_4;
@ -3191,12 +3320,14 @@ static void test_simple_graphics(void)
ok(dib != NULL, "ret NULL\n");
orig_bm = SelectObject(mem_dc, dib);
DeleteObject( SelectPalette( mem_dc, create_default_palette(1), FALSE ));
dst_format = "1";
current_sha1 = sha1_graphics_1;
draw_graphics(mem_dc, bmi, bits);
draw_text(mem_dc, bmi, bits);
DeleteObject( SelectPalette( mem_dc, old_hpal, FALSE ));
SelectObject(mem_dc, orig_bm);
DeleteObject(dib);

1636
rostests/winetests/gdi32/font.c
View file

File diff suppressed because it is too large Load diff

12
rostests/winetests/gdi32/gdiobj.c
View file

@ -121,7 +121,7 @@ static DWORD WINAPI thread_proc(void *param)
DWORD status;
struct hgdiobj_event *hgdiobj_event = param;
hgdiobj_event->hdc = CreateDC("display", NULL, NULL, NULL);
hgdiobj_event->hdc = CreateDCA("display", NULL, NULL, NULL);
ok(hgdiobj_event->hdc != NULL, "CreateDC error %u\n", GetLastError());
hgdiobj_event->hgdiobj1 = CreatePen(PS_DASHDOTDOT, 17, RGB(1, 2, 3));
@ -134,7 +134,7 @@ static DWORD WINAPI thread_proc(void *param)
status = WaitForSingleObject(hgdiobj_event->stop_event, INFINITE);
ok(status == WAIT_OBJECT_0, "WaitForSingleObject error %u\n", GetLastError());
ok(!GetObject(hgdiobj_event->hgdiobj1, sizeof(lp), &lp), "GetObject should fail\n");
ok(!GetObjectA(hgdiobj_event->hgdiobj1, sizeof(lp), &lp), "GetObject should fail\n");
ok(!GetDeviceCaps(hgdiobj_event->hdc, TECHNOLOGY), "GetDeviceCaps(TECHNOLOGY) should fail\n");
@ -151,9 +151,9 @@ static void test_thread_objects(void)
DWORD status;
BOOL bRet;
hgdiobj_event.stop_event = CreateEvent(NULL, 0, 0, NULL);
hgdiobj_event.stop_event = CreateEventA(NULL, 0, 0, NULL);
ok(hgdiobj_event.stop_event != NULL, "CreateEvent error %u\n", GetLastError());
hgdiobj_event.ready_event = CreateEvent(NULL, 0, 0, NULL);
hgdiobj_event.ready_event = CreateEventA(NULL, 0, 0, NULL);
ok(hgdiobj_event.ready_event != NULL, "CreateEvent error %u\n", GetLastError());
hthread = CreateThread(NULL, 0, thread_proc, &hgdiobj_event, 0, &tid);
@ -162,7 +162,7 @@ static void test_thread_objects(void)
status = WaitForSingleObject(hgdiobj_event.ready_event, INFINITE);
ok(status == WAIT_OBJECT_0, "WaitForSingleObject error %u\n", GetLastError());
ret = GetObject(hgdiobj_event.hgdiobj1, sizeof(lp), &lp);
ret = GetObjectA(hgdiobj_event.hgdiobj1, sizeof(lp), &lp);
ok(ret == sizeof(lp), "GetObject error %u\n", GetLastError());
ok(lp.lopnStyle == PS_DASHDOTDOT, "wrong pen style %d\n", lp.lopnStyle);
ok(lp.lopnWidth.x == 17, "wrong pen width.y %d\n", lp.lopnWidth.x);
@ -249,7 +249,7 @@ static void test_GetCurrentObject(void)
hobj = GetCurrentObject(hdc, OBJ_BITMAP);
ok(hobj == hbmp, "OBJ_BITMAP is wrong: %p\n", hobj);
assert(GetObject(hbrush, sizeof(lb), &lb) == sizeof(lb));
assert(GetObjectA(hbrush, sizeof(lb), &lb) == sizeof(lb));
hpen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_SQUARE | PS_JOIN_BEVEL,
10, &lb, 0, NULL);
assert(hpen != 0);

15
rostests/winetests/gdi32/generated.c
View file

@ -4434,13 +4434,6 @@ static void test_pack_NPEXTLOGPEN(void)
TEST_TARGET_ALIGN(NPEXTLOGPEN, 8)
}
static void test_pack_OLDFONTENUMPROC(void)
{
/* OLDFONTENUMPROC */
TEST_TYPE_SIZE (OLDFONTENUMPROC, 8)
TEST_TYPE_ALIGN (OLDFONTENUMPROC, 8)
}
static void test_pack_OLDFONTENUMPROCA(void)
{
/* OLDFONTENUMPROCA */
@ -10964,13 +10957,6 @@ static void test_pack_NPEXTLOGPEN(void)
TEST_TARGET_ALIGN(NPEXTLOGPEN, 4)
}
static void test_pack_OLDFONTENUMPROC(void)
{
/* OLDFONTENUMPROC */
TEST_TYPE_SIZE (OLDFONTENUMPROC, 4)
TEST_TYPE_ALIGN (OLDFONTENUMPROC, 4)
}
static void test_pack_OLDFONTENUMPROCA(void)
{
/* OLDFONTENUMPROCA */
@ -13386,7 +13372,6 @@ static void test_pack(void)
test_pack_NEWTEXTMETRICEXW();
test_pack_NEWTEXTMETRICW();
test_pack_NPEXTLOGPEN();
test_pack_OLDFONTENUMPROC();
test_pack_OLDFONTENUMPROCA();
test_pack_OLDFONTENUMPROCW();
test_pack_OUTLINETEXTMETRICA();

4
rostests/winetests/gdi32/mapping.c
View file

@ -32,7 +32,7 @@ static DWORD (WINAPI *pSetLayout)(HDC hdc, DWORD layout);
static DWORD (WINAPI *pGetLayout)(HDC hdc);
static INT (WINAPI *pGetRandomRgn)(HDC hDC, HRGN hRgn, INT iCode);
static BOOL (WINAPI *pGetTransform)(HDC, DWORD, XFORM *);
static DWORD (WINAPI *pSetVirtualResolution)(HDC, DWORD, DWORD, DWORD, DWORD);
static BOOL (WINAPI *pSetVirtualResolution)(HDC, DWORD, DWORD, DWORD, DWORD);
#define rough_match(got, expected) (abs( MulDiv( (got) - (expected), 1000, (expected) )) <= 5)
@ -513,7 +513,7 @@ static void test_isotropic_mapping(void)
static void test_setvirtualresolution(void)
{
HDC hdc = CreateICA("DISPLAY", NULL, NULL, NULL);
DWORD r;
BOOL r;
INT horz_res = GetDeviceCaps(hdc, HORZRES);
INT horz_size = GetDeviceCaps(hdc, HORZSIZE);
INT log_pixels_x = GetDeviceCaps(hdc, LOGPIXELSX);

8
rostests/winetests/gdi32/metafile.c
View file

@ -2724,7 +2724,7 @@ static HENHMETAFILE create_converted_emf(const METAFILEPICT *mfp)
UINT size;
LPBYTE pBits;
hdcMf = CreateMetaFile(NULL);
hdcMf = CreateMetaFileA(NULL);
ok(hdcMf != NULL, "CreateMetaFile failed with error %d\n", GetLastError());
ret = LineTo(hdcMf, (INT)LINE_X, (INT)LINE_Y);
ok(ret, "LineTo failed with error %d\n", GetLastError());
@ -2904,7 +2904,7 @@ static void test_SetWinMetaFileBits(void)
HDC dc;
LONG diffx, diffy;
wmfDC = CreateMetaFile(NULL);
wmfDC = CreateMetaFileA(NULL);
ok(wmfDC != NULL, "CreateMetaFile failed\n");
if (!wmfDC) return;
@ -3251,7 +3251,7 @@ static void test_gdiis(void)
HMODULE hgdi32;
/* resolve all the functions */
hgdi32 = GetModuleHandle("gdi32");
hgdi32 = GetModuleHandleA("gdi32.dll");
pGdiIsMetaPrintDC = (void*) GetProcAddress(hgdi32, "GdiIsMetaPrintDC");
pGdiIsMetaFileDC = (void*) GetProcAddress(hgdi32, "GdiIsMetaFileDC");
pGdiIsPlayMetafileDC = (void*) GetProcAddress(hgdi32, "GdiIsPlayMetafileDC");
@ -3268,7 +3268,7 @@ static void test_gdiis(void)
ok(!pGdiIsPlayMetafileDC(NULL), "isplaymetafile with NULL parameter\n");
/* try with a metafile */
hmfDC = CreateMetaFile(NULL);
hmfDC = CreateMetaFileA(NULL);
ok(!pGdiIsMetaPrintDC(hmfDC), "ismetaprint on metafile\n");
ok(pGdiIsMetaFileDC(hmfDC), "ismetafile on metafile\n");
ok(!pGdiIsPlayMetafileDC(hmfDC), "isplaymetafile on metafile\n");

8
rostests/winetests/gdi32/palette.c
View file

@ -96,7 +96,7 @@ static void test_DIB_PAL_COLORS(void) {
getColor = GetPixel( memhdc, 0, 0 );
ok( getColor == chkColor, "getColor=%08X\n", (UINT)getColor );
/* Test with a invalid DIBINDEX to DIB_PAL_COLORS */
/* Test with an invalid DIBINDEX to DIB_PAL_COLORS */
setColor = DIBINDEX( 12 );
SetPixel( memhdc, 0, 0, setColor );
chkColor = RGB( 0, 0, 0 );
@ -162,10 +162,10 @@ static void test_halftone_palette(void)
ok( count == 256 || broken(count <= 20), /* nt 4 */
"wrong size %u\n", count );
/* first and last 10 match the default palette */
/* first and last 8 match the default palette */
if (count >= 20)
{
for (i = 0; i < 10; i++)
for (i = 0; i < 8; i++)
{
ok( entries[i].peRed == defpal[i].peRed &&
entries[i].peGreen == defpal[i].peGreen &&
@ -175,7 +175,7 @@ static void test_halftone_palette(void)
entries[i].peRed, entries[i].peGreen, entries[i].peBlue, entries[i].peFlags,
defpal[i].peRed, defpal[i].peGreen, defpal[i].peBlue );
}
for (i = count - 10; i < count; i++)
for (i = count - 8; i < count; i++)
{
int idx = i - count + 20;
ok( entries[i].peRed == defpal[idx].peRed &&

3
rostests/winetests/gdi32/path.c
View file

@ -270,7 +270,8 @@ static void test_widenpath(void)
HDC hdc = GetDC(0);
HPEN greenPen, narrowPen;
POINT pnt[6];
INT nSize, ret;
INT nSize;
BOOL ret;
/* Create a pen to be used in WidenPath */
greenPen = CreatePen(PS_SOLID, 10, RGB(0,0,0));

91
rostests/winetests/gdi32/pen.c
View file

@ -95,7 +95,7 @@ static void test_logpen(void)
memset(&lp, 0xb0, sizeof(lp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(lp), &lp);
size = GetObjectW(hpen, sizeof(lp), &lp);
ok(size == sizeof(lp), "GetObject returned %d, error %d\n", size, GetLastError());
ok(lp.lopnStyle == pen[i].ret_style, "expected %u, got %u\n", pen[i].ret_style, lp.lopnStyle);
@ -114,30 +114,30 @@ static void test_logpen(void)
ok(obj_type == OBJ_PEN, "wrong object type %u\n", obj_type);
/* check what's the real size of the object */
size = GetObject(hpen, 0, NULL);
size = GetObjectW(hpen, 0, NULL);
ok(size == sizeof(lp), "GetObject returned %d, error %d\n", size, GetLastError());
/* ask for truncated data */
memset(&lp, 0xb0, sizeof(lp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(lp.lopnStyle), &lp);
size = GetObjectW(hpen, sizeof(lp.lopnStyle), &lp);
ok(!size, "GetObject should fail: size %d, error %d\n", size, GetLastError());
/* see how larger buffer sizes are handled */
memset(&lp, 0xb0, sizeof(lp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(lp) * 4, &lp);
size = GetObjectW(hpen, sizeof(lp) * 4, &lp);
ok(size == sizeof(lp), "GetObject returned %d, error %d\n", size, GetLastError());
/* see how larger buffer sizes are handled */
memset(&elp, 0xb0, sizeof(elp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(elp) * 2, &elp);
size = GetObjectW(hpen, sizeof(elp) * 2, &elp);
ok(size == sizeof(lp), "GetObject returned %d, error %d\n", size, GetLastError());
memset(&lp, 0xb0, sizeof(lp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(lp), &lp);
size = GetObjectW(hpen, sizeof(lp), &lp);
ok(size == sizeof(lp), "GetObject returned %d, error %d\n", size, GetLastError());
ok(lp.lopnStyle == pen[i].ret_style, "expected %u, got %u\n", pen[i].ret_style, lp.lopnStyle);
@ -147,13 +147,14 @@ static void test_logpen(void)
memset(&elp, 0xb0, sizeof(elp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(elp), &elp);
size = GetObjectW(hpen, sizeof(elp), &elp);
/* for some reason XP differentiates PS_NULL here */
if (pen[i].style == PS_NULL)
{
ok(hpen == GetStockObject(NULL_PEN), "hpen should be a stock NULL_PEN\n");
ok(size == sizeof(EXTLOGPEN), "GetObject returned %d, error %d\n", size, GetLastError());
ok(size == offsetof(EXTLOGPEN, elpStyleEntry[1]), "GetObject returned %d, error %d\n",
size, GetLastError());
ok(elp.elpPenStyle == pen[i].ret_style, "expected %u, got %u\n", pen[i].ret_style, elp.elpPenStyle);
ok(elp.elpWidth == 0, "expected 0, got %u\n", elp.elpWidth);
ok(elp.elpColor == pen[i].ret_color, "expected %08x, got %08x\n", pen[i].ret_color, elp.elpColor);
@ -230,7 +231,7 @@ static void test_logpen(void)
/* check what's the real size of the object */
SetLastError(0xdeadbeef);
size = GetObject(hpen, 0, NULL);
size = GetObjectW(hpen, 0, NULL);
switch (pen[i].style)
{
case PS_NULL:
@ -239,12 +240,12 @@ static void test_logpen(void)
break;
case PS_USERSTYLE:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry[2] ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry[2] ),
"GetObject returned %d, error %d\n", size, GetLastError());
break;
default:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry ),
"GetObject returned %d, error %d\n", size, GetLastError());
break;
}
@ -252,13 +253,13 @@ static void test_logpen(void)
/* ask for truncated data */
memset(&elp, 0xb0, sizeof(elp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(elp.elpPenStyle), &elp);
size = GetObjectW(hpen, sizeof(elp.elpPenStyle), &elp);
ok(!size, "GetObject should fail: size %d, error %d\n", size, GetLastError());
/* see how larger buffer sizes are handled */
memset(elp_buffer, 0xb0, sizeof(elp_buffer));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(elp_buffer), elp_buffer);
size = GetObjectW(hpen, sizeof(elp_buffer), elp_buffer);
switch (pen[i].style)
{
case PS_NULL:
@ -274,15 +275,15 @@ static void test_logpen(void)
memset(&elp, 0xb0, sizeof(elp));
memset(&unset_hatch, 0xb0, sizeof(unset_hatch));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(elp), &elp);
ok(size == sizeof(EXTLOGPEN),
size = GetObjectW(hpen, sizeof(elp), &elp);
ok(size == offsetof(EXTLOGPEN, elpStyleEntry[1]),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(ext_pen->elpHatch == unset_hatch, "expected 0xb0b0b0b0, got %p\n", (void *)ext_pen->elpHatch);
ok(ext_pen->elpNumEntries == 0xb0b0b0b0, "expected 0xb0b0b0b0, got %x\n", ext_pen->elpNumEntries);
break;
case PS_USERSTYLE:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry[2] ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry[2] ),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(ext_pen->elpHatch == HS_CROSS, "expected HS_CROSS, got %p\n", (void *)ext_pen->elpHatch);
ok(ext_pen->elpNumEntries == 2, "expected 0, got %x\n", ext_pen->elpNumEntries);
@ -291,7 +292,7 @@ static void test_logpen(void)
break;
default:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry ),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(ext_pen->elpHatch == HS_CROSS, "expected HS_CROSS, got %p\n", (void *)ext_pen->elpHatch);
ok(ext_pen->elpNumEntries == 0, "expected 0, got %x\n", ext_pen->elpNumEntries);
@ -340,7 +341,7 @@ test_geometric_pens:
ok(obj_type == OBJ_EXTPEN, "wrong object type %u\n", obj_type);
/* check what's the real size of the object */
size = GetObject(hpen, 0, NULL);
size = GetObjectW(hpen, 0, NULL);
switch (pen[i].style)
{
case PS_NULL:
@ -349,12 +350,12 @@ test_geometric_pens:
break;
case PS_USERSTYLE:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry[2] ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry[2] ),
"GetObject returned %d, error %d\n", size, GetLastError());
break;
default:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry ),
"GetObject returned %d, error %d\n", size, GetLastError());
break;
}
@ -362,12 +363,12 @@ test_geometric_pens:
/* ask for truncated data */
memset(&lp, 0xb0, sizeof(lp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(lp.lopnStyle), &lp);
size = GetObjectW(hpen, sizeof(lp.lopnStyle), &lp);
ok(!size, "GetObject should fail: size %d, error %d\n", size, GetLastError());
memset(&lp, 0xb0, sizeof(lp));
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(lp), &lp);
size = GetObjectW(hpen, sizeof(lp), &lp);
/* for some reason XP differentiates PS_NULL here */
if (pen[i].style == PS_NULL)
{
@ -385,18 +386,18 @@ test_geometric_pens:
memset(elp_buffer, 0xb0, sizeof(elp_buffer));
SetLastError(0xdeadbeef);
/* buffer is too small for user styles */
size = GetObject(hpen, sizeof(EXTLOGPEN), elp_buffer);
size = GetObjectW(hpen, offsetof(EXTLOGPEN, elpStyleEntry[1]), elp_buffer);
switch (pen[i].style)
{
case PS_NULL:
ok(size == sizeof(EXTLOGPEN),
ok(size == offsetof(EXTLOGPEN, elpStyleEntry[1]),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(ext_pen->elpHatch == 0, "expected 0, got %p\n", (void *)ext_pen->elpHatch);
ok(ext_pen->elpNumEntries == 0, "expected 0, got %x\n", ext_pen->elpNumEntries);
/* for PS_NULL it also works this way */
SetLastError(0xdeadbeef);
size = GetObject(hpen, sizeof(elp_buffer), &lp);
size = GetObjectW(hpen, sizeof(elp_buffer), &lp);
ok(size == sizeof(LOGPEN),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(lp.lopnStyle == pen[i].ret_style, "expected %u, got %u\n", pen[i].ret_style, lp.lopnStyle);
@ -408,8 +409,8 @@ test_geometric_pens:
case PS_USERSTYLE:
ok(!size /*&& GetLastError() == ERROR_INVALID_PARAMETER*/,
"GetObject should fail: size %d, error %d\n", size, GetLastError());
size = GetObject(hpen, sizeof(elp_buffer), elp_buffer);
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry[2] ),
size = GetObjectW(hpen, sizeof(elp_buffer), elp_buffer);
ok(size == offsetof( EXTLOGPEN, elpStyleEntry[2] ),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(ext_pen->elpHatch == HS_CROSS, "expected HS_CROSS, got %p\n", (void *)ext_pen->elpHatch);
ok(ext_pen->elpNumEntries == 2, "expected 0, got %x\n", ext_pen->elpNumEntries);
@ -418,7 +419,7 @@ test_geometric_pens:
break;
default:
ok(size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ),
ok(size == offsetof( EXTLOGPEN, elpStyleEntry ),
"GetObject returned %d, error %d\n", size, GetLastError());
ok(ext_pen->elpHatch == HS_CROSS, "expected HS_CROSS, got %p\n", (void *)ext_pen->elpHatch);
ok(ext_pen->elpNumEntries == 0, "expected 0, got %x\n", ext_pen->elpNumEntries);
@ -511,12 +512,8 @@ static void test_ps_userstyle(void)
LOGBRUSH lb;
HPEN pen;
INT size, i;
struct
{
EXTLOGPEN elp;
DWORD style_data[15];
} ext_pen;
char buffer[offsetof(EXTLOGPEN, elpStyleEntry) + 16 * sizeof(DWORD)];
EXTLOGPEN *ext_pen = (EXTLOGPEN *)buffer;
lb.lbColor = 0x00ff0000;
lb.lbStyle = BS_SOLID;
@ -561,18 +558,18 @@ static void test_ps_userstyle(void)
pen = ExtCreatePen(PS_GEOMETRIC | PS_USERSTYLE, 50, &lb, 16, style);
ok(pen != 0, "ExtCreatePen should not fail\n");
size = GetObject(pen, sizeof(ext_pen), &ext_pen);
expect(FIELD_OFFSET(EXTLOGPEN,elpStyleEntry[16]), size);
size = GetObjectW(pen, sizeof(buffer), ext_pen);
ok(size == offsetof(EXTLOGPEN, elpStyleEntry[16]), "wrong size %d\n", size);
for(i = 0; i < 16; i++)
expect(style[i], ext_pen.elp.elpStyleEntry[i]);
expect(style[i], ext_pen->elpStyleEntry[i]);
DeleteObject(pen);
}
static void test_brush_pens(void)
{
char buffer[sizeof(EXTLOGPEN) + 15 * sizeof(DWORD)];
char buffer[offsetof(EXTLOGPEN, elpStyleEntry) + 16 * sizeof(DWORD)];
EXTLOGPEN *elp = (EXTLOGPEN *)buffer;
LOGBRUSH lb;
HPEN pen = 0;
@ -604,8 +601,8 @@ static void test_brush_pens(void)
lb.lbHatch = HS_CROSS;
pen = ExtCreatePen( PS_DOT | PS_GEOMETRIC, 3, &lb, 0, NULL );
ok( pen != 0, "ExtCreatePen failed err %u\n", GetLastError() );
size = GetObject( pen, sizeof(buffer), elp );
ok( size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
size = GetObjectW( pen, sizeof(buffer), elp );
ok( size == offsetof( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
ok( elp->elpPenStyle == (PS_DOT | PS_GEOMETRIC), "wrong pen style %x\n", elp->elpPenStyle );
ok( elp->elpBrushStyle == lb.lbStyle, "wrong brush style %x\n", elp->elpBrushStyle );
ok( elp->elpColor == RGB(12,34,56), "wrong color %x\n", elp->elpColor );
@ -616,7 +613,7 @@ static void test_brush_pens(void)
case BS_NULL:
pen = ExtCreatePen( PS_SOLID | PS_GEOMETRIC, 3, &lb, 0, NULL );
ok( pen != 0, "ExtCreatePen failed err %u\n", GetLastError() );
size = GetObject( pen, sizeof(buffer), elp );
size = GetObjectW( pen, sizeof(buffer), elp );
ok( size == sizeof(LOGPEN), "wrong size %u\n", size );
ok( ((LOGPEN *)elp)->lopnStyle == PS_NULL,
"wrong pen style %x\n", ((LOGPEN *)elp)->lopnStyle );
@ -629,8 +626,8 @@ static void test_brush_pens(void)
lb.lbHatch = (ULONG_PTR)bmp;
pen = ExtCreatePen( PS_DOT | PS_GEOMETRIC, 3, &lb, 0, NULL );
ok( pen != 0, "ExtCreatePen failed err %u\n", GetLastError() );
size = GetObject( pen, sizeof(buffer), elp );
ok( size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
size = GetObjectW( pen, sizeof(buffer), elp );
ok( size == offsetof( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
ok( elp->elpPenStyle == (PS_DOT | PS_GEOMETRIC), "wrong pen style %x\n", elp->elpPenStyle );
ok( elp->elpBrushStyle == BS_PATTERN, "wrong brush style %x\n", elp->elpBrushStyle );
ok( elp->elpColor == 0, "wrong color %x\n", elp->elpColor );
@ -644,8 +641,8 @@ static void test_brush_pens(void)
lb.lbHatch = lb.lbStyle == BS_DIBPATTERN ? (ULONG_PTR)hmem : (ULONG_PTR)info;
pen = ExtCreatePen( PS_DOT | PS_GEOMETRIC, 3, &lb, 0, NULL );
ok( pen != 0, "ExtCreatePen failed err %u\n", GetLastError() );
size = GetObject( pen, sizeof(buffer), elp );
ok( size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
size = GetObjectW( pen, sizeof(buffer), elp );
ok( size == offsetof( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
ok( elp->elpPenStyle == (PS_DOT | PS_GEOMETRIC), "wrong pen style %x\n", elp->elpPenStyle );
ok( elp->elpBrushStyle == BS_DIBPATTERNPT, "wrong brush style %x\n", elp->elpBrushStyle );
ok( elp->elpColor == 0, "wrong color %x\n", elp->elpColor );
@ -670,8 +667,8 @@ static void test_brush_pens(void)
if (lb.lbStyle == BS_SOLID)
{
ok( pen != 0, "ExtCreatePen failed err %u\n", GetLastError() );
size = GetObject( pen, sizeof(buffer), elp );
ok( size == FIELD_OFFSET( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
size = GetObjectW( pen, sizeof(buffer), elp );
ok( size == offsetof( EXTLOGPEN, elpStyleEntry ), "wrong size %u\n", size );
ok( elp->elpPenStyle == PS_DOT, "wrong pen style %x\n", elp->elpPenStyle );
ok( elp->elpBrushStyle == BS_SOLID, "wrong brush style %x\n", elp->elpBrushStyle );
ok( elp->elpColor == RGB(12,34,56), "wrong color %x\n", elp->elpColor );

2
rostests/winetests/gdi32/resource.rc
View file

@ -23,6 +23,8 @@
/* @makedep: wine_test.ttf */
wine_test.ttf RCDATA wine_test.ttf
/* @makedep: wine_vdmx.ttf */
wine_vdmx.ttf RCDATA wine_vdmx.ttf
/* @makedep: vertical.ttf */
vertical.ttf RCDATA vertical.ttf

5
rostests/winetests/gdi32/testlist.c
View file

@ -1,10 +1,7 @@
/* Automatically generated file; DO NOT EDIT!! */
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define STANDALONE
#include "wine/test.h"
#include <wine/test.h>
extern void func_bitmap(void);
extern void func_brush(void);

1060
rostests/winetests/gdi32/vertical.sfd
View file

File diff suppressed because it is too large Load diff

BIN
rostests/winetests/gdi32/vertical.ttf
View file

Binary file not shown.

60
rostests/winetests/gdi32/wine_test.sfd
View file

@ -20,7 +20,7 @@ OS2Version: 2
OS2_WeightWidthSlopeOnly: 0
OS2_UseTypoMetrics: 1
CreationTime: 1288336343
ModificationTime: 1352483620
ModificationTime: 1366465321
PfmFamily: 17
TTFWeight: 500
TTFWidth: 5
@ -32,10 +32,10 @@ OS2TypoAOffset: 1
OS2TypoDescent: 0
OS2TypoDOffset: 1
OS2TypoLinegap: 184
OS2WinAscent: 0
OS2WinAOffset: 1
OS2WinDescent: 0
OS2WinDOffset: 1
OS2WinAscent: 1638
OS2WinAOffset: 0
OS2WinDescent: 410
OS2WinDOffset: 0
HheadAscent: 0
HheadAOffset: 1
HheadDescent: 0
@ -78,15 +78,17 @@ ShortTable: maxp 16
0
EndShort
LangName: 1033 "" "" "" "Wine : wine_test : 4-11-2010"
GaspTable: 1 65535 2
GaspTable: 1 65535 2 0
Encoding: UnicodeBmp
UnicodeInterp: none
NameList: Adobe Glyph List
DisplaySize: -24
AntiAlias: 1
FitToEm: 1
WinInfo: 65 65 19
BeginChars: 65539 5
WinInfo: 48 16 4
BeginPrivate: 0
EndPrivate
BeginChars: 65539 7
StartChar: .notdef
Encoding: 65536 -1 0
@ -178,10 +180,10 @@ LayerCount: 2
EndChar
StartChar: dieresis
Encoding: 168 168 0
Encoding: 168 168 4
Width: 1000
VWidth: 0
Flags: HW
Flags: W
LayerCount: 2
Fore
SplineSet
@ -201,5 +203,43 @@ SplineSet
310.707 834.805 310.707 834.805 254.492 773.213 c 1,12,13
EndSplineSet
EndChar
StartChar: A
Encoding: 65 65 5
Width: 1000
VWidth: 0
Flags: WO
LayerCount: 2
Fore
SplineSet
459 1258 m 29,0,-1
462 1639 l 5,1,-1
389 1638 l 5,2,-1
492 1815 l 5,3,-1
609 1638.5 l 5,4,-1
531 1637.5 l 5,5,-1
523 1258 l 5,6,-1
459 1258 l 29,0,-1
EndSplineSet
EndChar
StartChar: D
Encoding: 68 68 6
Width: 1000
VWidth: 0
Flags: WO
LayerCount: 2
Fore
SplineSet
461 -30.7998 m 29,0,-1
464 -411.8 l 5,1,-1
391 -410.8 l 5,2,-1
494 -587.8 l 5,3,-1
611 -411.3 l 5,4,-1
533 -410.3 l 5,5,-1
525 -30.7998 l 5,6,-1
461 -30.7998 l 29,0,-1
EndSplineSet
EndChar
EndChars
EndSplineFont

BIN
rostests/winetests/gdi32/wine_test.ttf
View file

Binary file not shown.

271
rostests/winetests/gdi32/wine_vdmx.sfd Normal file
View file

@ -0,0 +1,271 @@
SplineFontDB: 3.0
FontName: wine_vdmx
FullName: wine_vdmx
FamilyName: wine_vdmx
Weight: Medium
Copyright: Copyright (c) 2010 Dmitry Timoshkov
Version: 001.000
ItalicAngle: 0
UnderlinePosition: -170
UnderlineWidth: 130
Ascent: 1638
Descent: 410
sfntRevision: 0x00010000
LayerCount: 2
Layer: 0 1 "Back" 1
Layer: 1 1 "Fore" 0
XUID: [1021 905 592216984 1247726]
FSType: 0
OS2Version: 2
OS2_WeightWidthSlopeOnly: 0
OS2_UseTypoMetrics: 1
PfmFamily: 33
TTFWeight: 400
TTFWidth: 5
LineGap: 0
VLineGap: 0
Panose: 2 11 6 4 3 5 4 4 2 4
OS2TypoAscent: 1566
OS2TypoAOffset: 0
OS2TypoDescent: -423
OS2TypoDOffset: 0
OS2TypoLinegap: 59
OS2WinAscent: 2049
OS2WinAOffset: 0
OS2WinDescent: 423
OS2WinDOffset: 0
HheadAscent: 2049
HheadAOffset: 0
HheadDescent: -423
HheadDOffset: 0
OS2SubXSize: 1331
OS2SubYSize: 1433
OS2SubXOff: 0
OS2SubYOff: 2861
OS2SupXSize: 1331
OS2SupYSize: 1433
OS2SupXOff: 0
OS2SupYOff: 983
OS2StrikeYSize: 102
OS2StrikeYPos: 530
OS2Vendor: 'Wine'
OS2CodePages: 00000001.00000000
OS2UnicodeRanges: 00000001.00000000.00000000.00000000
MarkAttachClasses: 1
DEI: 91125
ShortTable: cvt 2
68
1297
EndShort
ShortTable: maxp 16
1
0
4
8
2
0
0
2
0
1
1
0
64
46
0
0
EndShort
TtfTable: VDMX 1504
!!!!"!!*'#!<E0/!;Hj"!!iQ1s8E!)!"&])!"&]5s8E!+!"8i+!"8i:s8;p,!"Ju,!"Ju>s82j-
!"f2.!"],Bs82j/!##>0!"o8Fs82j1!#>P3!#,DKs82j3!#P\5!#>PNs82j5!#Yb5!#P\Ss7u^5
!#kn6!#bhVs7u^7!$2+9!#tt[s7u^9!$;1:!$2+_s7u^;!$VC=!$D7bs7lX<!$_I=!$VCgs7lX>
!%%[@!$hOks7lX@!%7gA!%%[os7cRA!%@mB!%7gss7ZLB!%\*D!%It"s7ZLD!%n6F!%\+&s7QFE
!&"<F!%n7*s7QFG!&=NI!&+C.s7QFI!&OZK!&=O2s7QFK!&jlN!&O[6s7H@L!&srN!&ag:s7H@N
!'(#O!&ss?s7?:O!'L;R!'1*Cs7?:Q!'UAS!'C6Fs7?:S!'gMU!'UBJs764T!($YU!'gNOs7-.U
!(6eW!($ZRs7-.W!(R"Z!(6fWs7-.Y!([([!(HrZs7-.[!)!:^!([)_s7$(\!)3F^!(m5cs6p"]
!)<L_!)*Afs6p"_!)NXa!)<Mks6p"a!)ijd!)NYos6p"c!*'!e!)`ers6fqd!*9-g!)rr"s6fqf
!*B3h!*0)&s6]kg!*]Ej!*B5*s6Teh!*oQk!*TA.s6Tej!+,]m!*fM1s6K_k!+5cm!+#Y7s6K_m
!+Pup!+5e:s6K_o!+c,q!+Gq=s6BYp!+u8s!+Z(Bs6BYr!,;K!!+l4Fs69Ss!,DQ!!,)@Ks69Su
!,V]#!,;LNs69T"!,hi$!,MXQs60N#!-/&'!,_dWs60N%!-A2)!,qpZs6'H&!-J8)!-/'_s6'H(
!-eJ,!-A3ds6'H*!.+\.!-S?gs5sB+!.4b/!-eKls5sB-!.Ot2!."Wos5j<.!.Y%2!.4cts5j<0
!.t75!.Fp#s5j<2!/1C6!.Y'&s5a63!/:I7!.k3*s5a65!/^a;!/(?/s5X06!/gg;!/:K3s5X08
!/pm<!/LW7s5X0:!07*>!/^c:s5O*;!0I6@!/po?s5O*=!0dHB!0.&Cs5F$>!0mNC!0@2Gs5F$@
!1!TD!0R>Ks5F$B!1ElG!0dJOs5<sC!1NrH!1!VSs5<sE!1a)I!13bWs53mF!1s5K!1En\s53mH
!20AM!1X%_s53mJ!2KSO!1j1cs5*gK!2TYP!2'=gs5*gM!2okS!29Iks5!aN!3-"T!2KUps5!aP
!36(U!2]ass5!aR!3H4V!2on"s4m[S!3cFY!3-%'s4dUT!3lLY!3?1*s4dUV!42^\!3Q=/s4dUX
!4;d]!3cI3s4dUZ!4W!_!3uU6s4[O[!4i-a!42a;s4[O]!4r3b!4Dm>s4RI^!5/?c!4W$Ds4RI`
!5JQf!4i0Gs4RIb!5\]g!5&<Js4ICc!5nii!58HPs4@=d!65&k!5JTTs4@=f!6G2m!5\`Xs4@=h
!6Y>o!5nl\s4@=j!6kJp!6,#_s477k!7(Vq!6>/es4.1l!7:bs!6P;hs4.1n!7Lnu!6bGls4.1p
!7_&"!6tSqs4.1r!8%8$!71_ts4%+s!8.>%!7Cl#s4%+u!8@J'!7V#'s3q&!!8[\)!7h/,s3q&#
!8db)!8%;0s3gu$!9*t,!87G3s3gu&!94%,!8IS7s3^o'!9O7/!8[_<s3^o)!9aC1!8mk@s3^o+
!9jI2!9+"Ds3^o-!:0[4!9=.Hs3Ui.!:Bg6!9O:Ls3Ui0!:Km6!9aFPs3Lc1!:g*9!9sRTs3Lc3
!:p0:!:0^Xs3Lc5!;?H=!:Bj\s3:W5!;HN=!:U!`s3:W7!;QT>!:g-ds3:W9!;ulB!;$9hs3:W;
!<)rC!;6Els31Q<!<<)D!;HQps3(K=!<N5E!;Z]ts3(K?!<`AG!;lj#s3(KA!=&SJ!<*!'s3(KC
!=/YK
EndTtf
LangName: 1033 "" "" "" "Wine : wine_vdmx : 4-11-2010"
GaspTable: 1 65535 2 0
Encoding: UnicodeBmp
UnicodeInterp: none
NameList: Adobe Glyph List
DisplaySize: -24
AntiAlias: 1
FitToEm: 1
WinInfo: 48 16 4
BeginPrivate: 0
EndPrivate
BeginChars: 65539 7
StartChar: .notdef
Encoding: 65536 -1 0
Width: 748
Flags: W
TtInstrs:
PUSHB_2
1
0
MDAP[rnd]
ALIGNRP
PUSHB_3
7
4
0
MIRP[min,rnd,black]
SHP[rp2]
PUSHB_2
6
5
MDRP[rp0,min,rnd,grey]
ALIGNRP
PUSHB_3
3
2
0
MIRP[min,rnd,black]
SHP[rp2]
SVTCA[y-axis]
PUSHB_2
3
0
MDAP[rnd]
ALIGNRP
PUSHB_3
5
4
0
MIRP[min,rnd,black]
SHP[rp2]
PUSHB_3
7
6
1
MIRP[rp0,min,rnd,grey]
ALIGNRP
PUSHB_3
1
2
0
MIRP[min,rnd,black]
SHP[rp2]
EndTTInstrs
LayerCount: 2
Fore
SplineSet
68 0 m 1,0,-1
68 1365 l 1,1,-1
612 1365 l 1,2,-1
612 0 l 1,3,-1
68 0 l 1,0,-1
136 68 m 1,4,-1
544 68 l 1,5,-1
544 1297 l 1,6,-1
136 1297 l 1,7,-1
136 68 l 1,4,-1
EndSplineSet
EndChar
StartChar: .null
Encoding: 65537 -1 1
Width: 0
Flags: W
LayerCount: 2
EndChar
StartChar: nonmarkingreturn
Encoding: 65538 -1 2
Width: 682
Flags: W
LayerCount: 2
EndChar
StartChar: exclam
Encoding: 33 33 3
Width: 0
Flags: W
LayerCount: 2
EndChar
StartChar: dieresis
Encoding: 168 168 4
Width: 1000
VWidth: 0
Flags: W
LayerCount: 2
Fore
SplineSet
620.215 824.429 m 1,0,1
760.84 777.554 760.84 777.554 713.965 636.929 c 1,2,-1
620.215 824.429 l 1,0,1
154.883 324.971 m 0,3,-1
254.492 773.213 m 1,4,5
310.707 834.805 310.707 834.805 374.609 767.354 c 1,6,7
410.471 728.672 410.471 728.672 374.609 691.182 c 0,8,9
308.375 621.934 308.375 621.934 254.492 688.252 c 0,10,11
216.406 735.127 216.406 735.127 254.492 773.213 c 1,4,5
254.492 773.213 m 1,12,13
216.406 735.127 216.406 735.127 254.492 688.252 c 0,14,15
308.375 621.934 308.375 621.934 374.609 691.182 c 0,16,17
410.471 728.672 410.471 728.672 374.609 767.354 c 1,18,19
310.707 834.805 310.707 834.805 254.492 773.213 c 1,12,13
EndSplineSet
EndChar
StartChar: A
Encoding: 65 65 5
Width: 1000
VWidth: 0
Flags: W
LayerCount: 2
Fore
SplineSet
459 1258 m 29,0,-1
462 1639 l 5,1,-1
389 1638 l 5,2,-1
492 1815 l 5,3,-1
609 1638.5 l 5,4,-1
531 1637.5 l 5,5,-1
523 1258 l 5,6,-1
459 1258 l 29,0,-1
EndSplineSet
EndChar
StartChar: D
Encoding: 68 68 6
Width: 1000
VWidth: 0
Flags: W
LayerCount: 2
Fore
SplineSet
461 -30.7998 m 29,0,-1
464 -411.8 l 5,1,-1
391 -410.8 l 5,2,-1
494 -587.8 l 5,3,-1
611 -411.3 l 5,4,-1
533 -410.3 l 5,5,-1
525 -30.7998 l 5,6,-1
461 -30.7998 l 29,0,-1
EndSplineSet
EndChar
EndChars
EndSplineFont

BIN
rostests/winetests/gdi32/wine_vdmx.ttf Normal file
View file

Binary file not shown.