?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32/header: Implement HDM_SETFILTERCHANGETIMEOUT.
[wine.git] / dlls / comctl32 / tests / header.c
blob3dc102dfd527c6d5dfe11f95c2935ccf0c0c62c2
1 /* Unit test suite for header control.
2 *
3 * Copyright 2005 Vijay Kiran Kamuju
4 * Copyright 2007 Shanren Zhou
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21
22 #include <windows.h>
23 #include <commctrl.h>
24
25 #include "wine/test.h"
26 #include "v6util.h"
27 #include "msg.h"
28
29 typedef struct tagEXPECTEDNOTIFY
30 {
31 INT iCode;
32 BOOL fUnicode;
33 HDITEMA hdItem;
34 } EXPECTEDNOTIFY;
35
36 typedef LRESULT (*CUSTOMDRAWPROC)(int n, NMCUSTOMDRAW *nm);
37
38 static CUSTOMDRAWPROC g_CustomDrawProc;
39 static int g_CustomDrawCount;
40 static DRAWITEMSTRUCT g_DrawItem;
41 static BOOL g_DrawItemReceived;
42 static DWORD g_customheight;
43
44 static EXPECTEDNOTIFY expectedNotify[10];
45 static INT nExpectedNotify = 0;
46 static INT nReceivedNotify = 0;
47 static INT unexpectedNotify[10];
48 static INT nUnexpectedNotify = 0;
49
50 static HWND hHeaderParentWnd;
51 static HWND hWndHeader;
52 #define MAX_CHARS 100
53
54 #define compare(val, exp, fmt) ok((val) == (exp), #val " value: " fmt ", expected: " fmt "\n", (val), (exp))
55
56 #define expect(expected, got) ok(expected == got, "expected %d, got %d\n", expected,got)
57
58 #define NUM_MSG_SEQUENCES 2
59 #define PARENT_SEQ_INDEX 0
60 #define HEADER_SEQ_INDEX 1
61
62 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
63
64 static const struct message create_parent_wnd_seq[] = {
65 { WM_GETMINMAXINFO, sent },
66 { WM_NCCREATE, sent },
67 { WM_NCCALCSIZE, sent|wparam, 0 },
68 { WM_CREATE, sent },
69 { 0 }
70 };
71
72 static const struct message add_header_to_parent_seq_interactive[] = {
73 { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
74 { WM_QUERYUISTATE, sent },
75 { WM_PARENTNOTIFY, sent|wparam, 1 },
76 { WM_SHOWWINDOW, sent|wparam, 1 },
77 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
78 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
79 { WM_ACTIVATEAPP, sent|wparam, 1 },
80 { WM_NCACTIVATE, sent|wparam, 1 },
81 { WM_ACTIVATE, sent|wparam, 1 },
82 { WM_IME_SETCONTEXT, sent|defwinproc|wparam, 1 },
83 { WM_IME_NOTIFY, sent|defwinproc|wparam, 2 },
84 { WM_SETFOCUS, sent|defwinproc|wparam, 0 },
85 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
86 { WM_SIZE, sent|wparam, 0 },
87 { WM_MOVE, sent|wparam, 0 },
88 { 0 }
89 };
90
91 static const struct message add_header_to_parent_seq[] = {
92 { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
93 { WM_QUERYUISTATE, sent|optional },
94 { WM_PARENTNOTIFY, sent },
95 { 0 }
96 };
97
98 static const struct message insertItem_seq[] = {
99 { HDM_INSERTITEMA, sent|wparam, 0 },
100 { HDM_INSERTITEMA, sent|wparam, 1 },
101 { HDM_INSERTITEMA, sent|wparam, 2 },
102 { HDM_INSERTITEMA, sent|wparam, 3 },
103 { 0 }
104 };
105
106 static const struct message getItem_seq[] = {
107 { HDM_GETITEMA, sent|wparam, 3 },
108 { HDM_GETITEMA, sent|wparam, 0 },
109 { 0 }
110 };
111
112
113 static const struct message deleteItem_getItemCount_seq[] = {
114 { HDM_DELETEITEM, sent|wparam, 3 },
115 { HDM_GETITEMCOUNT, sent },
116 { HDM_DELETEITEM, sent|wparam, 3 },
117 { HDM_GETITEMCOUNT, sent },
118 { HDM_DELETEITEM, sent|wparam, 2 },
119 { HDM_GETITEMCOUNT, sent },
120 { 0 }
121 };
122
123 static const struct message orderArray_seq[] = {
124 { HDM_SETORDERARRAY, sent|wparam, 2 },
125 { HDM_GETORDERARRAY, sent|wparam, 2 },
126 { 0 }
127 };
128
129 static const struct message setItem_seq[] = {
130 { HDM_SETITEMA, sent|wparam, 0 },
131 { HDM_SETITEMA, sent|wparam, 1 },
132 { 0 }
133 };
134
135 static const struct message getItemRect_seq[] = {
136 { HDM_GETITEMRECT, sent|wparam, 1 },
137 { HDM_GETITEMRECT, sent|wparam, 0 },
138 { HDM_GETITEMRECT, sent|wparam, 10 },
139 { 0 }
140 };
141
142 static const struct message layout_seq[] = {
143 { HDM_LAYOUT, sent },
144 { 0 }
145 };
146
147 static const struct message orderToIndex_seq[] = {
148 { HDM_ORDERTOINDEX, sent|wparam, 1 },
149 { 0 }
150 };
151
152 static const struct message hittest_seq[] = {
153 { HDM_HITTEST, sent },
154 { HDM_HITTEST, sent },
155 { HDM_HITTEST, sent },
156 { 0 }
157 };
158
159 static const struct message setHotDivider_seq_interactive[] = {
160 { HDM_SETHOTDIVIDER, sent|wparam, TRUE },
161 { WM_PAINT, sent|defwinproc},
162 { WM_NCPAINT, sent|defwinproc},
163 { WM_ERASEBKGND, sent|defwinproc},
164 { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 100 },
165 { WM_PAINT, sent|defwinproc},
166 { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 1},
167 { WM_PAINT, sent|defwinproc},
168 { 0 }
169 };
170
171 static const struct message setHotDivider_seq_noninteractive[] = {
172 { HDM_SETHOTDIVIDER, sent|wparam, TRUE },
173 { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 100 },
174 { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 1},
175 { 0 }
176 };
177
178 static const struct message imageMessages_seq[] = {
179 { HDM_SETIMAGELIST, sent },
180 { HDM_GETIMAGELIST, sent },
181 { HDM_CREATEDRAGIMAGE, sent },
182 { 0 }
183 };
184
185 static const struct message filterMessages_seq_interactive[] = {
186 { HDM_SETFILTERCHANGETIMEOUT, sent|wparam|lparam, 1, 100 },
187 { HDM_CLEARFILTER, sent|wparam|lparam, 0, 1 },
188 { HDM_EDITFILTER, sent|wparam|lparam, 1, 0 },
189 { WM_PARENTNOTIFY, sent|wparam|defwinproc, WM_CREATE },
190 { WM_CTLCOLOREDIT, sent|defwinproc },
191 { WM_COMMAND, sent|defwinproc },
192 { 0 }
193 };
194
195 static const struct message filterMessages_seq_noninteractive[] = {
196 { HDM_SETFILTERCHANGETIMEOUT, sent|wparam|lparam, 1, 100 },
197 { HDM_CLEARFILTER, sent|wparam|lparam, 0, 1 },
198 { HDM_EDITFILTER, sent|wparam|lparam, 1, 0 },
199 { WM_PARENTNOTIFY, sent|wparam|defwinproc|optional, WM_CREATE },
200 { WM_COMMAND, sent|defwinproc|optional },
201 { 0 }
202 };
203
204 static const struct message unicodeformatMessages_seq[] = {
205 { HDM_SETUNICODEFORMAT, sent|wparam, TRUE },
206 { HDM_GETUNICODEFORMAT, sent },
207 { 0 }
208 };
209
210 static const struct message bitmapmarginMessages_seq[] = {
211 { HDM_GETBITMAPMARGIN, sent },
212 { 0 }
213 };
214
215
216 static void expect_notify(INT iCode, BOOL fUnicode, HDITEMA *lpItem)
217 {
218 ok(nExpectedNotify < 10, "notification count %d\n", nExpectedNotify);
219 if (nExpectedNotify < 10)
220 {
221 expectedNotify[nExpectedNotify].iCode = iCode;
222 expectedNotify[nExpectedNotify].fUnicode = fUnicode;
223 expectedNotify[nExpectedNotify].hdItem = *lpItem;
224 nExpectedNotify++;
225 }
226 }
227
228 static void dont_expect_notify(INT iCode)
229 {
230 ok(nExpectedNotify < 10, "notification count %d\n", nExpectedNotify);
231 if (nExpectedNotify < 10)
232 unexpectedNotify[nUnexpectedNotify++] = iCode;
233 }
234
235 static BOOL notifies_received(void)
236 {
237 BOOL fRet = (nExpectedNotify == nReceivedNotify);
238 nExpectedNotify = nReceivedNotify = 0;
239 nUnexpectedNotify = 0;
240 return fRet;
241 }
242
243 static LONG addItem(HWND hdex, int idx, LPSTR text)
244 {
245 HDITEMA hdItem;
246 hdItem.mask = HDI_TEXT | HDI_WIDTH;
247 hdItem.cxy = 100;
248 hdItem.pszText = text;
249 hdItem.cchTextMax = 0;
250 return SendMessageA(hdex, HDM_INSERTITEMA, idx, (LPARAM)&hdItem);
251 }
252
253 static LONG setItem(HWND hdex, int idx, LPSTR text, BOOL fCheckNotifies)
254 {
255 LONG ret;
256 HDITEMA hdexItem;
257 hdexItem.mask = HDI_TEXT;
258 hdexItem.pszText = text;
259 hdexItem.cchTextMax = 0;
260 if (fCheckNotifies)
261 {
262 expect_notify(HDN_ITEMCHANGINGA, FALSE, &hdexItem);
263 expect_notify(HDN_ITEMCHANGEDA, FALSE, &hdexItem);
264 }
265 ret = SendMessageA(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
266 if (fCheckNotifies)
267 ok(notifies_received(), "setItem(): not all expected notifies were received\n");
268 return ret;
269 }
270
271 static LONG setItemUnicodeNotify(HWND hdex, int idx, LPSTR text, LPWSTR wText)
272 {
273 LONG ret;
274 HDITEMA hdexItem;
275 HDITEMW hdexNotify;
276 hdexItem.mask = HDI_TEXT;
277 hdexItem.pszText = text;
278 hdexItem.cchTextMax = 0;
279
280 hdexNotify.mask = HDI_TEXT;
281 hdexNotify.pszText = wText;
282
283 expect_notify(HDN_ITEMCHANGINGW, TRUE, (HDITEMA*)&hdexNotify);
284 expect_notify(HDN_ITEMCHANGEDW, TRUE, (HDITEMA*)&hdexNotify);
285 ret = SendMessageA(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
286 ok(notifies_received(), "setItemUnicodeNotify(): not all expected notifies were received\n");
287 return ret;
288 }
289
290 static LONG delItem(HWND hdex, int idx)
291 {
292 return SendMessageA(hdex, HDM_DELETEITEM, idx, 0);
293 }
294
295 static LONG getItemCount(HWND hdex)
296 {
297 return SendMessageA(hdex, HDM_GETITEMCOUNT, 0, 0);
298 }
299
300 static LONG getItem(HWND hdex, int idx, LPSTR textBuffer)
301 {
302 HDITEMA hdItem;
303 hdItem.mask = HDI_TEXT;
304 hdItem.pszText = textBuffer;
305 hdItem.cchTextMax = MAX_CHARS;
306 return SendMessageA(hdex, HDM_GETITEMA, idx, (LPARAM)&hdItem);
307 }
308
309 static void addReadDelItem(HWND hdex, HDITEMA *phdiCreate, int maskRead, HDITEMA *phdiRead)
310 {
311 ok(SendMessageA(hdex, HDM_INSERTITEMA, 0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
312 ZeroMemory(phdiRead, sizeof(HDITEMA));
313 phdiRead->mask = maskRead;
314 ok(SendMessageA(hdex, HDM_GETITEMA, 0, (LPARAM)phdiRead)!=0, "Getting item data failed\n");
315 ok(SendMessageA(hdex, HDM_DELETEITEM, 0, 0)!=0, "Deleting item failed\n");
316 }
317
318 static HWND create_header_control (void)
319 {
320 HWND handle;
321 HDLAYOUT hlayout;
322 RECT rectwin;
323 WINDOWPOS winpos;
324
325 handle = CreateWindowExA(0, WC_HEADERA, NULL,
326 WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
327 0, 0, 0, 0,
328 hHeaderParentWnd, NULL, NULL, NULL);
329 ok(handle != NULL, "failed to create header window\n");
330
331 if (winetest_interactive)
332 ShowWindow (hHeaderParentWnd, SW_SHOW);
333
334 GetClientRect(hHeaderParentWnd,&rectwin);
335 hlayout.prc = &rectwin;
336 hlayout.pwpos = &winpos;
337 SendMessageA(handle, HDM_LAYOUT, 0, (LPARAM)&hlayout);
338 SetWindowPos(handle, winpos.hwndInsertAfter, winpos.x, winpos.y,
339 winpos.cx, winpos.cy, 0);
340
341 return handle;
342 }
343
344 static void compare_items(INT iCode, HDITEMA *hdi1, HDITEMA *hdi2, BOOL fUnicode)
345 {
346 ok(hdi1->mask == hdi2->mask, "Notify %d mask mismatch (%08x != %08x)\n", iCode, hdi1->mask, hdi2->mask);
347 if (hdi1->mask & HDI_WIDTH)
348 {
349 ok(hdi1->cxy == hdi2->cxy, "Notify %d cxy mismatch (%08x != %08x)\n", iCode, hdi1->cxy, hdi2->cxy);
350 }
351 if (hdi1->mask & HDI_TEXT)
352 {
353 if (hdi1->pszText == LPSTR_TEXTCALLBACKA)
354 {
355 ok(hdi1->pszText == LPSTR_TEXTCALLBACKA, "Notify %d - only one item is LPSTR_TEXTCALLBACK\n", iCode);
356 }
357 else
358 if (fUnicode)
359 {
360 char buf1[260];
361 char buf2[260];
362 WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi1->pszText, -1, buf1, 260, NULL, NULL);
363 WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi2->pszText, -1, buf2, 260, NULL, NULL);
364 ok(lstrcmpW((LPWSTR)hdi1->pszText, (LPWSTR)hdi2->pszText)==0,
365 "Notify %d text mismatch (L\"%s\" vs L\"%s\")\n",
366 iCode, buf1, buf2);
367 }
368 else
369 {
370 ok(strcmp(hdi1->pszText, hdi2->pszText)==0,
371 "Notify %d text mismatch (\"%s\" vs \"%s\")\n",
372 iCode, hdi1->pszText, hdi2->pszText);
373 }
374 }
375 }
376
377 static char pszFirstItem[] = "First Item";
378 static char pszSecondItem[] = "Second Item";
379 static char pszThirdItem[] = "Third Item";
380 static char pszFourthItem[] = "Fourth Item";
381 static char pszReplaceItem[] = "Replace Item";
382 static char pszOutOfRangeItem[] = "Out Of Range Item";
383
384 static char *str_items[] =
385 {pszFirstItem, pszSecondItem, pszThirdItem, pszFourthItem, pszReplaceItem, pszOutOfRangeItem};
386
387 static char pszUniTestA[] = "TST";
388 static WCHAR pszUniTestW[] = {'T','S','T',0};
389
390
391 #define TEST_GET_ITEM(i,c)\
392 { res = getItem(hWndHeader, i, buffer);\
393 ok(res != 0, "Getting item[%d] using valid index failed unexpectedly (%d)\n", i, res);\
394 ok(strcmp(str_items[c], buffer) == 0, "Getting item[%d] returned \"%s\" expecting \"%s\"\n", i, buffer, str_items[c]);\
395 }
396
397 #define TEST_GET_ITEMCOUNT(i)\
398 { res = getItemCount(hWndHeader);\
399 ok(res == i, "Got Item Count as %d\n", res);\
400 }
401
402 static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
403 {
404 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
405 static LONG defwndproc_counter = 0;
406 LRESULT ret;
407 struct message msg;
408
409 msg.message = message;
410 msg.flags = sent|wparam|lparam;
411 if (defwndproc_counter) msg.flags |= defwinproc;
412 msg.wParam = wParam;
413 msg.lParam = lParam;
414 msg.id = 0;
415 add_message(sequences, HEADER_SEQ_INDEX, &msg);
416
417 defwndproc_counter++;
418 ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
419 defwndproc_counter--;
420
421 return ret;
422 }
423
424 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
425 {
426 static LONG defwndproc_counter = 0;
427 LRESULT ret;
428 struct message msg;
429
430 /* do not log painting messages */
431 if (message != WM_PAINT &&
432 message != WM_ERASEBKGND &&
433 message != WM_NCPAINT &&
434 message != WM_NCHITTEST &&
435 message != WM_GETTEXT &&
436 message != WM_GETICON &&
437 message != WM_DEVICECHANGE)
438
439 {
440 msg.message = message;
441 msg.flags = sent|wparam|lparam;
442 if (defwndproc_counter) msg.flags |= defwinproc;
443 msg.wParam = wParam;
444 msg.lParam = lParam;
445 msg.id = 0;
446 add_message(sequences, PARENT_SEQ_INDEX, &msg);
447 }
448
449 defwndproc_counter++;
450 ret = DefWindowProcA(hwnd, message, wParam, lParam);
451 defwndproc_counter--;
452
453 return ret;
454 }
455
456 static BOOL register_parent_wnd_class(void)
457 {
458 WNDCLASSA cls;
459
460 cls.style = 0;
461 cls.lpfnWndProc = parent_wnd_proc;
462 cls.cbClsExtra = 0;
463 cls.cbWndExtra = 0;
464 cls.hInstance = GetModuleHandleA(NULL);
465 cls.hIcon = 0;
466 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
467 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
468 cls.lpszMenuName = NULL;
469 cls.lpszClassName = "Header test parent class";
470 return RegisterClassA(&cls);
471 }
472
473 static HWND create_custom_parent_window(void)
474 {
475 if (!register_parent_wnd_class())
476 return NULL;
477
478 return CreateWindowExA(0, "Header test parent class", "Header Message Sequence Testing",
479 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
480 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
481 226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
482 NULL, NULL, GetModuleHandleA(NULL), 0);
483 }
484
485 static HWND create_custom_header_control(HWND hParent, BOOL preloadHeaderItems)
486 {
487 WNDPROC oldproc;
488 HWND childHandle;
489 HDLAYOUT hlayout;
490 RECT rectwin;
491 WINDOWPOS winpos;
492 int retVal;
493 int loopcnt;
494 static char firstHeaderItem[] = "Name";
495 static char secondHeaderItem[] = "Size";
496 static char *items[] = {secondHeaderItem, firstHeaderItem};
497 HDITEMA hdItem;
498 hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
499 hdItem.fmt = HDF_LEFT;
500 hdItem.cxy = 80;
501 hdItem.cchTextMax = 260;
502
503 flush_sequences(sequences, NUM_MSG_SEQUENCES);
504
505 childHandle = CreateWindowExA(0, WC_HEADERA, NULL,
506 WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
507 0, 0, 0, 0,
508 hParent, NULL, NULL, NULL);
509 ok(childHandle != NULL, "failed to create child window\n");
510 if (preloadHeaderItems)
511 {
512 for ( loopcnt = 0 ; loopcnt < 2 ; loopcnt++ )
513 {
514 hdItem.pszText = items[loopcnt];
515 retVal = SendMessageA(childHandle, HDM_INSERTITEMA, loopcnt, (LPARAM) &hdItem);
516 ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
517 }
518 }
519
520 if (winetest_interactive)
521 ShowWindow (hParent, SW_SHOW);
522
523 GetClientRect(hParent,&rectwin);
524 hlayout.prc = &rectwin;
525 hlayout.pwpos = &winpos;
526 SendMessageA(childHandle,HDM_LAYOUT,0,(LPARAM) &hlayout);
527 SetWindowPos(childHandle, winpos.hwndInsertAfter, winpos.x, winpos.y,
528 winpos.cx, winpos.cy, 0);
529
530 oldproc = (WNDPROC)SetWindowLongPtrA(childHandle, GWLP_WNDPROC,
531 (LONG_PTR)header_subclass_proc);
532 SetWindowLongPtrA(childHandle, GWLP_USERDATA, (LONG_PTR)oldproc);
533 return childHandle;
534 }
535
536 static void check_auto_format(void)
537 {
538 HDITEMA hdiCreate;
539 HDITEMA hdiRead;
540 static CHAR text[] = "Test";
541 ZeroMemory(&hdiCreate, sizeof(HDITEMA));
542
543 /* Windows implicitly sets some format bits in INSERTITEM */
544
545 /* HDF_STRING is automatically set and cleared for no text */
546 hdiCreate.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;
547 hdiCreate.pszText = text;
548 hdiCreate.cxy = 100;
549 hdiCreate.fmt=HDF_CENTER;
550 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
551 ok(hdiRead.fmt == (HDF_STRING|HDF_CENTER), "HDF_STRING not set automatically (fmt=%x)\n", hdiRead.fmt);
552
553 hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
554 hdiCreate.pszText = text;
555 hdiCreate.fmt = HDF_CENTER|HDF_STRING;
556 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
557 ok(hdiRead.fmt == (HDF_CENTER), "HDF_STRING should be automatically cleared (fmt=%x)\n", hdiRead.fmt);
558
559 /* HDF_BITMAP is automatically set and cleared for a NULL bitmap or no bitmap */
560 hdiCreate.mask = HDI_BITMAP|HDI_WIDTH|HDI_FORMAT;
561 hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
562 hdiCreate.fmt = HDF_CENTER;
563 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
564 ok(hdiRead.fmt == (HDF_BITMAP|HDF_CENTER), "HDF_BITMAP not set automatically (fmt=%x)\n", hdiRead.fmt);
565 DeleteObject(hdiCreate.hbm);
566
567 hdiCreate.hbm = NULL;
568 hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
569 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
570 ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for NULL bitmap (fmt=%x)\n", hdiRead.fmt);
571
572 hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
573 hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
574 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
575 ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for no bitmap (fmt=%x)\n", hdiRead.fmt);
576
577 /* HDF_IMAGE is automatically set but not cleared */
578 hdiCreate.mask = HDI_IMAGE|HDI_WIDTH|HDI_FORMAT;
579 hdiCreate.iImage = 17;
580 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
581 ok(hdiRead.fmt == (HDF_IMAGE|HDF_CENTER), "HDF_IMAGE not set automatically (fmt=%x)\n", hdiRead.fmt);
582
583 hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
584 hdiCreate.fmt = HDF_CENTER|HDF_IMAGE;
585 hdiCreate.iImage = 0;
586 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
587 ok(hdiRead.fmt == (HDF_CENTER|HDF_IMAGE), "HDF_IMAGE shouldn't be cleared automatically (fmt=%x)\n", hdiRead.fmt);
588 }
589
590 static void check_auto_fields(void)
591 {
592 HDITEMA hdiCreate;
593 HDITEMA hdiRead;
594 static CHAR text[] = "Test";
595 LONG res;
596
597 /* Windows stores the format, width, lparam even if they are not in the item's mask */
598 ZeroMemory(&hdiCreate, sizeof(HDITEMA));
599 hdiCreate.mask = HDI_TEXT;
600 hdiCreate.cxy = 100;
601 hdiCreate.pszText = text;
602 addReadDelItem(hWndHeader, &hdiCreate, HDI_WIDTH, &hdiRead);
603 TEST_GET_ITEMCOUNT(6);
604 ok(hdiRead.cxy == hdiCreate.cxy, "cxy should be automatically set\n");
605
606 ZeroMemory(&hdiCreate, sizeof(HDITEMA));
607 hdiCreate.mask = HDI_TEXT;
608 hdiCreate.pszText = text;
609 hdiCreate.lParam = 0x12345678;
610 addReadDelItem(hWndHeader, &hdiCreate, HDI_LPARAM, &hdiRead);
611 TEST_GET_ITEMCOUNT(6);
612 ok(hdiRead.lParam == hdiCreate.lParam, "lParam should be automatically set\n");
613
614 ZeroMemory(&hdiCreate, sizeof(HDITEMA));
615 hdiCreate.mask = HDI_TEXT;
616 hdiCreate.pszText = text;
617 hdiCreate.fmt = HDF_STRING|HDF_CENTER;
618 addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
619 TEST_GET_ITEMCOUNT(6);
620 ok(hdiRead.fmt == hdiCreate.fmt, "fmt should be automatically set\n");
621
622 /* others fields are not set */
623 ZeroMemory(&hdiCreate, sizeof(HDITEMA));
624 hdiCreate.mask = HDI_TEXT;
625 hdiCreate.pszText = text;
626 hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
627 addReadDelItem(hWndHeader, &hdiCreate, HDI_BITMAP, &hdiRead);
628 TEST_GET_ITEMCOUNT(6);
629 ok(hdiRead.hbm == NULL, "hbm should not be automatically set\n");
630 DeleteObject(hdiCreate.hbm);
631
632 ZeroMemory(&hdiCreate, sizeof(HDITEMA));
633 hdiCreate.mask = HDI_IMAGE;
634 hdiCreate.iImage = 17;
635 hdiCreate.pszText = text;
636 addReadDelItem(hWndHeader, &hdiCreate, HDI_TEXT, &hdiRead);
637 TEST_GET_ITEMCOUNT(6);
638 ok(hdiRead.pszText==NULL, "pszText shouldn't be automatically set\n");
639
640 /* field from comctl >4.0 not tested as the system probably won't touch them */
641 }
642
643 static void check_mask(void)
644 {
645 HDITEMA hdi;
646 static CHAR text[] = "ABC";
647 LRESULT ret;
648
649 /* don't create items if the mask is zero */
650 ZeroMemory(&hdi, sizeof(hdi));
651 hdi.mask = 0;
652 hdi.cxy = 200;
653 hdi.pszText = text;
654 hdi.fmt = 0;
655 hdi.iOrder = 0;
656 hdi.lParam = 17;
657 hdi.cchTextMax = 260;
658 ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
659 ok(ret == -1, "Creating an item with a zero mask should have failed\n");
660 if (ret != -1) SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
661
662 /* with a non-zero mask creation will succeed */
663 ZeroMemory(&hdi, sizeof(hdi));
664 hdi.mask = HDI_LPARAM;
665 ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
666 ok(ret != -1, "Adding item with non-zero mask failed\n");
667 if (ret != -1)
668 SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
669
670 /* in SETITEM if the mask contains a unknown bit, it is ignored */
671 ZeroMemory(&hdi, sizeof(hdi));
672 hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
673 hdi.lParam = 133;
674 hdi.iImage = 17;
675 ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
676 ok(ret != -1, "Adding item failed\n");
677
678 if (ret != -1)
679 {
680 /* check result */
681 ZeroMemory(&hdi, sizeof(hdi));
682 hdi.mask = HDI_LPARAM | HDI_IMAGE;
683 SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
684 ok(hdi.lParam == 133, "comctl32 4.0 field not set\n");
685 ok(hdi.iImage == 17, "comctl32 >4.0 field not set\n");
686
687 /* but in GETITEM if an unknown bit is set, comctl32 uses only version 4.0 fields */
688 ZeroMemory(&hdi, sizeof(hdi));
689 hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
690 SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
691 ok(hdi.lParam == 133, "comctl32 4.0 field not read\n");
692 ok(hdi.iImage == 0, "comctl32 >4.0 field shouldn't be read\n");
693
694 SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
695 }
696 }
697
698 static void test_header_control (void)
699 {
700 LONG res;
701 static char buffer[MAX_CHARS];
702 int i;
703
704 hWndHeader = create_header_control ();
705
706 for (i = 3; i >= 0; i--)
707 {
708 TEST_GET_ITEMCOUNT(3-i);
709 res = addItem(hWndHeader, 0, str_items[i]);
710 ok(res == 0, "Adding simple item failed (%d)\n", res);
711 }
712
713 TEST_GET_ITEMCOUNT(4);
714 res = addItem(hWndHeader, 99, str_items[i+1]);
715 ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
716 TEST_GET_ITEMCOUNT(5);
717 res = addItem(hWndHeader, 5, str_items[i+1]);
718 ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
719 TEST_GET_ITEMCOUNT(6);
720
721 for (i = 0; i < 4; i++) { TEST_GET_ITEM(i,i); TEST_GET_ITEMCOUNT(6); }
722
723 res=getItem(hWndHeader, 99, buffer);
724 ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
725 res=getItem(hWndHeader, 5, buffer);
726 ok(res == 1, "Getting Out of Range item should fail with 1 (%d), got %s\n", res,buffer);
727 res=getItem(hWndHeader, -2, buffer);
728 ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
729
730 if (winetest_interactive)
731 {
732 UpdateWindow(hHeaderParentWnd);
733 UpdateWindow(hWndHeader);
734 }
735
736 TEST_GET_ITEMCOUNT(6);
737 res=setItem(hWndHeader, 99, str_items[5], FALSE);
738 ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
739 res=setItem(hWndHeader, 5, str_items[5], TRUE);
740 ok(res == 1, "Setting Out of Range item should fail with 1 (%d)\n", res);
741 res=setItem(hWndHeader, -2, str_items[5], FALSE);
742 ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
743 TEST_GET_ITEMCOUNT(6);
744
745 for (i = 0; i < 4; i++)
746 {
747 res = setItem(hWndHeader, i, str_items[4], TRUE);
748 ok(res != 0, "Setting %d item failed (%d)\n", i+1, res);
749 TEST_GET_ITEM(i, 4);
750 TEST_GET_ITEMCOUNT(6);
751 }
752
753 SendMessageA(hWndHeader, HDM_SETUNICODEFORMAT, TRUE, 0);
754 setItemUnicodeNotify(hWndHeader, 3, pszUniTestA, pszUniTestW);
755 SendMessageA(hWndHeader, WM_NOTIFYFORMAT, (WPARAM)hHeaderParentWnd, NF_REQUERY);
756 setItem(hWndHeader, 3, str_items[4], TRUE);
757
758 dont_expect_notify(HDN_GETDISPINFOA);
759 dont_expect_notify(HDN_GETDISPINFOW);
760 addItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA);
761 setItem(hWndHeader, 0, str_items[4], TRUE);
762 /* unexpected notifies cleared by notifies_received in setItem */
763 dont_expect_notify(HDN_GETDISPINFOA);
764 dont_expect_notify(HDN_GETDISPINFOW);
765 setItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA, TRUE);
766 /* unexpected notifies cleared by notifies_received in setItem */
767 delItem(hWndHeader, 0);
768
769 check_auto_format();
770 TEST_GET_ITEMCOUNT(6);
771 check_auto_fields();
772 TEST_GET_ITEMCOUNT(6);
773 check_mask();
774 TEST_GET_ITEMCOUNT(6);
775
776 res = delItem(hWndHeader, 5);
777 ok(res == 1, "Deleting Out of Range item should fail with 1 (%d)\n", res);
778 res = delItem(hWndHeader, -2);
779 ok(res == 0, "Deleting Out of Range item should fail with 0 (%d)\n", res);
780 TEST_GET_ITEMCOUNT(5);
781
782 res = delItem(hWndHeader, 3);
783 ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
784 TEST_GET_ITEMCOUNT(4);
785 res = delItem(hWndHeader, 0);
786 ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
787 TEST_GET_ITEMCOUNT(3);
788 res = delItem(hWndHeader, 0);
789 ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
790 TEST_GET_ITEMCOUNT(2);
791 res = delItem(hWndHeader, 0);
792 ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
793 TEST_GET_ITEMCOUNT(1);
794
795 DestroyWindow(hWndHeader);
796 }
797
798 static void test_hdm_getitemrect(HWND hParent)
799 {
800
801 HWND hChild;
802 RECT rect;
803 int retVal;
804
805 flush_sequences(sequences, NUM_MSG_SEQUENCES);
806 hChild = create_custom_header_control(hParent, TRUE);
807 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
808 "adder header control to parent", FALSE);
809
810 retVal = SendMessageA(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
811 ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
812 /* check bounding rectangle information of 2nd header item */
813 expect(80, rect.left);
814 expect(0, rect.top);
815 expect(160, rect.right);
816 expect(g_customheight, rect.bottom);
817
818 retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
819
820 ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
821 /* check bounding rectangle information of 1st header item */
822 expect(0, rect.left);
823 expect(0, rect.top);
824
825 expect(80, rect.right);
826 expect(g_customheight, rect.bottom);
827
828 retVal = SendMessageA(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
829 ok(retVal == 0, "Getting rect of nonexistent item should return 0, got %d\n", retVal);
830
831 ok_sequence(sequences, HEADER_SEQ_INDEX, getItemRect_seq, "getItemRect sequence testing", FALSE);
832 DestroyWindow(hChild);
833 }
834
835 static void test_hdm_layout(HWND hParent)
836 {
837 HWND hChild;
838 int retVal;
839 RECT rect;
840 HDLAYOUT hdLayout;
841 WINDOWPOS windowPos;
842 hdLayout.prc = &rect;
843 hdLayout.pwpos = &windowPos;
844
845 flush_sequences(sequences, NUM_MSG_SEQUENCES);
846 hChild = create_custom_header_control(hParent, TRUE);
847 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
848 "adder header control to parent", FALSE);
849
850 flush_sequences(sequences, NUM_MSG_SEQUENCES);
851 retVal = SendMessageA(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
852 expect(TRUE, retVal);
853
854 ok_sequence(sequences, HEADER_SEQ_INDEX, layout_seq, "layout sequence testing", FALSE);
855
856 DestroyWindow(hChild);
857 }
858
859 static void test_hdm_ordertoindex(HWND hParent)
860 {
861 HWND hChild;
862 int retVal;
863
864 flush_sequences(sequences, NUM_MSG_SEQUENCES);
865 hChild = create_custom_header_control(hParent, TRUE);
866 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
867 "adder header control to parent", FALSE);
868
869 flush_sequences(sequences, NUM_MSG_SEQUENCES);
870 retVal = SendMessageA(hChild, HDM_ORDERTOINDEX, 1, 0);
871 expect(1, retVal);
872
873 ok_sequence(sequences, HEADER_SEQ_INDEX, orderToIndex_seq, "orderToIndex sequence testing", FALSE);
874 DestroyWindow(hChild);
875 }
876
877 static void test_hdm_hittest(HWND hParent)
878 {
879 HWND hChild;
880 int retVal;
881 POINT pt;
882 HDHITTESTINFO hdHitTestInfo;
883 const int firstItemRightBoundary = 80;
884 const int secondItemRightBoundary = 160;
885 const int bottomBoundary = g_customheight;
886
887 pt.x = firstItemRightBoundary - 1;
888 pt.y = bottomBoundary - 1;
889 hdHitTestInfo.pt = pt;
890
891
892 flush_sequences(sequences, NUM_MSG_SEQUENCES);
893 hChild = create_custom_header_control(hParent, TRUE);
894 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
895 "adder header control to parent", FALSE);
896
897 flush_sequences(sequences, NUM_MSG_SEQUENCES);
898 retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
899 expect(0, retVal);
900 expect(0, hdHitTestInfo.iItem);
901 expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
902
903 pt.x = secondItemRightBoundary - 1;
904 pt.y = bottomBoundary - 1;
905 hdHitTestInfo.pt = pt;
906 retVal = SendMessageA(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
907 expect(1, retVal);
908 expect(1, hdHitTestInfo.iItem);
909 expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
910
911 pt.x = secondItemRightBoundary;
912 pt.y = bottomBoundary + 1;
913 hdHitTestInfo.pt = pt;
914 retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
915 expect(-1, retVal);
916 expect(-1, hdHitTestInfo.iItem);
917 expect(HHT_BELOW, hdHitTestInfo.flags);
918
919 ok_sequence(sequences, HEADER_SEQ_INDEX, hittest_seq, "hittest sequence testing", FALSE);
920
921 DestroyWindow(hChild);
922 }
923
924 static void test_hdm_sethotdivider(HWND hParent)
925 {
926 HWND hChild;
927 int retVal;
928 /* low word: x coordinate = 5
929 * high word: y coordinate = 5
930 */
931
932 flush_sequences(sequences, NUM_MSG_SEQUENCES);
933 hChild = create_custom_header_control(hParent, TRUE);
934 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
935 "adder header control to parent", FALSE);
936
937 flush_sequences(sequences, NUM_MSG_SEQUENCES);
938 retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, TRUE, MAKELPARAM(5, 5));
939 expect(0, retVal);
940
941 retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
942 expect(100, retVal);
943 retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
944 expect(1, retVal);
945 if (winetest_interactive)
946 ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_interactive,
947 "setHotDivider sequence testing", TRUE);
948 else
949 ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_noninteractive,
950 "setHotDivider sequence testing", FALSE);
951
952 DestroyWindow(hChild);
953 }
954
955 static void test_hdm_imageMessages(HWND hParent)
956 {
957 HIMAGELIST hImageList = ImageList_Create (4, 4, 0, 1, 0);
958 HIMAGELIST hIml;
959 BOOL wasValid;
960 HWND hChild;
961
962 flush_sequences(sequences, NUM_MSG_SEQUENCES);
963 hChild = create_custom_header_control(hParent, TRUE);
964 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
965 "adder header control to parent", FALSE);
966
967 flush_sequences(sequences, NUM_MSG_SEQUENCES);
968
969 hIml = (HIMAGELIST) SendMessageA(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
970 ok(hIml == NULL, "Expected NULL, got %p\n", hIml);
971
972 hIml = (HIMAGELIST) SendMessageA(hChild, HDM_GETIMAGELIST, 0, 0);
973 ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
974
975 hIml = (HIMAGELIST) SendMessageA(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
976 ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
977 ImageList_Destroy(hIml);
978
979 ok_sequence(sequences, HEADER_SEQ_INDEX, imageMessages_seq, "imageMessages sequence testing", FALSE);
980
981 DestroyWindow(hChild);
982
983 wasValid = ImageList_Destroy(hImageList);
984 ok(wasValid, "Header must not free image list at destruction!\n");
985 }
986
987 static void test_hdm_filterMessages(HWND hParent)
988 {
989 HWND hChild;
990 int retVal, timeout;
991
992 flush_sequences(sequences, NUM_MSG_SEQUENCES);
993 hChild = create_custom_header_control(hParent, TRUE);
994 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
995 "adder header control to parent", FALSE);
996
997 timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 0, 0);
998 ok(timeout == 1000, "got %d\n", timeout);
999
1000 timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 0, 0);
1001 ok(timeout == 1000, "got %d\n", timeout);
1002
1003 timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 0, -100);
1004 ok(timeout == 1000, "got %d\n", timeout);
1005
1006 timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1007 ok(timeout == -100, "got %d\n", timeout);
1008 retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
1009 ok(retVal == 100, "got %d\n", retVal);
1010
1011 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1012
1013 /* msdn incorrectly states that return value
1014 * is the index of the filter control being
1015 * modified. The sendMessage here should
1016 * return previous filter timeout value
1017 */
1018
1019 retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1020 expect(timeout, retVal);
1021
1022 todo_wine
1023 {
1024 retVal = SendMessageA(hChild, HDM_CLEARFILTER, 0, 1);
1025 if (retVal == 0)
1026 win_skip("HDM_CLEARFILTER needs 5.80\n");
1027 else
1028 expect(1, retVal);
1029
1030 retVal = SendMessageA(hChild, HDM_EDITFILTER, 1, 0);
1031 if (retVal == 0)
1032 win_skip("HDM_EDITFILTER needs 5.80\n");
1033 else
1034 expect(1, retVal);
1035 }
1036 if (winetest_interactive)
1037 ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_interactive,
1038 "filterMessages sequence testing", TRUE);
1039 else
1040 ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_noninteractive,
1041 "filterMessages sequence testing", FALSE);
1042 DestroyWindow(hChild);
1043
1044 }
1045
1046 static void test_hdm_unicodeformatMessages(HWND hParent)
1047 {
1048 HWND hChild;
1049 int retVal;
1050
1051 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1052 hChild = create_custom_header_control(hParent, TRUE);
1053 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1054 "adder header control to parent", FALSE);
1055
1056 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1057 retVal = SendMessageA(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
1058 expect(0, retVal);
1059 retVal = SendMessageA(hChild, HDM_GETUNICODEFORMAT, 0, 0);
1060 expect(1, retVal);
1061
1062 ok_sequence(sequences, HEADER_SEQ_INDEX, unicodeformatMessages_seq,
1063 "unicodeformatMessages sequence testing", FALSE);
1064 DestroyWindow(hChild);
1065 }
1066
1067 static void test_hdm_bitmapmarginMessages(HWND hParent)
1068 {
1069 HWND hChild;
1070 int retVal;
1071
1072 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1073 hChild = create_custom_header_control(hParent, TRUE);
1074 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1075 "adder header control to parent", FALSE);
1076
1077 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1078 retVal = SendMessageA(hChild, HDM_GETBITMAPMARGIN, 0, 0);
1079 if (retVal == 0)
1080 win_skip("HDM_GETBITMAPMARGIN needs 5.80\n");
1081 else
1082 expect(6, retVal);
1083
1084 ok_sequence(sequences, HEADER_SEQ_INDEX, bitmapmarginMessages_seq,
1085 "bitmapmarginMessages sequence testing", FALSE);
1086 DestroyWindow(hChild);
1087 }
1088
1089 static void test_hdm_index_messages(HWND hParent)
1090 {
1091 HWND hChild;
1092 int retVal, i, iSize;
1093 static const int lpiarray[2] = {1, 0};
1094 static const char *item_texts[] = {
1095 "Name", "Size", "Type", "Date Modified"
1096 };
1097 RECT rect;
1098 HDITEMA hdItem;
1099 char buffA[32];
1100 int array[2];
1101
1102 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1103 hChild = create_custom_header_control(hParent, FALSE);
1104 if (winetest_interactive)
1105 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq_interactive,
1106 "adder header control to parent", TRUE);
1107 else
1108 ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1109 "adder header control to parent", FALSE);
1110 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1111 for (i = 0; i < sizeof(item_texts)/sizeof(item_texts[0]); i++)
1112 {
1113 hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
1114 hdItem.pszText = (char*)item_texts[i];
1115 hdItem.fmt = HDF_LEFT;
1116 hdItem.cxy = 80;
1117
1118 retVal = SendMessageA(hChild, HDM_INSERTITEMA, i, (LPARAM) &hdItem);
1119 ok(retVal == i, "Adding item %d failed with return value %d\n", i, retVal);
1120 }
1121 ok_sequence(sequences, HEADER_SEQ_INDEX, insertItem_seq, "insertItem sequence testing", FALSE);
1122
1123 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1124
1125 retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1126 ok(retVal == TRUE, "Deleting item 3 should return TRUE, got %d\n", retVal);
1127 retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1128 ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
1129
1130 retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1131 ok(retVal == FALSE, "Deleting already-deleted item should return FALSE, got %d\n", retVal);
1132 retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1133 ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
1134
1135 retVal = SendMessageA(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
1136 ok(retVal == TRUE, "Deleting item 2 should return TRUE, got %d\n", retVal);
1137 retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1138 ok(retVal == 2, "Getting item count should return 2, got %d\n", retVal);
1139
1140 ok_sequence(sequences, HEADER_SEQ_INDEX, deleteItem_getItemCount_seq,
1141 "deleteItem_getItemCount sequence testing", FALSE);
1142
1143 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1144
1145 hdItem.mask = HDI_WIDTH;
1146 retVal = SendMessageA(hChild, HDM_GETITEMA, 3, (LPARAM) &hdItem);
1147 ok(retVal == FALSE, "Getting already-deleted item should return FALSE, got %d\n", retVal);
1148
1149 hdItem.mask = HDI_TEXT | HDI_WIDTH;
1150 hdItem.pszText = buffA;
1151 hdItem.cchTextMax = sizeof(buffA)/sizeof(buffA[0]);
1152 retVal = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM) &hdItem);
1153 ok(retVal == TRUE, "Getting the 1st header item should return TRUE, got %d\n", retVal);
1154
1155 ok_sequence(sequences, HEADER_SEQ_INDEX, getItem_seq, "getItem sequence testing", FALSE);
1156
1157 /* check if the item is the right one */
1158 ok(!strcmp(hdItem.pszText, item_texts[0]), "got wrong item %s, expected %s\n",
1159 hdItem.pszText, item_texts[0]);
1160 expect(80, hdItem.cxy);
1161
1162 iSize = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1163
1164 /* item should be updated just after accepting new array */
1165 ShowWindow(hChild, SW_HIDE);
1166 retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1167 expect(TRUE, retVal);
1168 rect.left = 0;
1169 retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
1170 expect(TRUE, retVal);
1171 ok(rect.left != 0, "Expected updated rectangle\n");
1172
1173 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1174
1175 retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1176 ok(retVal == TRUE, "Setting header items order should return TRUE, got %d\n", retVal);
1177
1178 retVal = SendMessageA(hChild, HDM_GETORDERARRAY, 2, (LPARAM) array);
1179 ok(retVal == TRUE, "Getting header items order should return TRUE, got %d\n", retVal);
1180
1181 ok_sequence(sequences, HEADER_SEQ_INDEX, orderArray_seq, "set_get_orderArray sequence testing", FALSE);
1182
1183 /* check if the array order is set correctly and the size of the array is correct. */
1184 expect(2, iSize);
1185 ok(lpiarray[0] == array[0], "got %d, expected %d\n", array[0], lpiarray[0]);
1186 ok(lpiarray[1] == array[1], "got %d, expected %d\n", array[1], lpiarray[1]);
1187
1188 hdItem.mask = HDI_FORMAT;
1189 hdItem.fmt = HDF_CENTER | HDF_STRING;
1190
1191 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1192
1193 retVal = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM) &hdItem);
1194 ok(retVal == TRUE, "Aligning 1st header item to center should return TRUE, got %d\n", retVal);
1195 hdItem.fmt = HDF_RIGHT | HDF_STRING;
1196 retVal = SendMessageA(hChild, HDM_SETITEMA, 1, (LPARAM) &hdItem);
1197 ok(retVal == TRUE, "Aligning 2nd header item to right should return TRUE, got %d\n", retVal);
1198
1199 ok_sequence(sequences, HEADER_SEQ_INDEX, setItem_seq, "setItem sequence testing", FALSE);
1200 DestroyWindow(hChild);
1201 }
1202
1203 static void test_hdf_fixedwidth(HWND hParent)
1204 {
1205 HWND hChild;
1206 HDITEMA hdItem;
1207 DWORD ret;
1208 RECT rect;
1209 HDHITTESTINFO ht;
1210
1211 hChild = create_custom_header_control(hParent, FALSE);
1212
1213 hdItem.mask = HDI_WIDTH | HDI_FORMAT;
1214 hdItem.fmt = HDF_FIXEDWIDTH;
1215 hdItem.cxy = 80;
1216
1217 ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
1218 expect(0, ret);
1219
1220 /* try to change width */
1221 rect.right = rect.bottom = 0;
1222 SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1223 ok(rect.right != 0, "Expected not zero width\n");
1224 ok(rect.bottom != 0, "Expected not zero height\n");
1225
1226 SendMessageA(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
1227 SendMessageA(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
1228 SendMessageA(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
1229
1230 SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1231
1232 if (hdItem.cxy != rect.right)
1233 {
1234 win_skip("HDF_FIXEDWIDTH format not supported\n");
1235 DestroyWindow(hChild);
1236 return;
1237 }
1238
1239 /* try to adjust with message */
1240 hdItem.mask = HDI_WIDTH;
1241 hdItem.cxy = 90;
1242
1243 ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1244 expect(TRUE, ret);
1245
1246 rect.right = 0;
1247 SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1248 expect(90, rect.right);
1249
1250 /* hittesting doesn't report ondivider flag for HDF_FIXEDWIDTH */
1251 ht.pt.x = rect.right - 1;
1252 ht.pt.y = rect.bottom / 2;
1253 SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1254 expect(HHT_ONHEADER, ht.flags);
1255
1256 /* try to adjust with message */
1257 hdItem.mask = HDI_FORMAT;
1258 hdItem.fmt = 0;
1259
1260 ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1261 expect(TRUE, ret);
1262
1263 ht.pt.x = 90;
1264 ht.pt.y = rect.bottom / 2;
1265 SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1266 expect(HHT_ONDIVIDER, ht.flags);
1267
1268 DestroyWindow(hChild);
1269 }
1270
1271 static void test_hds_nosizing(HWND hParent)
1272 {
1273 HWND hChild;
1274 HDITEMA hdItem;
1275 DWORD ret;
1276 RECT rect;
1277 HDHITTESTINFO ht;
1278
1279 hChild = create_custom_header_control(hParent, FALSE);
1280
1281 memset(&hdItem, 0, sizeof(hdItem));
1282 hdItem.mask = HDI_WIDTH;
1283 hdItem.cxy = 80;
1284
1285 ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
1286 expect(0, ret);
1287
1288 /* HDS_NOSIZING only blocks hittesting */
1289 ret = GetWindowLongA(hChild, GWL_STYLE);
1290 SetWindowLongA(hChild, GWL_STYLE, ret | HDS_NOSIZING);
1291
1292 /* try to change width with mouse gestures */
1293 rect.right = rect.bottom = 0;
1294 SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1295 ok(rect.right != 0, "Expected not zero width\n");
1296 ok(rect.bottom != 0, "Expected not zero height\n");
1297
1298 SendMessageA(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
1299 SendMessageA(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
1300 SendMessageA(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
1301
1302 SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1303
1304 if (hdItem.cxy != rect.right)
1305 {
1306 win_skip("HDS_NOSIZING style not supported\n");
1307 DestroyWindow(hChild);
1308 return;
1309 }
1310
1311 /* this style doesn't set HDF_FIXEDWIDTH for items */
1312 hdItem.mask = HDI_FORMAT;
1313 ret = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM)&hdItem);
1314 expect(TRUE, ret);
1315 ok(!(hdItem.fmt & HDF_FIXEDWIDTH), "Unexpected HDF_FIXEDWIDTH\n");
1316
1317 /* try to adjust with message */
1318 hdItem.mask = HDI_WIDTH;
1319 hdItem.cxy = 90;
1320
1321 ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1322 expect(TRUE, ret);
1323
1324 rect.right = 0;
1325 SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1326 expect(90, rect.right);
1327
1328 /* hittesting doesn't report ondivider flags for HDS_NOSIZING */
1329 ht.pt.x = rect.right - 1;
1330 ht.pt.y = rect.bottom / 2;
1331 SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1332 expect(HHT_ONHEADER, ht.flags);
1333
1334 /* try to adjust with message */
1335 ret = GetWindowLongA(hChild, GWL_STYLE);
1336 SetWindowLongA(hChild, GWL_STYLE, ret & ~HDS_NOSIZING);
1337
1338 ht.pt.x = 90;
1339 ht.pt.y = rect.bottom / 2;
1340 SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1341 expect(HHT_ONDIVIDER, ht.flags);
1342
1343 DestroyWindow(hChild);
1344 }
1345
1346 #define TEST_NMCUSTOMDRAW(draw_stage, item_spec, lparam, _left, _top, _right, _bottom) \
1347 ok(nm->dwDrawStage == draw_stage, "Invalid dwDrawStage %d vs %d\n", draw_stage, nm->dwDrawStage); \
1348 if (item_spec != -1) \
1349 ok(nm->dwItemSpec == item_spec, "Invalid dwItemSpec %d vs %ld\n", item_spec, nm->dwItemSpec); \
1350 ok(nm->lItemlParam == lparam, "Invalid lItemlParam %d vs %ld\n", lparam, nm->lItemlParam); \
1351 ok((nm->rc.top == _top && nm->rc.bottom == _bottom && nm->rc.left == _left && nm->rc.right == _right) || \
1352 broken(draw_stage != CDDS_ITEMPREPAINT), /* comctl32 < 5.80 */ \
1353 "Invalid rect (%d,%d) (%d,%d) vs (%d,%d) (%d,%d)\n", _left, _top, _right, _bottom, \
1354 nm->rc.left, nm->rc.top, nm->rc.right, nm->rc.bottom);
1355
1356 static LRESULT customdraw_1(int n, NMCUSTOMDRAW *nm)
1357 {
1358 if (nm == NULL) { /* test ended */
1359 ok(n==1, "NM_CUSTOMDRAW messages: %d, expected: 1\n", n);
1360 return 0;
1361 }
1362
1363 switch (n)
1364 {
1365 case 0:
1366 /* don't test dwItemSpec - it's 0 no comctl5 but 1308756 on comctl6 */
1367 TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1368 return 0;
1369 }
1370
1371 ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1372 return -1;
1373 }
1374
1375 static LRESULT customdraw_2(int n, NMCUSTOMDRAW *nm)
1376 {
1377 if (nm == NULL) { /* test ended */
1378 ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
1379 return 0;
1380 }
1381
1382 switch (n)
1383 {
1384 case 0:
1385 TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1386 return CDRF_NOTIFYITEMDRAW;
1387 case 1:
1388 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1389 return 0;
1390 case 2:
1391 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1392 return 0;
1393 case 3:
1394 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1395 return 0;
1396 }
1397
1398 ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1399 return 0;
1400 }
1401
1402 static LRESULT customdraw_3(int n, NMCUSTOMDRAW *nm)
1403 {
1404 if (nm == NULL) { /* test ended */
1405 ok(n==5, "NM_CUSTOMDRAW messages: %d, expected: 5\n", n);
1406 return 0;
1407 }
1408
1409 switch (n)
1410 {
1411 case 0:
1412 TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1413 return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTERASE|CDRF_NOTIFYPOSTPAINT|CDRF_SKIPDEFAULT;
1414 case 1:
1415 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1416 return 0;
1417 case 2:
1418 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1419 return 0;
1420 case 3:
1421 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1422 return 0;
1423 case 4:
1424 TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1425 return 0;
1426 }
1427
1428 ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1429 return 0;
1430 }
1431
1432
1433 static LRESULT customdraw_4(int n, NMCUSTOMDRAW *nm)
1434 {
1435 if (nm == NULL) { /* test ended */
1436 ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
1437 return 0;
1438 }
1439
1440 switch (n)
1441 {
1442 case 0:
1443 TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1444 return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTPAINT;
1445 case 1:
1446 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1447 return 0;
1448 case 2:
1449 TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1450 return 0;
1451 case 3:
1452 TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1453 return 0;
1454 }
1455
1456 ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1457 return 0;
1458 }
1459
1460 static void run_customdraw_scenario(CUSTOMDRAWPROC proc)
1461 {
1462 g_CustomDrawProc = proc;
1463 g_CustomDrawCount = 0;
1464 InvalidateRect(hWndHeader, NULL, TRUE);
1465 UpdateWindow(hWndHeader);
1466 proc(g_CustomDrawCount, NULL);
1467 g_CustomDrawProc = NULL;
1468 }
1469
1470 static void test_customdraw(void)
1471 {
1472 int i;
1473 HDITEMA item;
1474 RECT rect;
1475 CHAR name[] = "Test";
1476 hWndHeader = create_header_control();
1477 GetClientRect(hWndHeader, &rect);
1478 ok(rect.right - rect.left == 670 && rect.bottom - rect.top == g_customheight,
1479 "Tests will fail as header size is %dx%d instead of 670x%d\n",
1480 rect.right - rect.left, rect.bottom - rect.top, g_customheight);
1481
1482 for (i = 0; i < 3; i++)
1483 {
1484 ZeroMemory(&item, sizeof(item));
1485 item.mask = HDI_TEXT|HDI_WIDTH;
1486 item.cxy = 50*(i+1);
1487 item.pszText = name;
1488 item.lParam = i*5;
1489 SendMessageA(hWndHeader, HDM_INSERTITEMA, i, (LPARAM)&item);
1490 }
1491
1492 run_customdraw_scenario(customdraw_1);
1493 run_customdraw_scenario(customdraw_2);
1494 run_customdraw_scenario(customdraw_3);
1495
1496 ZeroMemory(&item, sizeof(item));
1497 item.mask = HDI_FORMAT;
1498 item.fmt = HDF_OWNERDRAW;
1499 SendMessageA(hWndHeader, HDM_SETITEMA, 1, (LPARAM)&item);
1500 g_DrawItem.CtlID = 0;
1501 g_DrawItem.CtlType = ODT_HEADER;
1502 g_DrawItem.hwndItem = hWndHeader;
1503 g_DrawItem.itemID = 1;
1504 g_DrawItem.itemState = 0;
1505 SendMessageA(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
1506 run_customdraw_scenario(customdraw_4);
1507 ok(g_DrawItemReceived, "WM_DRAWITEM not received\n");
1508 DestroyWindow(hWndHeader);
1509 hWndHeader = NULL;
1510 g_DrawItem.CtlType = 0;
1511 g_DrawItemReceived = FALSE;
1512 }
1513
1514 static void check_order(const int expected_id[], const int expected_order[],
1515 int count, const char *type)
1516 {
1517 int i;
1518 HDITEMA hdi;
1519
1520 ok(getItemCount(hWndHeader) == count, "Invalid item count in order tests\n");
1521 for (i = 0; i < count; i++)
1522 {
1523 hdi.mask = HDI_LPARAM|HDI_ORDER;
1524 SendMessageA(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
1525 ok(hdi.lParam == expected_id[i],
1526 "Invalid item ids after '%s'- item %d has lParam %d\n", type, i, (int)hdi.lParam);
1527 ok(hdi.iOrder == expected_order[i],
1528 "Invalid item order after '%s'- item %d has iOrder %d\n", type, i, hdi.iOrder);
1529 }
1530 }
1531
1532 static void test_header_order (void)
1533 {
1534 const int rand1[] = {0, 1, 1, 0, 4};
1535 const int rand2[] = {4, 5, 6, 7, 4};
1536 const int rand3[] = {5, 5, 1, 6, 1};
1537 const int rand4[] = {1, 5, 2, 7, 6, 1, 4, 2, 3, 2};
1538 const int rand5[] = {7, 8, 5, 6, 7, 2, 1, 9, 10, 10};
1539 const int rand6[] = {2, 8, 3, 4, 0};
1540
1541 const int ids1[] = {3, 0, 2, 1, 4};
1542 const int ord1[] = {0, 1, 2, 3, 4};
1543 const int ids2[] = {3, 9, 7, 0, 2, 1, 4, 8, 6, 5};
1544 const int ord2[] = {0, 4, 7, 1, 2, 3, 9, 8, 6, 5};
1545 const int ord3[] = {0, 3, 9, 2, 1, 8, 7, 6, 5, 4};
1546 const int ids4[] = {9, 0, 1, 8, 6};
1547 const int ord4[] = {1, 0, 4, 3, 2};
1548
1549 char buffer[20];
1550 HDITEMA hdi;
1551 int i;
1552
1553 hWndHeader = create_header_control();
1554
1555 ZeroMemory(&hdi, sizeof(HDITEMA));
1556 hdi.mask = HDI_TEXT | HDI_LPARAM;
1557 hdi.pszText = buffer;
1558 strcpy(buffer, "test");
1559
1560 for (i = 0; i < 5; i++)
1561 {
1562 hdi.lParam = i;
1563 SendMessageA(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
1564 rand();
1565 }
1566 check_order(ids1, ord1, 5, "insert without iOrder");
1567
1568 hdi.mask |= HDI_ORDER;
1569 for (i = 0; i < 5; i++)
1570 {
1571 hdi.lParam = i + 5;
1572 hdi.iOrder = rand2[i];
1573 SendMessageA(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
1574 rand(); rand();
1575 }
1576 check_order(ids2, ord2, 10, "insert with order");
1577
1578 hdi.mask = HDI_ORDER;
1579 for (i=0; i<10; i++)
1580 {
1581 hdi.iOrder = rand5[i];
1582 SendMessageA(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
1583 rand(); rand();
1584 }
1585 check_order(ids2, ord3, 10, "setitems changing order");
1586
1587 for (i=0; i<5; i++)
1588 SendMessageA(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
1589 check_order(ids4, ord4, 5, "deleteitem");
1590
1591 DestroyWindow(hWndHeader);
1592 }
1593
1594 static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1595 {
1596 DRAWITEMSTRUCT *di;
1597 switch(msg) {
1598
1599 case WM_NOTIFY:
1600 {
1601 NMHEADERA *hdr = (NMHEADERA*)lParam;
1602 EXPECTEDNOTIFY *expected;
1603 int i;
1604
1605 if (hdr->hdr.code == NM_CUSTOMDRAW)
1606 if (g_CustomDrawProc)
1607 return g_CustomDrawProc(g_CustomDrawCount++, (NMCUSTOMDRAW*)hdr);
1608
1609 for (i=0; i<nUnexpectedNotify; i++)
1610 ok(hdr->hdr.code != unexpectedNotify[i], "Received invalid notify %d\n", hdr->hdr.code);
1611
1612 if (nReceivedNotify >= nExpectedNotify || hdr->hdr.hwndFrom != hWndHeader )
1613 break;
1614
1615 expected = &expectedNotify[nReceivedNotify];
1616 if (hdr->hdr.code != expected->iCode)
1617 break;
1618
1619 nReceivedNotify++;
1620 compare_items(hdr->hdr.code, &expected->hdItem, hdr->pitem, expected->fUnicode);
1621 break;
1622 }
1623
1624 case WM_DRAWITEM:
1625 di = (DRAWITEMSTRUCT *)lParam;
1626 ok(g_DrawItem.CtlType != 0, "Unexpected WM_DRAWITEM\n");
1627 if (g_DrawItem.CtlType == 0) return 0;
1628 g_DrawItemReceived = TRUE;
1629 compare(di->CtlType, g_DrawItem.CtlType, "%d");
1630 compare(di->CtlID, g_DrawItem.CtlID, "%d");
1631 compare(di->hwndItem, g_DrawItem.hwndItem, "%p");
1632 compare(di->itemID, g_DrawItem.itemID, "%d");
1633 compare(di->itemState, g_DrawItem.itemState, "%d");
1634 compare(di->rcItem.left, g_DrawItem.rcItem.left, "%d");
1635 compare(di->rcItem.top, g_DrawItem.rcItem.top, "%d");
1636 compare(di->rcItem.right, g_DrawItem.rcItem.right, "%d");
1637 compare(di->rcItem.bottom, g_DrawItem.rcItem.bottom, "%d");
1638 break;
1639
1640 case WM_DESTROY:
1641 PostQuitMessage(0);
1642 break;
1643
1644 default:
1645 return DefWindowProcA(hWnd, msg, wParam, lParam);
1646 }
1647
1648 return 0L;
1649 }
1650
1651 static BOOL init(void)
1652 {
1653 HMODULE hComctl32;
1654 BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
1655 WNDCLASSA wc;
1656 INITCOMMONCONTROLSEX iccex;
1657 TEXTMETRICA tm;
1658 HFONT hOldFont;
1659 HDC hdc;
1660
1661 hComctl32 = GetModuleHandleA("comctl32.dll");
1662 pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
1663 if (!pInitCommonControlsEx)
1664 {
1665 skip("InitCommonControlsEx() is missing. Skipping the tests\n");
1666 return FALSE;
1667 }
1668
1669 iccex.dwSize = sizeof(iccex);
1670 iccex.dwICC = ICC_USEREX_CLASSES;
1671 pInitCommonControlsEx(&iccex);
1672
1673 wc.style = CS_HREDRAW | CS_VREDRAW;
1674 wc.cbClsExtra = 0;
1675 wc.cbWndExtra = 0;
1676 wc.hInstance = GetModuleHandleA(NULL);
1677 wc.hIcon = NULL;
1678 wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
1679 wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1680 wc.lpszMenuName = NULL;
1681 wc.lpszClassName = "HeaderTestClass";
1682 wc.lpfnWndProc = HeaderTestWndProc;
1683 RegisterClassA(&wc);
1684
1685 /* The height of the header control depends on the height of the system font.
1686 The height of the system font is dpi dependent */
1687 hdc = GetDC(0);
1688 hOldFont = SelectObject(hdc, GetStockObject(SYSTEM_FONT));
1689 GetTextMetricsA(hdc, &tm);
1690 /* 2 dot extra space are needed for the border */
1691 g_customheight = tm.tmHeight + 2;
1692 trace("customdraw height: %d (dpi: %d)\n", g_customheight, GetDeviceCaps(hdc, LOGPIXELSY));
1693 SelectObject(hdc, hOldFont);
1694 ReleaseDC(0, hdc);
1695
1696 hHeaderParentWnd = CreateWindowExA(0, "HeaderTestClass", "Header test", WS_OVERLAPPEDWINDOW,
1697 CW_USEDEFAULT, CW_USEDEFAULT, 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
1698 226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
1699 NULL, NULL, GetModuleHandleA(NULL), 0);
1700 ok(hHeaderParentWnd != NULL, "failed to create parent wnd\n");
1701
1702 ShowWindow(hHeaderParentWnd, SW_SHOW);
1703 return hHeaderParentWnd != NULL;
1704 }
1705
1706 /* maximum 8 items allowed */
1707 static void check_orderarray(HWND hwnd, DWORD start, DWORD set, DWORD expected,
1708 BOOL todo, int line)
1709 {
1710 int count, i;
1711 INT order[8];
1712 DWORD ret, array = 0;
1713
1714 count = SendMessageA(hwnd, HDM_GETITEMCOUNT, 0, 0);
1715
1716 /* initial order */
1717 for(i = 1; i<=count; i++)
1718 order[i-1] = start>>(4*(count-i)) & 0xf;
1719
1720 ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
1721 ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARAY to succeed, got %d\n", ret);
1722
1723 /* new order */
1724 for(i = 1; i<=count; i++)
1725 order[i-1] = set>>(4*(count-i)) & 0xf;
1726 ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
1727 ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARAY to succeed, got %d\n", ret);
1728
1729 /* check actual order */
1730 ret = SendMessageA(hwnd, HDM_GETORDERARRAY, count, (LPARAM)order);
1731 ok_(__FILE__, line)(ret, "Expected HDM_GETORDERARAY to succeed, got %d\n", ret);
1732 for(i = 1; i<=count; i++)
1733 array |= order[i-1]<<(4*(count-i));
1734
1735 todo_wine_if(todo)
1736 ok_(__FILE__, line)(array == expected, "Expected %x, got %x\n", expected, array);
1737 }
1738
1739 static void test_hdm_orderarray(void)
1740 {
1741 HWND hwnd;
1742 INT order[5];
1743 DWORD ret;
1744
1745 hwnd = create_header_control();
1746
1747 /* three items */
1748 addItem(hwnd, 0, NULL);
1749 addItem(hwnd, 1, NULL);
1750 addItem(hwnd, 2, NULL);
1751
1752 ret = SendMessageA(hwnd, HDM_GETORDERARRAY, 3, (LPARAM)order);
1753 if (!ret)
1754 {
1755 win_skip("HDM_GETORDERARRAY not implemented.\n");
1756 DestroyWindow(hwnd);
1757 return;
1758 }
1759
1760 expect(0, order[0]);
1761 expect(1, order[1]);
1762 expect(2, order[2]);
1763
1764 if (0)
1765 {
1766 /* null pointer, crashes native */
1767 ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 3, 0);
1768 expect(FALSE, ret);
1769 }
1770 /* count out of limits */
1771 ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 5, (LPARAM)order);
1772 expect(FALSE, ret);
1773 /* count out of limits */
1774 ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 2, (LPARAM)order);
1775 expect(FALSE, ret);
1776
1777 /* try with out of range item index */
1778 /* (0,1,2)->(1,0,3) => (1,0,2) */
1779 check_orderarray(hwnd, 0x120, 0x103, 0x102, FALSE, __LINE__);
1780 /* (1,0,2)->(3,0,1) => (0,2,1) */
1781 check_orderarray(hwnd, 0x102, 0x301, 0x021, TRUE, __LINE__);
1782 /* (0,2,1)->(2,3,1) => (2,0,1) */
1783 check_orderarray(hwnd, 0x021, 0x231, 0x201, FALSE, __LINE__);
1784
1785 /* (0,1,2)->(0,2,2) => (0,1,2) */
1786 check_orderarray(hwnd, 0x012, 0x022, 0x012, FALSE, __LINE__);
1787
1788 addItem(hwnd, 3, NULL);
1789
1790 /* (0,1,2,3)->(0,1,2,2) => (0,1,3,2) */
1791 check_orderarray(hwnd, 0x0123, 0x0122, 0x0132, FALSE, __LINE__);
1792 /* (0,1,2,3)->(0,1,3,3) => (0,1,2,3) */
1793 check_orderarray(hwnd, 0x0123, 0x0133, 0x0123, FALSE, __LINE__);
1794 /* (0,1,2,3)->(0,4,2,3) => (0,1,2,3) */
1795 check_orderarray(hwnd, 0x0123, 0x0423, 0x0123, FALSE, __LINE__);
1796 /* (0,1,2,3)->(4,0,1,2) => (0,1,3,2) */
1797 check_orderarray(hwnd, 0x0123, 0x4012, 0x0132, TRUE, __LINE__);
1798 /* (0,1,3,2)->(4,0,1,4) => (0,3,1,2) */
1799 check_orderarray(hwnd, 0x0132, 0x4014, 0x0312, TRUE, __LINE__);
1800 /* (0,1,2,3)->(4,1,0,2) => (1,0,3,2) */
1801 check_orderarray(hwnd, 0x0123, 0x4102, 0x1032, TRUE, __LINE__);
1802 /* (0,1,2,3)->(0,1,4,2) => (0,1,2,3) */
1803 check_orderarray(hwnd, 0x0123, 0x0142, 0x0132, FALSE, __LINE__);
1804 /* (0,1,2,3)->(4,4,4,4) => (0,1,2,3) */
1805 check_orderarray(hwnd, 0x0123, 0x4444, 0x0123, FALSE, __LINE__);
1806 /* (0,1,2,3)->(4,4,1,2) => (0,1,3,2) */
1807 check_orderarray(hwnd, 0x0123, 0x4412, 0x0132, TRUE, __LINE__);
1808 /* (0,1,2,3)->(4,4,4,1) => (0,2,3,1) */
1809 check_orderarray(hwnd, 0x0123, 0x4441, 0x0231, TRUE, __LINE__);
1810 /* (0,1,2,3)->(1,4,4,4) => (1,0,2,3) */
1811 check_orderarray(hwnd, 0x0123, 0x1444, 0x1023, FALSE, __LINE__);
1812 /* (0,1,2,3)->(4,2,4,1) => (0,2,3,1) */
1813 check_orderarray(hwnd, 0x0123, 0x4241, 0x0231, FALSE, __LINE__);
1814 /* (0,1,2,3)->(4,2,0,1) => (2,0,3,1) */
1815 check_orderarray(hwnd, 0x0123, 0x4201, 0x2031, TRUE, __LINE__);
1816 /* (3,2,1,0)->(4,2,0,1) => (3,2,0,1) */
1817 check_orderarray(hwnd, 0x3210, 0x4201, 0x3201, FALSE, __LINE__);
1818
1819 DestroyWindow(hwnd);
1820 }
1821
1822 START_TEST(header)
1823 {
1824 HWND parent_hwnd;
1825 ULONG_PTR ctx_cookie;
1826 HANDLE hCtx;
1827
1828 if (!init())
1829 return;
1830
1831 test_header_control();
1832 test_header_order();
1833 test_hdm_orderarray();
1834 test_customdraw();
1835
1836 DestroyWindow(hHeaderParentWnd);
1837
1838 init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1839 parent_hwnd = create_custom_parent_window();
1840 ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_wnd_seq, "create parent windows", FALSE);
1841
1842 test_hdm_index_messages(parent_hwnd);
1843 test_hdm_getitemrect(parent_hwnd);
1844 test_hdm_hittest(parent_hwnd);
1845 test_hdm_layout(parent_hwnd);
1846 test_hdm_ordertoindex(parent_hwnd);
1847 test_hdm_sethotdivider(parent_hwnd);
1848 test_hdm_imageMessages(parent_hwnd);
1849 test_hdm_filterMessages(parent_hwnd);
1850 test_hdm_unicodeformatMessages(parent_hwnd);
1851 test_hdm_bitmapmarginMessages(parent_hwnd);
1852
1853 if (!load_v6_module(&ctx_cookie, &hCtx))
1854 {
1855 DestroyWindow(parent_hwnd);
1856 return;
1857 }
1858
1859 /* comctl32 version 6 tests start here */
1860 test_hdf_fixedwidth(parent_hwnd);
1861 test_hds_nosizing(parent_hwnd);
1862
1863 unload_v6_module(ctx_cookie, hCtx);
1864
1865 DestroyWindow(parent_hwnd);
1866 }
Windows API implementation