?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.39.
[wine/gsoc-2012-control.git] / dlls / gdi32 / tests / bitmap.c
blob353e2c59a077bc5cae7e1c4b5b5a10324e1e8436
1 /*
2 * Unit test suite for bitmaps
3 *
4 * Copyright 2004 Huw Davies
5 * Copyright 2006 Dmitry Timoshkov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <assert.h>
24 #include <string.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "mmsystem.h"
31
32 #include "wine/test.h"
33
34 static BOOL is_win9x;
35
36 static INT BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
37 {
38 switch(bpp)
39 {
40 case 1:
41 return 2 * ((bmWidth+15) >> 4);
42
43 case 24:
44 bmWidth *= 3; /* fall through */
45 case 8:
46 return bmWidth + (bmWidth & 1);
47
48 case 32:
49 return bmWidth * 4;
50
51 case 16:
52 case 15:
53 return bmWidth * 2;
54
55 case 4:
56 return 2 * ((bmWidth+3) >> 2);
57
58 default:
59 trace("Unknown depth %d, please report.\n", bpp );
60 assert(0);
61 }
62 return -1;
63 }
64
65 static void test_bitmap_info(HBITMAP hbm, INT expected_depth, const BITMAPINFOHEADER *bmih)
66 {
67 BITMAP bm;
68 INT ret, width_bytes;
69 char buf[512], buf_cmp[512];
70
71 ret = GetObject(hbm, sizeof(bm), &bm);
72 ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
73
74 ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
75 ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
76 ok(bm.bmHeight == bmih->biHeight, "wrong bm.bmHeight %d\n", bm.bmHeight);
77 width_bytes = BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel);
78 ok(bm.bmWidthBytes == width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, width_bytes);
79 ok(bm.bmPlanes == bmih->biPlanes, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
80 ok(bm.bmBitsPixel == expected_depth, "wrong bm.bmBitsPixel %d != %d\n", bm.bmBitsPixel, expected_depth);
81 ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
82
83 assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
84 assert(sizeof(buf) == sizeof(buf_cmp));
85
86 ret = GetBitmapBits(hbm, 0, NULL);
87 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
88
89 memset(buf_cmp, 0xAA, sizeof(buf_cmp));
90 memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);
91
92 memset(buf, 0xAA, sizeof(buf));
93 ret = GetBitmapBits(hbm, sizeof(buf), buf);
94 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
95 ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
96
97 /* test various buffer sizes for GetObject */
98 ret = GetObject(hbm, 0, NULL);
99 ok(ret == sizeof(bm), "wrong size %d\n", ret);
100
101 ret = GetObject(hbm, sizeof(bm) * 2, &bm);
102 ok(ret == sizeof(bm), "wrong size %d\n", ret);
103
104 ret = GetObject(hbm, sizeof(bm) / 2, &bm);
105 ok(ret == 0, "%d != 0\n", ret);
106
107 ret = GetObject(hbm, 0, &bm);
108 ok(ret == 0, "%d != 0\n", ret);
109
110 ret = GetObject(hbm, 1, &bm);
111 ok(ret == 0, "%d != 0\n", ret);
112 }
113
114 static void test_createdibitmap(void)
115 {
116 HDC hdc, hdcmem;
117 BITMAPINFOHEADER bmih;
118 HBITMAP hbm, hbm_colour, hbm_old;
119 INT screen_depth;
120
121 hdc = GetDC(0);
122 screen_depth = GetDeviceCaps(hdc, BITSPIXEL);
123 memset(&bmih, 0, sizeof(bmih));
124 bmih.biSize = sizeof(bmih);
125 bmih.biWidth = 10;
126 bmih.biHeight = 10;
127 bmih.biPlanes = 1;
128 bmih.biBitCount = 32;
129 bmih.biCompression = BI_RGB;
130
131 /* First create an un-initialised bitmap. The depth of the bitmap
132 should match that of the hdc and not that supplied in bmih.
133 */
134
135 /* First try 32 bits */
136 hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
137 ok(hbm != NULL, "CreateDIBitmap failed\n");
138 test_bitmap_info(hbm, screen_depth, &bmih);
139 DeleteObject(hbm);
140
141 /* Then 16 */
142 bmih.biBitCount = 16;
143 hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
144 ok(hbm != NULL, "CreateDIBitmap failed\n");
145 test_bitmap_info(hbm, screen_depth, &bmih);
146 DeleteObject(hbm);
147
148 /* Then 1 */
149 bmih.biBitCount = 1;
150 hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
151 ok(hbm != NULL, "CreateDIBitmap failed\n");
152 test_bitmap_info(hbm, screen_depth, &bmih);
153 DeleteObject(hbm);
154
155 /* Now with a monochrome dc we expect a monochrome bitmap */
156 hdcmem = CreateCompatibleDC(hdc);
157
158 /* First try 32 bits */
159 bmih.biBitCount = 32;
160 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
161 ok(hbm != NULL, "CreateDIBitmap failed\n");
162 test_bitmap_info(hbm, 1, &bmih);
163 DeleteObject(hbm);
164
165 /* Then 16 */
166 bmih.biBitCount = 16;
167 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
168 ok(hbm != NULL, "CreateDIBitmap failed\n");
169 test_bitmap_info(hbm, 1, &bmih);
170 DeleteObject(hbm);
171
172 /* Then 1 */
173 bmih.biBitCount = 1;
174 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
175 ok(hbm != NULL, "CreateDIBitmap failed\n");
176 test_bitmap_info(hbm, 1, &bmih);
177 DeleteObject(hbm);
178
179 /* Now select a polychrome bitmap into the dc and we expect
180 screen_depth bitmaps again */
181 hbm_colour = CreateCompatibleBitmap(hdc, 1, 1);
182 hbm_old = SelectObject(hdcmem, hbm_colour);
183
184 /* First try 32 bits */
185 bmih.biBitCount = 32;
186 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
187 ok(hbm != NULL, "CreateDIBitmap failed\n");
188 test_bitmap_info(hbm, screen_depth, &bmih);
189 DeleteObject(hbm);
190
191 /* Then 16 */
192 bmih.biBitCount = 16;
193 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
194 ok(hbm != NULL, "CreateDIBitmap failed\n");
195 test_bitmap_info(hbm, screen_depth, &bmih);
196 DeleteObject(hbm);
197
198 /* Then 1 */
199 bmih.biBitCount = 1;
200 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
201 ok(hbm != NULL, "CreateDIBitmap failed\n");
202 test_bitmap_info(hbm, screen_depth, &bmih);
203 DeleteObject(hbm);
204
205 SelectObject(hdcmem, hbm_old);
206 DeleteObject(hbm_colour);
207 DeleteDC(hdcmem);
208
209 /* If hdc == 0 then we get a 1 bpp bitmap */
210 if (!is_win9x) {
211 bmih.biBitCount = 32;
212 hbm = CreateDIBitmap(0, &bmih, 0, NULL, NULL, 0);
213 ok(hbm != NULL, "CreateDIBitmap failed\n");
214 test_bitmap_info(hbm, 1, &bmih);
215 DeleteObject(hbm);
216 }
217
218 ReleaseDC(0, hdc);
219 }
220
221 static INT DIB_GetWidthBytes( int width, int bpp )
222 {
223 int words;
224
225 switch (bpp)
226 {
227 case 1: words = (width + 31) / 32; break;
228 case 4: words = (width + 7) / 8; break;
229 case 8: words = (width + 3) / 4; break;
230 case 15:
231 case 16: words = (width + 1) / 2; break;
232 case 24: words = (width * 3 + 3)/4; break;
233 case 32: words = width; break;
234
235 default:
236 words=0;
237 trace("Unknown depth %d, please report.\n", bpp );
238 assert(0);
239 break;
240 }
241 return 4 * words;
242 }
243
244 static void test_dib_info(HBITMAP hbm, const void *bits, const BITMAPINFOHEADER *bmih)
245 {
246 BITMAP bm;
247 DIBSECTION ds;
248 INT ret, width_bytes;
249 BYTE *buf;
250
251 ret = GetObject(hbm, sizeof(bm), &bm);
252 ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
253
254 ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
255 ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
256 ok(bm.bmHeight == bmih->biHeight, "wrong bm.bmHeight %d\n", bm.bmHeight);
257 width_bytes = DIB_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel);
258 ok(bm.bmWidthBytes == width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, width_bytes);
259 ok(bm.bmPlanes == bmih->biPlanes, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
260 ok(bm.bmBitsPixel == bmih->biBitCount, "bm.bmBitsPixel %d != %d\n", bm.bmBitsPixel, bmih->biBitCount);
261 ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);
262
263 buf = HeapAlloc(GetProcessHeap(), 0, bm.bmWidthBytes * bm.bmHeight + 4096);
264
265 width_bytes = BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel);
266
267 /* GetBitmapBits returns not 32-bit aligned data */
268 ret = GetBitmapBits(hbm, 0, NULL);
269 ok(ret == width_bytes * bm.bmHeight, "%d != %d\n", ret, width_bytes * bm.bmHeight);
270
271 memset(buf, 0xAA, bm.bmWidthBytes * bm.bmHeight + 4096);
272 ret = GetBitmapBits(hbm, bm.bmWidthBytes * bm.bmHeight + 4096, buf);
273 ok(ret == width_bytes * bm.bmHeight, "%d != %d\n", ret, width_bytes * bm.bmHeight);
274
275 HeapFree(GetProcessHeap(), 0, buf);
276
277 /* test various buffer sizes for GetObject */
278 memset(&ds, 0xAA, sizeof(ds));
279 ret = GetObject(hbm, sizeof(bm) * 2, &bm);
280 ok(ret == sizeof(bm), "wrong size %d\n", ret);
281 ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
282 ok(bm.bmHeight == bmih->biHeight, "wrong bm.bmHeight %d\n", bm.bmHeight);
283 ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);
284
285 ret = GetObject(hbm, sizeof(bm) / 2, &bm);
286 ok(ret == 0, "%d != 0\n", ret);
287
288 ret = GetObject(hbm, 0, &bm);
289 ok(ret == 0, "%d != 0\n", ret);
290
291 ret = GetObject(hbm, 1, &bm);
292 ok(ret == 0, "%d != 0\n", ret);
293
294 /* test various buffer sizes for GetObject */
295 ret = GetObject(hbm, 0, NULL);
296 ok(ret == sizeof(bm), "wrong size %d\n", ret);
297
298 memset(&ds, 0xAA, sizeof(ds));
299 ret = GetObject(hbm, sizeof(ds) * 2, &ds);
300 ok(ret == sizeof(ds), "wrong size %d\n", ret);
301
302 ok(ds.dsBm.bmBits == bits, "wrong bm.bmBits %p != %p\n", ds.dsBm.bmBits, bits);
303 ok(ds.dsBmih.biSizeImage == ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight, "%u != %u\n",
304 ds.dsBmih.biSizeImage, ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight);
305 ok(bmih->biSizeImage == 0, "%u != 0\n", bmih->biSizeImage);
306 ds.dsBmih.biSizeImage = 0;
307
308 ok(ds.dsBmih.biSize == bmih->biSize, "%u != %u\n", ds.dsBmih.biSize, bmih->biSize);
309 ok(ds.dsBmih.biWidth == bmih->biWidth, "%u != %u\n", ds.dsBmih.biWidth, bmih->biWidth);
310 ok(ds.dsBmih.biHeight == bmih->biHeight, "%u != %u\n", ds.dsBmih.biHeight, bmih->biHeight);
311 ok(ds.dsBmih.biPlanes == bmih->biPlanes, "%u != %u\n", ds.dsBmih.biPlanes, bmih->biPlanes);
312 ok(ds.dsBmih.biBitCount == bmih->biBitCount, "%u != %u\n", ds.dsBmih.biBitCount, bmih->biBitCount);
313 ok(ds.dsBmih.biCompression == bmih->biCompression, "%u != %u\n", ds.dsBmih.biCompression, bmih->biCompression);
314 ok(ds.dsBmih.biSizeImage == bmih->biSizeImage, "%u != %u\n", ds.dsBmih.biSizeImage, bmih->biSizeImage);
315 ok(ds.dsBmih.biXPelsPerMeter == bmih->biXPelsPerMeter, "%u != %u\n", ds.dsBmih.biXPelsPerMeter, bmih->biXPelsPerMeter);
316 ok(ds.dsBmih.biYPelsPerMeter == bmih->biYPelsPerMeter, "%u != %u\n", ds.dsBmih.biYPelsPerMeter, bmih->biYPelsPerMeter);
317
318 memset(&ds, 0xAA, sizeof(ds));
319 ret = GetObject(hbm, sizeof(ds) - 4, &ds);
320 ok(ret == sizeof(ds.dsBm), "wrong size %d\n", ret);
321 ok(ds.dsBm.bmWidth == bmih->biWidth, "%u != %u\n", ds.dsBmih.biWidth, bmih->biWidth);
322 ok(ds.dsBm.bmHeight == bmih->biHeight, "%u != %u\n", ds.dsBmih.biHeight, bmih->biHeight);
323 ok(ds.dsBm.bmBits == bits, "%p != %p\n", ds.dsBm.bmBits, bits);
324
325 ret = GetObject(hbm, 0, &ds);
326 ok(ret == 0, "%d != 0\n", ret);
327
328 ret = GetObject(hbm, 1, &ds);
329 ok(ret == 0, "%d != 0\n", ret);
330 }
331
332 #define test_color_todo(got, exp, txt, todo) \
333 if (!todo && got != exp && screen_depth < 24) { \
334 todo_wine ok(0, #txt " failed at %d-bit screen depth: got 0x%06x expected 0x%06x - skipping DIB tests\n", \
335 screen_depth, (UINT)got, (UINT)exp); \
336 return; \
337 } else if (todo) todo_wine { ok(got == exp, #txt " failed: got 0x%06x expected 0x%06x\n", (UINT)got, (UINT)exp); } \
338 else ok(got == exp, #txt " failed: got 0x%06x expected 0x%06x\n", (UINT)got, (UINT)exp) \
339
340 #define test_color(hdc, color, exp, todo_setp, todo_getp) \
341 { \
342 COLORREF c; \
343 c = SetPixel(hdc, 0, 0, color); \
344 if (!is_win9x) { test_color_todo(c, exp, SetPixel, todo_setp); } \
345 c = GetPixel(hdc, 0, 0); \
346 test_color_todo(c, exp, GetPixel, todo_getp); \
347 }
348
349 static void test_dibsections(void)
350 {
351 HDC hdc, hdcmem, hdcmem2;
352 HBITMAP hdib, oldbm, hdib2, oldbm2;
353 char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
354 char bcibuf[sizeof(BITMAPCOREINFO) + 256 * sizeof(RGBTRIPLE)];
355 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
356 BITMAPCOREINFO *pbci = (BITMAPCOREINFO *)bcibuf;
357 HBITMAP hcoredib;
358 char coreBits[256];
359 BYTE *bits;
360 RGBQUAD rgb[256];
361 int ret;
362 char logpalbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
363 LOGPALETTE *plogpal = (LOGPALETTE*)logpalbuf;
364 WORD *index;
365 DWORD *bits32;
366 HPALETTE hpal, oldpal;
367 DIBSECTION dibsec;
368 COLORREF c0, c1;
369 int i;
370 int screen_depth;
371 MEMORY_BASIC_INFORMATION info;
372
373 hdc = GetDC(0);
374 screen_depth = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
375
376 memset(pbmi, 0, sizeof(bmibuf));
377 pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
378 pbmi->bmiHeader.biHeight = 100;
379 pbmi->bmiHeader.biWidth = 512;
380 pbmi->bmiHeader.biBitCount = 24;
381 pbmi->bmiHeader.biPlanes = 1;
382 pbmi->bmiHeader.biCompression = BI_RGB;
383
384 SetLastError(0xdeadbeef);
385 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
386 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
387 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
388 ok(dibsec.dsBm.bmBits == bits, "dibsec.dsBits %p != bits %p\n", dibsec.dsBm.bmBits, bits);
389
390 /* test the DIB memory */
391 ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
392 "VirtualQuery failed\n");
393 ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
394 ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
395 ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
396 ok(info.RegionSize == 0x26000, "0x%lx != 0x26000\n", info.RegionSize);
397 ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
398 ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
399 ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
400
401 test_dib_info(hdib, bits, &pbmi->bmiHeader);
402 DeleteObject(hdib);
403
404 pbmi->bmiHeader.biBitCount = 8;
405 pbmi->bmiHeader.biCompression = BI_RLE8;
406 SetLastError(0xdeadbeef);
407 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
408 ok(hdib == NULL, "CreateDIBSection should fail when asked to create a compressed DIB section\n");
409 ok(GetLastError() == 0xdeadbeef, "wrong error %d\n", GetLastError());
410
411 pbmi->bmiHeader.biBitCount = 16;
412 pbmi->bmiHeader.biCompression = BI_BITFIELDS;
413 ((PDWORD)pbmi->bmiColors)[0] = 0xf800;
414 ((PDWORD)pbmi->bmiColors)[1] = 0x07e0;
415 ((PDWORD)pbmi->bmiColors)[2] = 0x001f;
416 SetLastError(0xdeadbeef);
417 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
418 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
419
420 /* test the DIB memory */
421 ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
422 "VirtualQuery failed\n");
423 ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
424 ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
425 ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
426 ok(info.RegionSize == 0x19000, "0x%lx != 0x19000\n", info.RegionSize);
427 ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
428 ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
429 ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
430
431 test_dib_info(hdib, bits, &pbmi->bmiHeader);
432 DeleteObject(hdib);
433
434 memset(pbmi, 0, sizeof(bmibuf));
435 pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
436 pbmi->bmiHeader.biHeight = 16;
437 pbmi->bmiHeader.biWidth = 16;
438 pbmi->bmiHeader.biBitCount = 1;
439 pbmi->bmiHeader.biPlanes = 1;
440 pbmi->bmiHeader.biCompression = BI_RGB;
441 pbmi->bmiColors[0].rgbRed = 0xff;
442 pbmi->bmiColors[0].rgbGreen = 0;
443 pbmi->bmiColors[0].rgbBlue = 0;
444 pbmi->bmiColors[1].rgbRed = 0;
445 pbmi->bmiColors[1].rgbGreen = 0;
446 pbmi->bmiColors[1].rgbBlue = 0xff;
447
448 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
449 ok(hdib != NULL, "CreateDIBSection failed\n");
450 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
451 ok(dibsec.dsBmih.biClrUsed == 2,
452 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
453
454 /* Test if the old BITMAPCOREINFO structure is supported */
455
456 pbci->bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
457 pbci->bmciHeader.bcBitCount = 0;
458
459 if (!is_win9x) {
460 ret = GetDIBits(hdc, hdib, 0, 16, NULL, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
461 ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
462 ok((pbci->bmciHeader.bcWidth == 16) && (pbci->bmciHeader.bcHeight == 16)
463 && (pbci->bmciHeader.bcBitCount == 1) && (pbci->bmciHeader.bcPlanes == 1),
464 "GetDIBits did't fill in the BITMAPCOREHEADER structure properly\n");
465
466 ret = GetDIBits(hdc, hdib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
467 ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
468 ok((pbci->bmciColors[0].rgbtRed == 0xff) && (pbci->bmciColors[0].rgbtGreen == 0) &&
469 (pbci->bmciColors[0].rgbtBlue == 0) && (pbci->bmciColors[1].rgbtRed == 0) &&
470 (pbci->bmciColors[1].rgbtGreen == 0) && (pbci->bmciColors[1].rgbtBlue == 0xff),
471 "The color table has not been translated to the old BITMAPCOREINFO format\n");
472
473 hcoredib = CreateDIBSection(hdc, (BITMAPINFO*) pbci, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
474 ok(hcoredib != NULL, "CreateDIBSection failed with a BITMAPCOREINFO\n");
475
476 ZeroMemory(pbci->bmciColors, 256 * sizeof(RGBTRIPLE));
477 ret = GetDIBits(hdc, hcoredib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
478 ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
479 ok((pbci->bmciColors[0].rgbtRed == 0xff) && (pbci->bmciColors[0].rgbtGreen == 0) &&
480 (pbci->bmciColors[0].rgbtBlue == 0) && (pbci->bmciColors[1].rgbtRed == 0) &&
481 (pbci->bmciColors[1].rgbtGreen == 0) && (pbci->bmciColors[1].rgbtBlue == 0xff),
482 "The color table has not been translated to the old BITMAPCOREINFO format\n");
483
484 DeleteObject(hcoredib);
485 }
486
487 hdcmem = CreateCompatibleDC(hdc);
488 oldbm = SelectObject(hdcmem, hdib);
489
490 ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
491 ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
492 ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
493 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
494 rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
495 rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
496
497 c0 = RGB(pbmi->bmiColors[0].rgbRed, pbmi->bmiColors[0].rgbGreen, pbmi->bmiColors[0].rgbBlue);
498 c1 = RGB(pbmi->bmiColors[1].rgbRed, pbmi->bmiColors[1].rgbGreen, pbmi->bmiColors[1].rgbBlue);
499
500 test_color(hdcmem, DIBINDEX(0), c0, 0, 1);
501 test_color(hdcmem, DIBINDEX(1), c1, 0, 1);
502 test_color(hdcmem, DIBINDEX(2), c0, 1, 1);
503 test_color(hdcmem, PALETTEINDEX(0), c0, 1, 1);
504 test_color(hdcmem, PALETTEINDEX(1), c0, 1, 1);
505 test_color(hdcmem, PALETTEINDEX(2), c0, 1, 1);
506 test_color(hdcmem, PALETTERGB(pbmi->bmiColors[0].rgbRed, pbmi->bmiColors[0].rgbGreen,
507 pbmi->bmiColors[0].rgbBlue), c0, 1, 1);
508 test_color(hdcmem, PALETTERGB(pbmi->bmiColors[1].rgbRed, pbmi->bmiColors[1].rgbGreen,
509 pbmi->bmiColors[1].rgbBlue), c1, 1, 1);
510 test_color(hdcmem, PALETTERGB(0, 0, 0), c0, 1, 1);
511 test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0, 1, 1);
512 test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c1, 1, 1);
513
514 SelectObject(hdcmem, oldbm);
515 DeleteObject(hdib);
516
517 pbmi->bmiColors[0].rgbRed = 0xff;
518 pbmi->bmiColors[0].rgbGreen = 0xff;
519 pbmi->bmiColors[0].rgbBlue = 0xff;
520 pbmi->bmiColors[1].rgbRed = 0;
521 pbmi->bmiColors[1].rgbGreen = 0;
522 pbmi->bmiColors[1].rgbBlue = 0;
523
524 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
525 ok(hdib != NULL, "CreateDIBSection failed\n");
526
527 test_dib_info(hdib, bits, &pbmi->bmiHeader);
528
529 oldbm = SelectObject(hdcmem, hdib);
530
531 ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
532 ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
533 ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
534 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
535 rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
536 rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
537
538 SelectObject(hdcmem, oldbm);
539 test_dib_info(hdib, bits, &pbmi->bmiHeader);
540 DeleteObject(hdib);
541
542 pbmi->bmiHeader.biBitCount = 4;
543 for (i = 0; i < 16; i++) {
544 pbmi->bmiColors[i].rgbRed = i;
545 pbmi->bmiColors[i].rgbGreen = 16-i;
546 pbmi->bmiColors[i].rgbBlue = 0;
547 }
548 hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
549 ok(hdib != NULL, "CreateDIBSection failed\n");
550 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
551 ok(dibsec.dsBmih.biClrUsed == 16,
552 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 16);
553 test_dib_info(hdib, bits, &pbmi->bmiHeader);
554 DeleteObject(hdib);
555
556 pbmi->bmiHeader.biBitCount = 8;
557
558 for (i = 0; i < 128; i++) {
559 pbmi->bmiColors[i].rgbRed = 255 - i * 2;
560 pbmi->bmiColors[i].rgbGreen = i * 2;
561 pbmi->bmiColors[i].rgbBlue = 0;
562 pbmi->bmiColors[255 - i].rgbRed = 0;
563 pbmi->bmiColors[255 - i].rgbGreen = i * 2;
564 pbmi->bmiColors[255 - i].rgbBlue = 255 - i * 2;
565 }
566 hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
567 ok(hdib != NULL, "CreateDIBSection failed\n");
568 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
569 ok(dibsec.dsBmih.biClrUsed == 256,
570 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
571
572 oldbm = SelectObject(hdcmem, hdib);
573
574 for (i = 0; i < 256; i++) {
575 test_color(hdcmem, DIBINDEX(i),
576 RGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue), 0, 0);
577 test_color(hdcmem, PALETTERGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue),
578 RGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue), 0, 0);
579 }
580
581 SelectObject(hdcmem, oldbm);
582 test_dib_info(hdib, bits, &pbmi->bmiHeader);
583 DeleteObject(hdib);
584
585 pbmi->bmiHeader.biBitCount = 1;
586
587 /* Now create a palette and a palette indexed dib section */
588 memset(plogpal, 0, sizeof(logpalbuf));
589 plogpal->palVersion = 0x300;
590 plogpal->palNumEntries = 2;
591 plogpal->palPalEntry[0].peRed = 0xff;
592 plogpal->palPalEntry[0].peBlue = 0xff;
593 plogpal->palPalEntry[1].peGreen = 0xff;
594
595 index = (WORD*)pbmi->bmiColors;
596 *index++ = 0;
597 *index = 1;
598 hpal = CreatePalette(plogpal);
599 ok(hpal != NULL, "CreatePalette failed\n");
600 oldpal = SelectPalette(hdc, hpal, TRUE);
601 hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
602 ok(hdib != NULL, "CreateDIBSection failed\n");
603 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
604 ok(dibsec.dsBmih.biClrUsed == 2,
605 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
606
607 /* The colour table has already been grabbed from the dc, so we select back the
608 old palette */
609
610 SelectPalette(hdc, oldpal, TRUE);
611 oldbm = SelectObject(hdcmem, hdib);
612 oldpal = SelectPalette(hdcmem, hpal, TRUE);
613
614 ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
615 ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
616 ok(rgb[0].rgbRed == 0xff && rgb[0].rgbBlue == 0xff && rgb[0].rgbGreen == 0 &&
617 rgb[1].rgbRed == 0 && rgb[1].rgbBlue == 0 && rgb[1].rgbGreen == 0xff,
618 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
619 rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
620 rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
621
622 c0 = RGB(plogpal->palPalEntry[0].peRed, plogpal->palPalEntry[0].peGreen, plogpal->palPalEntry[0].peBlue);
623 c1 = RGB(plogpal->palPalEntry[1].peRed, plogpal->palPalEntry[1].peGreen, plogpal->palPalEntry[1].peBlue);
624
625 test_color(hdcmem, DIBINDEX(0), c0, 0, 1);
626 test_color(hdcmem, DIBINDEX(1), c1, 0, 1);
627 test_color(hdcmem, DIBINDEX(2), c0, 1, 1);
628 test_color(hdcmem, PALETTEINDEX(0), c0, 0, 1);
629 test_color(hdcmem, PALETTEINDEX(1), c1, 0, 1);
630 test_color(hdcmem, PALETTEINDEX(2), c0, 1, 1);
631 test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[0].peRed, plogpal->palPalEntry[0].peGreen,
632 plogpal->palPalEntry[0].peBlue), c0, 1, 1);
633 test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[1].peRed, plogpal->palPalEntry[1].peGreen,
634 plogpal->palPalEntry[1].peBlue), c1, 1, 1);
635 test_color(hdcmem, PALETTERGB(0, 0, 0), c1, 1, 1);
636 test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0, 1, 1);
637 test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c0, 1, 1);
638 test_color(hdcmem, PALETTERGB(0, 1, 0), c1, 1, 1);
639 test_color(hdcmem, PALETTERGB(0x3f, 0, 0x3f), c1, 1, 1);
640 test_color(hdcmem, PALETTERGB(0x40, 0, 0x40), c0, 1, 1);
641
642 /* Bottom and 2nd row from top green, everything else magenta */
643 bits[0] = bits[1] = 0xff;
644 bits[13 * 4] = bits[13*4 + 1] = 0xff;
645
646 test_dib_info(hdib, bits, &pbmi->bmiHeader);
647
648 pbmi->bmiHeader.biBitCount = 32;
649
650 hdib2 = CreateDIBSection(NULL, pbmi, DIB_RGB_COLORS, (void **)&bits32, NULL, 0);
651 ok(hdib2 != NULL, "CreateDIBSection failed\n");
652 hdcmem2 = CreateCompatibleDC(hdc);
653 oldbm2 = SelectObject(hdcmem2, hdib2);
654
655 BitBlt(hdcmem2, 0, 0, 16,16, hdcmem, 0, 0, SRCCOPY);
656
657 ok(bits32[0] == 0xff00, "lower left pixel is %08x\n", bits32[0]);
658 ok(bits32[17] == 0xff00ff, "bottom but one, left pixel is %08x\n", bits32[17]);
659
660 SelectObject(hdcmem2, oldbm2);
661 test_dib_info(hdib2, bits32, &pbmi->bmiHeader);
662 DeleteObject(hdib2);
663
664 SelectObject(hdcmem, oldbm);
665 SelectObject(hdcmem, oldpal);
666 DeleteObject(hdib);
667 DeleteObject(hpal);
668
669
670 pbmi->bmiHeader.biBitCount = 8;
671
672 memset(plogpal, 0, sizeof(logpalbuf));
673 plogpal->palVersion = 0x300;
674 plogpal->palNumEntries = 256;
675
676 for (i = 0; i < 128; i++) {
677 plogpal->palPalEntry[i].peRed = 255 - i * 2;
678 plogpal->palPalEntry[i].peBlue = i * 2;
679 plogpal->palPalEntry[i].peGreen = 0;
680 plogpal->palPalEntry[255 - i].peRed = 0;
681 plogpal->palPalEntry[255 - i].peGreen = i * 2;
682 plogpal->palPalEntry[255 - i].peBlue = 255 - i * 2;
683 }
684
685 index = (WORD*)pbmi->bmiColors;
686 for (i = 0; i < 256; i++) {
687 *index++ = i;
688 }
689
690 hpal = CreatePalette(plogpal);
691 ok(hpal != NULL, "CreatePalette failed\n");
692 oldpal = SelectPalette(hdc, hpal, TRUE);
693 hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
694 ok(hdib != NULL, "CreateDIBSection failed\n");
695 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
696 ok(dibsec.dsBmih.biClrUsed == 256,
697 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
698
699 test_dib_info(hdib, bits, &pbmi->bmiHeader);
700
701 SelectPalette(hdc, oldpal, TRUE);
702 oldbm = SelectObject(hdcmem, hdib);
703 oldpal = SelectPalette(hdcmem, hpal, TRUE);
704
705 ret = GetDIBColorTable(hdcmem, 0, 256, rgb);
706 ok(ret == 256, "GetDIBColorTable returned %d\n", ret);
707 for (i = 0; i < 256; i++) {
708 ok(rgb[i].rgbRed == plogpal->palPalEntry[i].peRed &&
709 rgb[i].rgbBlue == plogpal->palPalEntry[i].peBlue &&
710 rgb[i].rgbGreen == plogpal->palPalEntry[i].peGreen,
711 "GetDIBColorTable returns table %d: r%02x g%02x b%02x res%02x\n",
712 i, rgb[i].rgbRed, rgb[i].rgbGreen, rgb[i].rgbBlue, rgb[i].rgbReserved);
713 }
714
715 for (i = 0; i < 256; i++) {
716 test_color(hdcmem, DIBINDEX(i),
717 RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
718 test_color(hdcmem, PALETTEINDEX(i),
719 RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
720 test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue),
721 RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
722 }
723
724 SelectPalette(hdcmem, oldpal, TRUE);
725 SelectObject(hdcmem, oldbm);
726 DeleteObject(hdib);
727 DeleteObject(hpal);
728
729
730 DeleteDC(hdcmem);
731 ReleaseDC(0, hdc);
732 }
733
734 static void test_mono_dibsection(void)
735 {
736 HDC hdc, memdc;
737 HBITMAP old_bm, mono_ds;
738 char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
739 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
740 BYTE bits[10 * 4];
741 BYTE *ds_bits;
742 int num;
743
744 hdc = GetDC(0);
745
746 memdc = CreateCompatibleDC(hdc);
747
748 memset(pbmi, 0, sizeof(bmibuf));
749 pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
750 pbmi->bmiHeader.biHeight = 10;
751 pbmi->bmiHeader.biWidth = 10;
752 pbmi->bmiHeader.biBitCount = 1;
753 pbmi->bmiHeader.biPlanes = 1;
754 pbmi->bmiHeader.biCompression = BI_RGB;
755 pbmi->bmiColors[0].rgbRed = 0xff;
756 pbmi->bmiColors[0].rgbGreen = 0xff;
757 pbmi->bmiColors[0].rgbBlue = 0xff;
758 pbmi->bmiColors[1].rgbRed = 0x0;
759 pbmi->bmiColors[1].rgbGreen = 0x0;
760 pbmi->bmiColors[1].rgbBlue = 0x0;
761
762 /*
763 * First dib section is 'inverted' ie color[0] is white, color[1] is black
764 */
765
766 mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
767 ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
768 old_bm = SelectObject(memdc, mono_ds);
769
770 /* black border, white interior */
771 Rectangle(memdc, 0, 0, 10, 10);
772 ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
773 ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
774
775 /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
776
777 memset(bits, 0, sizeof(bits));
778 bits[0] = 0xaa;
779
780 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
781 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
782
783 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
784
785 pbmi->bmiColors[0].rgbRed = 0x0;
786 pbmi->bmiColors[0].rgbGreen = 0x0;
787 pbmi->bmiColors[0].rgbBlue = 0x0;
788 pbmi->bmiColors[1].rgbRed = 0xff;
789 pbmi->bmiColors[1].rgbGreen = 0xff;
790 pbmi->bmiColors[1].rgbBlue = 0xff;
791
792 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
793 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
794
795 SelectObject(memdc, old_bm);
796 DeleteObject(mono_ds);
797
798 /*
799 * Next dib section is 'normal' ie color[0] is black, color[1] is white
800 */
801
802 pbmi->bmiColors[0].rgbRed = 0x0;
803 pbmi->bmiColors[0].rgbGreen = 0x0;
804 pbmi->bmiColors[0].rgbBlue = 0x0;
805 pbmi->bmiColors[1].rgbRed = 0xff;
806 pbmi->bmiColors[1].rgbGreen = 0xff;
807 pbmi->bmiColors[1].rgbBlue = 0xff;
808
809 mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
810 ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
811 old_bm = SelectObject(memdc, mono_ds);
812
813 /* black border, white interior */
814 Rectangle(memdc, 0, 0, 10, 10);
815 ok(ds_bits[0] == 0x00, "out_bits %02x\n", ds_bits[0]);
816 ok(ds_bits[4] == 0x7f, "out_bits %02x\n", ds_bits[4]);
817
818 /* SetDIBitsToDevice with a normal bmi -> normal dib section */
819
820 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
821 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
822
823 /* SetDIBitsToDevice with a inverted bmi -> normal dib section */
824
825 pbmi->bmiColors[0].rgbRed = 0xff;
826 pbmi->bmiColors[0].rgbGreen = 0xff;
827 pbmi->bmiColors[0].rgbBlue = 0xff;
828 pbmi->bmiColors[1].rgbRed = 0x0;
829 pbmi->bmiColors[1].rgbGreen = 0x0;
830 pbmi->bmiColors[1].rgbBlue = 0x0;
831
832 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
833 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
834
835 /*
836 * Take that 'normal' dibsection and change its colour table to an 'inverted' one
837 */
838
839 pbmi->bmiColors[0].rgbRed = 0xff;
840 pbmi->bmiColors[0].rgbGreen = 0xff;
841 pbmi->bmiColors[0].rgbBlue = 0xff;
842 pbmi->bmiColors[1].rgbRed = 0x0;
843 pbmi->bmiColors[1].rgbGreen = 0x0;
844 pbmi->bmiColors[1].rgbBlue = 0x0;
845 num = SetDIBColorTable(memdc, 0, 2, pbmi->bmiColors);
846 ok(num == 2, "num = %d\n", num);
847
848 /* black border, white interior */
849 Rectangle(memdc, 0, 0, 10, 10);
850 todo_wine {
851 ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
852 ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
853 }
854 /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
855
856 memset(bits, 0, sizeof(bits));
857 bits[0] = 0xaa;
858
859 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
860 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
861
862 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
863
864 pbmi->bmiColors[0].rgbRed = 0x0;
865 pbmi->bmiColors[0].rgbGreen = 0x0;
866 pbmi->bmiColors[0].rgbBlue = 0x0;
867 pbmi->bmiColors[1].rgbRed = 0xff;
868 pbmi->bmiColors[1].rgbGreen = 0xff;
869 pbmi->bmiColors[1].rgbBlue = 0xff;
870
871 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
872 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
873
874 SelectObject(memdc, old_bm);
875 DeleteObject(mono_ds);
876
877 /*
878 * Now a dib section with a strange colour map just for fun. This behaves just like an inverted one.
879 */
880
881 pbmi->bmiColors[0].rgbRed = 0xff;
882 pbmi->bmiColors[0].rgbGreen = 0x0;
883 pbmi->bmiColors[0].rgbBlue = 0x0;
884 pbmi->bmiColors[1].rgbRed = 0xfe;
885 pbmi->bmiColors[1].rgbGreen = 0x0;
886 pbmi->bmiColors[1].rgbBlue = 0x0;
887
888 mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
889 ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
890 old_bm = SelectObject(memdc, mono_ds);
891
892 /* black border, white interior */
893 Rectangle(memdc, 0, 0, 10, 10);
894 ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
895 ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
896
897 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
898
899 pbmi->bmiColors[0].rgbRed = 0x0;
900 pbmi->bmiColors[0].rgbGreen = 0x0;
901 pbmi->bmiColors[0].rgbBlue = 0x0;
902 pbmi->bmiColors[1].rgbRed = 0xff;
903 pbmi->bmiColors[1].rgbGreen = 0xff;
904 pbmi->bmiColors[1].rgbBlue = 0xff;
905
906 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
907 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
908
909 /* SetDIBitsToDevice with a inverted bmi -> inverted dib section */
910
911 pbmi->bmiColors[0].rgbRed = 0xff;
912 pbmi->bmiColors[0].rgbGreen = 0xff;
913 pbmi->bmiColors[0].rgbBlue = 0xff;
914 pbmi->bmiColors[1].rgbRed = 0x0;
915 pbmi->bmiColors[1].rgbGreen = 0x0;
916 pbmi->bmiColors[1].rgbBlue = 0x0;
917
918 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
919 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
920
921 SelectObject(memdc, old_bm);
922 DeleteObject(mono_ds);
923
924 DeleteDC(memdc);
925 ReleaseDC(0, hdc);
926 }
927
928 static void test_bitmap(void)
929 {
930 char buf[256], buf_cmp[256];
931 HBITMAP hbmp, hbmp_old;
932 HDC hdc;
933 BITMAP bm;
934 INT ret;
935
936 hdc = CreateCompatibleDC(0);
937 assert(hdc != 0);
938
939 hbmp = CreateBitmap(15, 15, 1, 1, NULL);
940 assert(hbmp != NULL);
941
942 ret = GetObject(hbmp, sizeof(bm), &bm);
943 ok(ret == sizeof(bm), "wrong size %d\n", ret);
944
945 ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
946 ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
947 ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
948 ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
949 ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
950 ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
951 ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
952
953 assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
954 assert(sizeof(buf) == sizeof(buf_cmp));
955
956 ret = GetBitmapBits(hbmp, 0, NULL);
957 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
958
959 memset(buf_cmp, 0xAA, sizeof(buf_cmp));
960 memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);
961
962 memset(buf, 0xAA, sizeof(buf));
963 ret = GetBitmapBits(hbmp, sizeof(buf), buf);
964 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
965 ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
966
967 hbmp_old = SelectObject(hdc, hbmp);
968
969 ret = GetObject(hbmp, sizeof(bm), &bm);
970 ok(ret == sizeof(bm), "wrong size %d\n", ret);
971
972 ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
973 ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
974 ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
975 ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
976 ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
977 ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
978 ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
979
980 memset(buf, 0xAA, sizeof(buf));
981 ret = GetBitmapBits(hbmp, sizeof(buf), buf);
982 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
983 ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
984
985 hbmp_old = SelectObject(hdc, hbmp_old);
986 ok(hbmp_old == hbmp, "wrong old bitmap %p\n", hbmp_old);
987
988 /* test various buffer sizes for GetObject */
989 ret = GetObject(hbmp, sizeof(bm) * 2, &bm);
990 ok(ret == sizeof(bm), "wrong size %d\n", ret);
991
992 ret = GetObject(hbmp, sizeof(bm) / 2, &bm);
993 ok(ret == 0, "%d != 0\n", ret);
994
995 ret = GetObject(hbmp, 0, &bm);
996 ok(ret == 0, "%d != 0\n", ret);
997
998 ret = GetObject(hbmp, 1, &bm);
999 ok(ret == 0, "%d != 0\n", ret);
1000
1001 DeleteObject(hbmp);
1002 DeleteDC(hdc);
1003 }
1004
1005 static void test_bmBits(void)
1006 {
1007 BYTE bits[4];
1008 HBITMAP hbmp;
1009 BITMAP bmp;
1010
1011 memset(bits, 0, sizeof(bits));
1012 hbmp = CreateBitmap(2, 2, 1, 4, bits);
1013 ok(hbmp != NULL, "CreateBitmap failed\n");
1014
1015 memset(&bmp, 0xFF, sizeof(bmp));
1016 ok(GetObject(hbmp, sizeof(bmp), &bmp) == sizeof(bmp),
1017 "GetObject failed or returned a wrong structure size\n");
1018 ok(!bmp.bmBits, "bmBits must be NULL for device-dependent bitmaps\n");
1019
1020 DeleteObject(hbmp);
1021 }
1022
1023 static void test_GetDIBits_selected_DIB(UINT bpp)
1024 {
1025 HBITMAP dib;
1026 BITMAPINFO * info;
1027 BITMAPINFO * info2;
1028 void * bits;
1029 void * bits2;
1030 UINT dib_size;
1031 HDC dib_dc, dc;
1032 HBITMAP old_bmp;
1033 BOOL equalContents;
1034 UINT i;
1035 int res;
1036
1037 /* Create a DIB section with a color table */
1038
1039 info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + (1 << bpp) * sizeof(RGBQUAD));
1040 info2 = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + (1 << bpp) * sizeof(RGBQUAD));
1041 assert(info);
1042 assert(info2);
1043
1044 info->bmiHeader.biSize = sizeof(info->bmiHeader);
1045
1046 /* Choose width and height such that the row length (in bytes)
1047 is a multiple of 4 (makes things easier) */
1048 info->bmiHeader.biWidth = 32;
1049 info->bmiHeader.biHeight = 32;
1050 info->bmiHeader.biPlanes = 1;
1051 info->bmiHeader.biBitCount = bpp;
1052 info->bmiHeader.biCompression = BI_RGB;
1053
1054 for (i=0; i < (1u << bpp); i++)
1055 {
1056 BYTE c = i * (1 << (8 - bpp));
1057 info->bmiColors[i].rgbRed = c;
1058 info->bmiColors[i].rgbGreen = c;
1059 info->bmiColors[i].rgbBlue = c;
1060 info->bmiColors[i].rgbReserved = 0;
1061 }
1062
1063 dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
1064 assert(dib);
1065 dib_size = bpp * (info->bmiHeader.biWidth * info->bmiHeader.biHeight) / 8;
1066
1067 /* Set the bits of the DIB section */
1068 for (i=0; i < dib_size; i++)
1069 {
1070 ((BYTE *)bits)[i] = i % 256;
1071 }
1072
1073 /* Select the DIB into a DC */
1074 dib_dc = CreateCompatibleDC(NULL);
1075 old_bmp = (HBITMAP) SelectObject(dib_dc, dib);
1076 dc = CreateCompatibleDC(NULL);
1077 bits2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dib_size);
1078 assert(bits2);
1079
1080 /* Copy the DIB attributes but not the color table */
1081 memcpy(info2, info, sizeof(BITMAPINFOHEADER));
1082
1083 res = GetDIBits(dc, dib, 0, info->bmiHeader.biHeight, bits2, info2, DIB_RGB_COLORS);
1084 ok(res, "GetDIBits failed\n");
1085
1086 /* Compare the color table and the bits */
1087 equalContents = TRUE;
1088 for (i=0; i < (1u << bpp); i++)
1089 {
1090 if ((info->bmiColors[i].rgbRed != info2->bmiColors[i].rgbRed)
1091 || (info->bmiColors[i].rgbGreen != info2->bmiColors[i].rgbGreen)
1092 || (info->bmiColors[i].rgbBlue != info2->bmiColors[i].rgbBlue)
1093 || (info->bmiColors[i].rgbReserved != info2->bmiColors[i].rgbReserved))
1094 {
1095 equalContents = FALSE;
1096 break;
1097 }
1098 }
1099 ok(equalContents, "GetDIBits with DIB selected in DC: Invalid DIB color table\n");
1100
1101 equalContents = TRUE;
1102 for (i=0; i < dib_size / sizeof(DWORD); i++)
1103 {
1104 if (((DWORD *)bits)[i] != ((DWORD *)bits2)[i])
1105 {
1106 equalContents = FALSE;
1107 break;
1108 }
1109 }
1110 if (bpp != 1)
1111 ok(equalContents, "GetDIBits with %d bpp DIB selected in DC: Invalid DIB bits\n",bpp);
1112 else
1113 todo_wine ok(equalContents, "GetDIBits with %d bpp DIB selected in DC: Invalid DIB bits\n",bpp);
1114
1115 HeapFree(GetProcessHeap(), 0, bits2);
1116 DeleteDC(dc);
1117
1118 SelectObject(dib_dc, old_bmp);
1119 DeleteDC(dib_dc);
1120 DeleteObject(dib);
1121
1122 HeapFree(GetProcessHeap(), 0, info2);
1123 HeapFree(GetProcessHeap(), 0, info);
1124 }
1125
1126 static void test_GetDIBits_selected_DDB(BOOL monochrome)
1127 {
1128 HBITMAP ddb;
1129 BITMAPINFO * info;
1130 BITMAPINFO * info2;
1131 void * bits;
1132 void * bits2;
1133 HDC ddb_dc, dc;
1134 HBITMAP old_bmp;
1135 BOOL equalContents;
1136 UINT width, height;
1137 UINT bpp;
1138 UINT i, j;
1139 int res;
1140
1141 width = height = 16;
1142
1143 /* Create a DDB (device-dependent bitmap) */
1144 if (monochrome)
1145 {
1146 bpp = 1;
1147 ddb = CreateBitmap(width, height, 1, 1, NULL);
1148 }
1149 else
1150 {
1151 HDC screen_dc = GetDC(NULL);
1152 bpp = GetDeviceCaps(screen_dc, BITSPIXEL) * GetDeviceCaps(screen_dc, PLANES);
1153 ddb = CreateCompatibleBitmap(screen_dc, width, height);
1154 ReleaseDC(NULL, screen_dc);
1155 }
1156
1157 /* Set the pixels */
1158 ddb_dc = CreateCompatibleDC(NULL);
1159 old_bmp = (HBITMAP) SelectObject(ddb_dc, ddb);
1160 for (i = 0; i < width; i++)
1161 {
1162 for (j=0; j < height; j++)
1163 {
1164 BYTE c = (i * width + j) % 256;
1165 SetPixelV(ddb_dc, i, j, RGB(c, c, c));
1166 }
1167 }
1168 SelectObject(ddb_dc, old_bmp);
1169
1170 info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1171 info2 = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1172 assert(info);
1173 assert(info2);
1174
1175 info->bmiHeader.biSize = sizeof(info->bmiHeader);
1176 info->bmiHeader.biWidth = width;
1177 info->bmiHeader.biHeight = height;
1178 info->bmiHeader.biPlanes = 1;
1179 info->bmiHeader.biBitCount = bpp;
1180 info->bmiHeader.biCompression = BI_RGB;
1181
1182 dc = CreateCompatibleDC(NULL);
1183
1184 /* Fill in biSizeImage */
1185 GetDIBits(dc, ddb, 0, height, NULL, info, DIB_RGB_COLORS);
1186 ok(info->bmiHeader.biSizeImage != 0, "GetDIBits failed to get the DIB attributes\n");
1187
1188 bits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage);
1189 bits2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage);
1190 assert(bits);
1191 assert(bits2);
1192
1193 /* Get the bits */
1194 res = GetDIBits(dc, ddb, 0, height, bits, info, DIB_RGB_COLORS);
1195 ok(res, "GetDIBits failed\n");
1196
1197 /* Copy the DIB attributes but not the color table */
1198 memcpy(info2, info, sizeof(BITMAPINFOHEADER));
1199
1200 /* Select the DDB into another DC */
1201 old_bmp = (HBITMAP) SelectObject(ddb_dc, ddb);
1202
1203 /* Get the bits */
1204 res = GetDIBits(dc, ddb, 0, height, bits2, info2, DIB_RGB_COLORS);
1205 ok(res, "GetDIBits failed\n");
1206
1207 /* Compare the color table and the bits */
1208 if (bpp <= 8)
1209 {
1210 equalContents = TRUE;
1211 for (i=0; i < (1u << bpp); i++)
1212 {
1213 if ((info->bmiColors[i].rgbRed != info2->bmiColors[i].rgbRed)
1214 || (info->bmiColors[i].rgbGreen != info2->bmiColors[i].rgbGreen)
1215 || (info->bmiColors[i].rgbBlue != info2->bmiColors[i].rgbBlue)
1216 || (info->bmiColors[i].rgbReserved != info2->bmiColors[i].rgbReserved))
1217 {
1218 equalContents = FALSE;
1219 break;
1220 }
1221 }
1222 ok(equalContents, "GetDIBits with DDB selected in DC: Got a different color table\n");
1223 }
1224
1225 equalContents = TRUE;
1226 for (i=0; i < info->bmiHeader.biSizeImage / sizeof(DWORD); i++)
1227 {
1228 if (((DWORD *)bits)[i] != ((DWORD *)bits2)[i])
1229 {
1230 equalContents = FALSE;
1231 }
1232 }
1233 ok(equalContents, "GetDIBits with DDB selected in DC: Got different DIB bits\n");
1234
1235 HeapFree(GetProcessHeap(), 0, bits2);
1236 HeapFree(GetProcessHeap(), 0, bits);
1237 DeleteDC(dc);
1238
1239 SelectObject(ddb_dc, old_bmp);
1240 DeleteDC(ddb_dc);
1241 DeleteObject(ddb);
1242
1243 HeapFree(GetProcessHeap(), 0, info2);
1244 HeapFree(GetProcessHeap(), 0, info);
1245 }
1246
1247 static void test_GetDIBits(void)
1248 {
1249 /* 2-bytes aligned 1-bit bitmap data: 16x16 */
1250 static const BYTE bmp_bits_1[16 * 2] =
1251 {
1252 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1253 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1254 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1255 0xff,0xff, 0,0, 0xff,0xff, 0,0
1256 };
1257 /* 4-bytes aligned 1-bit DIB data: 16x16 */
1258 static const BYTE dib_bits_1[16 * 4] =
1259 {
1260 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1261 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1262 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1263 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0
1264 };
1265 /* 2-bytes aligned 24-bit bitmap data: 16x16 */
1266 static const BYTE bmp_bits_24[16 * 16*3] =
1267 {
1268 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1269 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1270 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1271 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1272 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1273 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1274 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1275 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1276 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1277 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1278 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1279 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1280 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1281 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1282 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1283 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1284 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1285 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1286 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1287 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1288 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1289 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1290 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1291 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1292 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1293 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1294 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1295 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1296 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1297 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1298 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1299 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1300 };
1301 /* 4-bytes aligned 24-bit DIB data: 16x16 */
1302 static const BYTE dib_bits_24[16 * 16*3] =
1303 {
1304 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1305 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1306 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1307 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1308 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1309 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1310 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1311 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1313 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1314 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1315 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1316 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1317 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1318 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1319 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1320 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1321 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1322 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1323 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1324 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1325 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1326 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1327 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1328 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1329 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1330 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1331 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1332 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1333 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1334 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1335 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
1336 };
1337 HBITMAP hbmp;
1338 BITMAP bm;
1339 HDC hdc;
1340 int i, bytes, lines;
1341 BYTE buf[1024];
1342 char bi_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
1343 BITMAPINFO *bi = (BITMAPINFO *)bi_buf;
1344
1345 hdc = GetDC(0);
1346
1347 /* 1-bit source bitmap data */
1348 hbmp = CreateBitmap(16, 16, 1, 1, bmp_bits_1);
1349 ok(hbmp != 0, "CreateBitmap failed\n");
1350
1351 memset(&bm, 0xAA, sizeof(bm));
1352 bytes = GetObject(hbmp, sizeof(bm), &bm);
1353 ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1354 ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1355 ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
1356 ok(bm.bmHeight == 16, "wrong bmHeight %d\n", bm.bmHeight);
1357 ok(bm.bmWidthBytes == 2, "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1358 ok(bm.bmPlanes == 1, "wrong bmPlanes %u\n", bm.bmPlanes);
1359 ok(bm.bmBitsPixel == 1, "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1360 ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1361
1362 bytes = GetBitmapBits(hbmp, 0, NULL);
1363 ok(bytes == sizeof(bmp_bits_1), "expected 16*2 got %d bytes\n", bytes);
1364 bytes = GetBitmapBits(hbmp, sizeof(buf), buf);
1365 ok(bytes == sizeof(bmp_bits_1), "expected 16*2 got %d bytes\n", bytes);
1366 ok(!memcmp(buf, bmp_bits_1, sizeof(bmp_bits_1)), "bitmap bits don't match\n");
1367
1368 /* retrieve 1-bit DIB data */
1369 memset(bi, 0, sizeof(*bi));
1370 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1371 bi->bmiHeader.biWidth = bm.bmWidth;
1372 bi->bmiHeader.biHeight = bm.bmHeight;
1373 bi->bmiHeader.biPlanes = 1;
1374 bi->bmiHeader.biBitCount = 1;
1375 bi->bmiHeader.biCompression = BI_RGB;
1376 bi->bmiHeader.biSizeImage = 0;
1377 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1378 SetLastError(0xdeadbeef);
1379 lines = GetDIBits(0, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1380 ok(lines == 0, "GetDIBits copied %d lines with hdc = 0\n", lines);
1381 ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError());
1382 ok(bi->bmiHeader.biSizeImage == 0, "expected 0, got %u\n", bi->bmiHeader.biSizeImage);
1383
1384 memset(buf, 0xAA, sizeof(buf));
1385 SetLastError(0xdeadbeef);
1386 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1387 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1388 lines, bm.bmHeight, GetLastError());
1389 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_1), "expected 16*4, got %u\n", bi->bmiHeader.biSizeImage);
1390
1391 /* the color table consists of black and white */
1392 ok(bi->bmiColors[0].rgbRed == 0 && bi->bmiColors[0].rgbGreen == 0 &&
1393 bi->bmiColors[0].rgbBlue == 0 && bi->bmiColors[0].rgbReserved == 0,
1394 "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1395 bi->bmiColors[0].rgbRed, bi->bmiColors[0].rgbGreen,
1396 bi->bmiColors[0].rgbBlue, bi->bmiColors[0].rgbReserved);
1397 todo_wine
1398 ok(bi->bmiColors[1].rgbRed == 0xff && bi->bmiColors[1].rgbGreen == 0xff &&
1399 bi->bmiColors[1].rgbBlue == 0xff && bi->bmiColors[1].rgbReserved == 0,
1400 "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1401 bi->bmiColors[1].rgbRed, bi->bmiColors[1].rgbGreen,
1402 bi->bmiColors[1].rgbBlue, bi->bmiColors[1].rgbReserved);
1403 for (i = 2; i < 256; i++)
1404 {
1405 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1406 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1407 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1408 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1409 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1410 }
1411
1412 /* returned bits are DWORD aligned and upside down */
1413 todo_wine
1414 ok(!memcmp(buf, dib_bits_1, sizeof(dib_bits_1)), "DIB bits don't match\n");
1415
1416 /* retrieve 24-bit DIB data */
1417 memset(bi, 0, sizeof(*bi));
1418 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1419 bi->bmiHeader.biWidth = bm.bmWidth;
1420 bi->bmiHeader.biHeight = bm.bmHeight;
1421 bi->bmiHeader.biPlanes = 1;
1422 bi->bmiHeader.biBitCount = 24;
1423 bi->bmiHeader.biCompression = BI_RGB;
1424 bi->bmiHeader.biSizeImage = 0;
1425 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1426 memset(buf, 0xAA, sizeof(buf));
1427 SetLastError(0xdeadbeef);
1428 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1429 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1430 lines, bm.bmHeight, GetLastError());
1431 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_24), "expected 16*16*3, got %u\n", bi->bmiHeader.biSizeImage);
1432
1433 /* the color table doesn't exist for 24-bit images */
1434 for (i = 0; i < 256; i++)
1435 {
1436 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1437 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1438 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1439 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1440 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1441 }
1442
1443 /* returned bits are DWORD aligned and upside down */
1444 todo_wine
1445 ok(!memcmp(buf, dib_bits_24, sizeof(dib_bits_24)), "DIB bits don't match\n");
1446 DeleteObject(hbmp);
1447
1448 /* 24-bit source bitmap data */
1449 hbmp = CreateCompatibleBitmap(hdc, 16, 16);
1450 ok(hbmp != 0, "CreateBitmap failed\n");
1451 SetLastError(0xdeadbeef);
1452 bi->bmiHeader.biHeight = -bm.bmHeight; /* indicate bottom-up data */
1453 lines = SetDIBits(hdc, hbmp, 0, bm.bmHeight, bmp_bits_24, bi, DIB_RGB_COLORS);
1454 ok(lines == bm.bmHeight, "SetDIBits copied %d lines of %d, error %u\n",
1455 lines, bm.bmHeight, GetLastError());
1456
1457 memset(&bm, 0xAA, sizeof(bm));
1458 bytes = GetObject(hbmp, sizeof(bm), &bm);
1459 ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1460 ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1461 ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
1462 ok(bm.bmHeight == 16, "wrong bmHeight %d\n", bm.bmHeight);
1463 ok(bm.bmWidthBytes == BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel), "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1464 ok(bm.bmPlanes == GetDeviceCaps(hdc, PLANES), "wrong bmPlanes %u\n", bm.bmPlanes);
1465 ok(bm.bmBitsPixel == GetDeviceCaps(hdc, BITSPIXEL), "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1466 ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1467
1468 bytes = GetBitmapBits(hbmp, 0, NULL);
1469 ok(bytes == bm.bmWidthBytes * bm.bmHeight, "expected %d got %d bytes\n",
1470 bm.bmWidthBytes * bm.bmHeight, bytes);
1471 bytes = GetBitmapBits(hbmp, sizeof(buf), buf);
1472 ok(bytes == bm.bmWidthBytes * bm.bmHeight, "expected %d got %d bytes\n",
1473 bm.bmWidthBytes * bm.bmHeight, bytes);
1474
1475 /* retrieve 1-bit DIB data */
1476 memset(bi, 0, sizeof(*bi));
1477 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1478 bi->bmiHeader.biWidth = bm.bmWidth;
1479 bi->bmiHeader.biHeight = bm.bmHeight;
1480 bi->bmiHeader.biPlanes = 1;
1481 bi->bmiHeader.biBitCount = 1;
1482 bi->bmiHeader.biCompression = BI_RGB;
1483 bi->bmiHeader.biSizeImage = 0;
1484 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1485 memset(buf, 0xAA, sizeof(buf));
1486 SetLastError(0xdeadbeef);
1487 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1488 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1489 lines, bm.bmHeight, GetLastError());
1490 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_1), "expected 16*4, got %u\n", bi->bmiHeader.biSizeImage);
1491
1492 /* the color table consists of black and white */
1493 ok(bi->bmiColors[0].rgbRed == 0 && bi->bmiColors[0].rgbGreen == 0 &&
1494 bi->bmiColors[0].rgbBlue == 0 && bi->bmiColors[0].rgbReserved == 0,
1495 "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1496 bi->bmiColors[0].rgbRed, bi->bmiColors[0].rgbGreen,
1497 bi->bmiColors[0].rgbBlue, bi->bmiColors[0].rgbReserved);
1498 ok(bi->bmiColors[1].rgbRed == 0xff && bi->bmiColors[1].rgbGreen == 0xff &&
1499 bi->bmiColors[1].rgbBlue == 0xff && bi->bmiColors[1].rgbReserved == 0,
1500 "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1501 bi->bmiColors[1].rgbRed, bi->bmiColors[1].rgbGreen,
1502 bi->bmiColors[1].rgbBlue, bi->bmiColors[1].rgbReserved);
1503 for (i = 2; i < 256; i++)
1504 {
1505 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1506 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1507 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1508 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1509 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1510 }
1511
1512 /* returned bits are DWORD aligned and upside down */
1513 todo_wine
1514 ok(!memcmp(buf, dib_bits_1, sizeof(dib_bits_1)), "DIB bits don't match\n");
1515
1516 /* retrieve 24-bit DIB data */
1517 memset(bi, 0, sizeof(*bi));
1518 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1519 bi->bmiHeader.biWidth = bm.bmWidth;
1520 bi->bmiHeader.biHeight = bm.bmHeight;
1521 bi->bmiHeader.biPlanes = 1;
1522 bi->bmiHeader.biBitCount = 24;
1523 bi->bmiHeader.biCompression = BI_RGB;
1524 bi->bmiHeader.biSizeImage = 0;
1525 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1526 memset(buf, 0xAA, sizeof(buf));
1527 SetLastError(0xdeadbeef);
1528 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1529 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1530 lines, bm.bmHeight, GetLastError());
1531 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_24), "expected 16*16*3, got %u\n", bi->bmiHeader.biSizeImage);
1532
1533 /* the color table doesn't exist for 24-bit images */
1534 for (i = 0; i < 256; i++)
1535 {
1536 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1537 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1538 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1539 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1540 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1541 }
1542
1543 /* returned bits are DWORD aligned and upside down */
1544 ok(!memcmp(buf, dib_bits_24, sizeof(dib_bits_24)), "DIB bits don't match\n");
1545 DeleteObject(hbmp);
1546
1547 ReleaseDC(0, hdc);
1548 }
1549
1550 static void test_select_object(void)
1551 {
1552 HDC hdc;
1553 HBITMAP hbm, hbm_old;
1554 INT planes, bpp;
1555
1556 hdc = GetDC(0);
1557 ok(hdc != 0, "GetDC(0) failed\n");
1558 hbm = CreateCompatibleBitmap(hdc, 10, 10);
1559 ok(hbm != 0, "CreateCompatibleBitmap failed\n");
1560
1561 hbm_old = SelectObject(hdc, hbm);
1562 ok(hbm_old == 0, "SelectObject should fail\n");
1563
1564 DeleteObject(hbm);
1565 ReleaseDC(0, hdc);
1566
1567 hdc = CreateCompatibleDC(0);
1568 ok(hdc != 0, "GetDC(0) failed\n");
1569 hbm = CreateCompatibleBitmap(hdc, 10, 10);
1570 ok(hbm != 0, "CreateCompatibleBitmap failed\n");
1571
1572 hbm_old = SelectObject(hdc, hbm);
1573 ok(hbm_old != 0, "SelectObject failed\n");
1574 hbm_old = SelectObject(hdc, hbm_old);
1575 ok(hbm_old == hbm, "SelectObject failed\n");
1576
1577 DeleteObject(hbm);
1578
1579 /* test an 1-bpp bitmap */
1580 planes = GetDeviceCaps(hdc, PLANES);
1581 bpp = 1;
1582
1583 hbm = CreateBitmap(10, 10, planes, bpp, NULL);
1584 ok(hbm != 0, "CreateBitmap failed\n");
1585
1586 hbm_old = SelectObject(hdc, hbm);
1587 ok(hbm_old != 0, "SelectObject failed\n");
1588 hbm_old = SelectObject(hdc, hbm_old);
1589 ok(hbm_old == hbm, "SelectObject failed\n");
1590
1591 DeleteObject(hbm);
1592
1593 /* test a color bitmap that doesn't match the dc's bpp */
1594 planes = GetDeviceCaps(hdc, PLANES);
1595 bpp = GetDeviceCaps(hdc, BITSPIXEL) == 24 ? 8 : 24;
1596
1597 hbm = CreateBitmap(10, 10, planes, bpp, NULL);
1598 ok(hbm != 0, "CreateBitmap failed\n");
1599
1600 hbm_old = SelectObject(hdc, hbm);
1601 ok(hbm_old == 0, "SelectObject should fail\n");
1602
1603 DeleteObject(hbm);
1604
1605 DeleteDC(hdc);
1606 }
1607
1608 static void test_mono_1x1_bmp_dbg(HBITMAP hbmp, int line)
1609 {
1610 INT ret;
1611 BITMAP bm;
1612
1613 ret = GetObjectType(hbmp);
1614 ok_(__FILE__, line)(ret == OBJ_BITMAP, "the object %p is not bitmap\n", hbmp);
1615
1616 ret = GetObject(hbmp, 0, 0);
1617 ok_(__FILE__, line)(ret == sizeof(BITMAP) /* XP */ ||
1618 ret == sizeof(DIBSECTION) /* Win9x */, "object size %d\n", ret);
1619
1620 memset(&bm, 0xDA, sizeof(bm));
1621 SetLastError(0xdeadbeef);
1622 ret = GetObject(hbmp, sizeof(bm), &bm);
1623 if (!ret) /* XP, only for curObj2 */ return;
1624 ok_(__FILE__, line)(ret == sizeof(BITMAP) ||
1625 ret == sizeof(DIBSECTION) /* Win9x, only for curObj2 */,
1626 "GetObject returned %d, error %u\n", ret, GetLastError());
1627 ok_(__FILE__, line)(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1628 ok_(__FILE__, line)(bm.bmWidth == 1, "wrong bmWidth %d\n", bm.bmWidth);
1629 ok_(__FILE__, line)(bm.bmHeight == 1, "wrong bmHeight %d\n", bm.bmHeight);
1630 ok_(__FILE__, line)(bm.bmWidthBytes == 2, "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1631 ok_(__FILE__, line)(bm.bmPlanes == 1, "wrong bmPlanes %u\n", bm.bmPlanes);
1632 ok_(__FILE__, line)(bm.bmBitsPixel == 1, "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1633 ok_(__FILE__, line)(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1634 }
1635
1636 #define test_mono_1x1_bmp(a) test_mono_1x1_bmp_dbg((a), __LINE__)
1637
1638 static void test_CreateBitmap(void)
1639 {
1640 BITMAP bmp;
1641 HDC screenDC = GetDC(0);
1642 HDC hdc = CreateCompatibleDC(screenDC);
1643
1644 /* all of these are the stock monochrome bitmap */
1645 HBITMAP bm = CreateCompatibleBitmap(hdc, 0, 0);
1646 HBITMAP bm1 = CreateCompatibleBitmap(screenDC, 0, 0);
1647 HBITMAP bm4 = CreateBitmap(0, 1, 0, 0, 0);
1648 HBITMAP bm5 = CreateDiscardableBitmap(hdc, 0, 0);
1649 HBITMAP curObj1 = (HBITMAP)GetCurrentObject(hdc, OBJ_BITMAP);
1650 HBITMAP curObj2 = (HBITMAP)GetCurrentObject(screenDC, OBJ_BITMAP);
1651
1652 /* these 2 are not the stock monochrome bitmap */
1653 HBITMAP bm2 = CreateCompatibleBitmap(hdc, 1, 1);
1654 HBITMAP bm3 = CreateBitmap(1, 1, 1, 1, 0);
1655
1656 HBITMAP old1 = (HBITMAP)SelectObject(hdc, bm2);
1657 HBITMAP old2 = (HBITMAP)SelectObject(screenDC, bm3);
1658 SelectObject(hdc, old1);
1659 SelectObject(screenDC, old2);
1660
1661 ok(bm == bm1 && bm == bm4 && bm == bm5 && bm == curObj1 && bm == old1,
1662 "0: %p, 1: %p, 4: %p, 5: %p, curObj1 %p, old1 %p\n",
1663 bm, bm1, bm4, bm5, curObj1, old1);
1664 ok(bm != bm2 && bm != bm3, "0: %p, 2: %p, 3: %p\n", bm, bm2, bm3);
1665 ok(bm != curObj2 /* XP */ || bm == curObj2 /* Win9x */,
1666 "0: %p, curObj2 %p\n", bm, curObj2);
1667 ok(old2 == 0, "old2 %p\n", old2);
1668
1669 test_mono_1x1_bmp(bm);
1670 test_mono_1x1_bmp(bm1);
1671 test_mono_1x1_bmp(bm2);
1672 test_mono_1x1_bmp(bm3);
1673 test_mono_1x1_bmp(bm4);
1674 test_mono_1x1_bmp(bm5);
1675 test_mono_1x1_bmp(old1);
1676 test_mono_1x1_bmp(curObj1);
1677 test_mono_1x1_bmp(curObj2);
1678
1679 DeleteObject(bm);
1680 DeleteObject(bm1);
1681 DeleteObject(bm2);
1682 DeleteObject(bm3);
1683 DeleteObject(bm4);
1684 DeleteObject(bm5);
1685
1686 DeleteDC(hdc);
1687 ReleaseDC(0, screenDC);
1688
1689 /* show that Windows ignores the provided bm.bmWidthBytes */
1690 bmp.bmType = 0;
1691 bmp.bmWidth = 1;
1692 bmp.bmHeight = 1;
1693 bmp.bmWidthBytes = 28;
1694 bmp.bmPlanes = 1;
1695 bmp.bmBitsPixel = 1;
1696 bmp.bmBits = NULL;
1697 bm = CreateBitmapIndirect(&bmp);
1698 ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
1699 test_mono_1x1_bmp(bm);
1700 DeleteObject(bm);
1701 }
1702
1703 static void test_bitmapinfoheadersize(void)
1704 {
1705 HBITMAP hdib;
1706 BITMAPINFO bmi;
1707 BITMAPCOREINFO bci;
1708 HDC hdc = GetDC(0);
1709
1710 memset(&bmi, 0, sizeof(BITMAPINFO));
1711 bmi.bmiHeader.biHeight = 100;
1712 bmi.bmiHeader.biWidth = 512;
1713 bmi.bmiHeader.biBitCount = 24;
1714 bmi.bmiHeader.biPlanes = 1;
1715
1716 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER) - 1;
1717
1718 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1719 ok(hdib == NULL, "CreateDIBSection succeeded\n");
1720
1721 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1722
1723 SetLastError(0xdeadbeef);
1724 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1725 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1726 DeleteObject(hdib);
1727
1728 bmi.bmiHeader.biSize++;
1729
1730 SetLastError(0xdeadbeef);
1731 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1732 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1733 DeleteObject(hdib);
1734
1735 bmi.bmiHeader.biSize = sizeof(BITMAPINFO);
1736
1737 SetLastError(0xdeadbeef);
1738 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1739 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1740 DeleteObject(hdib);
1741
1742 bmi.bmiHeader.biSize++;
1743
1744 SetLastError(0xdeadbeef);
1745 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1746 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1747 DeleteObject(hdib);
1748
1749 bmi.bmiHeader.biSize = sizeof(BITMAPV4HEADER);
1750
1751 SetLastError(0xdeadbeef);
1752 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1753 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1754 DeleteObject(hdib);
1755
1756 bmi.bmiHeader.biSize = sizeof(BITMAPV5HEADER);
1757
1758 SetLastError(0xdeadbeef);
1759 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
1760 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1761 DeleteObject(hdib);
1762
1763 memset(&bci, 0, sizeof(BITMAPCOREINFO));
1764 bci.bmciHeader.bcHeight = 100;
1765 bci.bmciHeader.bcWidth = 512;
1766 bci.bmciHeader.bcBitCount = 24;
1767 bci.bmciHeader.bcPlanes = 1;
1768
1769 bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER) - 1;
1770
1771 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
1772 ok(hdib == NULL, "CreateDIBSection succeeded\n");
1773
1774 bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
1775
1776 SetLastError(0xdeadbeef);
1777 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
1778 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
1779 DeleteObject(hdib);
1780
1781 bci.bmciHeader.bcSize++;
1782
1783 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
1784 ok(hdib == NULL, "CreateDIBSection succeeded\n");
1785
1786 bci.bmciHeader.bcSize = sizeof(BITMAPCOREINFO);
1787
1788 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
1789 ok(hdib == NULL, "CreateDIBSection succeeded\n");
1790
1791 ReleaseDC(0, hdc);
1792 }
1793
1794 START_TEST(bitmap)
1795 {
1796 is_win9x = GetWindowLongPtrW(GetDesktopWindow(), GWLP_WNDPROC) == 0;
1797
1798 test_createdibitmap();
1799 test_dibsections();
1800 test_mono_dibsection();
1801 test_bitmap();
1802 test_bmBits();
1803 test_GetDIBits_selected_DIB(1);
1804 test_GetDIBits_selected_DIB(4);
1805 test_GetDIBits_selected_DIB(8);
1806 test_GetDIBits_selected_DDB(TRUE);
1807 test_GetDIBits_selected_DDB(FALSE);
1808 test_GetDIBits();
1809 test_select_object();
1810 test_CreateBitmap();
1811 test_bitmapinfoheadersize();
1812 }
GSOC 2012 project to enhance the control panel