dlls/comctl32/tests/header.c

   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 #include <assert.h>
  25
  26 #include "wine/test.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_INSERTITEM, sent|wparam, 0 },
 100     { HDM_INSERTITEM, sent|wparam, 1 },
 101     { HDM_INSERTITEM, sent|wparam, 2 },
 102     { HDM_INSERTITEM, sent|wparam, 3 },
 103     { 0 }
 104 };
 105
 106 static const struct message getItem_seq[] = {
 107     { HDM_GETITEM, sent|wparam, 3 },
 108     { HDM_GETITEM, 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_SETITEM, sent|wparam, 0 },
 131     { HDM_SETITEM, 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     assert(nExpectedNotify < 10);
 219     expectedNotify[nExpectedNotify].iCode = iCode;
 220     expectedNotify[nExpectedNotify].fUnicode = fUnicode;
 221     expectedNotify[nExpectedNotify].hdItem = *lpItem;
 222     nExpectedNotify++;
 223 }
 224
 225 static void dont_expect_notify(INT iCode)
 226 {
 227     assert(nUnexpectedNotify < 10);
 228     unexpectedNotify[nUnexpectedNotify++] = iCode;
 229 }
 230
 231 static BOOL notifies_received(void)
 232 {
 233     BOOL fRet = (nExpectedNotify == nReceivedNotify);
 234     nExpectedNotify = nReceivedNotify = 0;
 235     nUnexpectedNotify = 0;
 236     return fRet;
 237 }
 238
 239 static LONG addItem(HWND hdex, int idx, LPSTR text)
 240 {
 241     HDITEMA hdItem;
 242     hdItem.mask       = HDI_TEXT | HDI_WIDTH;
 243     hdItem.cxy        = 100;
 244     hdItem.pszText    = text;
 245     hdItem.cchTextMax = 0;
 246     return (LONG)SendMessage(hdex, HDM_INSERTITEMA, (WPARAM)idx, (LPARAM)&hdItem);
 247 }
 248
 249 static LONG setItem(HWND hdex, int idx, LPSTR text, BOOL fCheckNotifies)
 250 {
 251     LONG ret;
 252     HDITEMA hdexItem;
 253     hdexItem.mask       = HDI_TEXT;
 254     hdexItem.pszText    = text;
 255     hdexItem.cchTextMax = 0;
 256     if (fCheckNotifies)
 257     {
 258         expect_notify(HDN_ITEMCHANGINGA, FALSE, &hdexItem);
 259         expect_notify(HDN_ITEMCHANGEDA, FALSE, &hdexItem);
 260     }
 261     ret = (LONG)SendMessage(hdex, HDM_SETITEMA, (WPARAM)idx, (LPARAM)&hdexItem);
 262     if (fCheckNotifies)
 263         ok(notifies_received(), "setItem(): not all expected notifies were received\n");
 264     return ret;
 265 }
 266
 267 static LONG setItemUnicodeNotify(HWND hdex, int idx, LPSTR text, LPWSTR wText)
 268 {
 269     LONG ret;
 270     HDITEMA hdexItem;
 271     HDITEMW hdexNotify;
 272     hdexItem.mask       = HDI_TEXT;
 273     hdexItem.pszText    = text;
 274     hdexItem.cchTextMax = 0;
 275
 276     hdexNotify.mask    = HDI_TEXT;
 277     hdexNotify.pszText = wText;
 278
 279     expect_notify(HDN_ITEMCHANGINGW, TRUE, (HDITEMA*)&hdexNotify);
 280     expect_notify(HDN_ITEMCHANGEDW, TRUE, (HDITEMA*)&hdexNotify);
 281     ret = (LONG)SendMessage(hdex, HDM_SETITEMA, (WPARAM)idx, (LPARAM)&hdexItem);
 282     ok(notifies_received(), "setItemUnicodeNotify(): not all expected notifies were received\n");
 283     return ret;
 284 }
 285
 286 static LONG delItem(HWND hdex, int idx)
 287 {
 288     return (LONG)SendMessage(hdex, HDM_DELETEITEM, (WPARAM)idx, 0);
 289 }
 290
 291 static LONG getItemCount(HWND hdex)
 292 {
 293     return (LONG)SendMessage(hdex, HDM_GETITEMCOUNT, 0, 0);
 294 }
 295
 296 static LONG getItem(HWND hdex, int idx, LPSTR textBuffer)
 297 {
 298     HDITEMA hdItem;
 299     hdItem.mask         = HDI_TEXT;
 300     hdItem.pszText      = textBuffer;
 301     hdItem.cchTextMax   = MAX_CHARS;
 302     return (LONG)SendMessage(hdex, HDM_GETITEMA, (WPARAM)idx, (LPARAM)&hdItem);
 303 }
 304
 305 static void addReadDelItem(HWND hdex, HDITEMA *phdiCreate, int maskRead, HDITEMA *phdiRead)
 306 {
 307     ok(SendMessage(hdex, HDM_INSERTITEMA, 0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
 308     ZeroMemory(phdiRead, sizeof(HDITEMA));
 309     phdiRead->mask = maskRead;
 310     ok(SendMessage(hdex, HDM_GETITEMA, 0, (LPARAM)phdiRead)!=0, "Getting item data failed\n");
 311     ok(SendMessage(hdex, HDM_DELETEITEM, 0, 0)!=0, "Deleting item failed\n");
 312 }
 313
 314 static HWND create_header_control (void)
 315 {
 316     HWND handle;
 317     HDLAYOUT hlayout;
 318     RECT rectwin;
 319     WINDOWPOS winpos;
 320
 321     handle = CreateWindowEx(0, WC_HEADER, NULL,
 322                             WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
 323                             0, 0, 0, 0,
 324                             hHeaderParentWnd, NULL, NULL, NULL);
 325     assert(handle);
 326
 327     if (winetest_interactive)
 328         ShowWindow (hHeaderParentWnd, SW_SHOW);
 329
 330     GetClientRect(hHeaderParentWnd,&rectwin);
 331     hlayout.prc = &rectwin;
 332     hlayout.pwpos = &winpos;
 333     SendMessageA(handle,HDM_LAYOUT,0,(LPARAM) &hlayout);
 334     SetWindowPos(handle, winpos.hwndInsertAfter, winpos.x, winpos.y,
 335                  winpos.cx, winpos.cy, 0);
 336
 337     return handle;
 338 }
 339
 340 static void compare_items(INT iCode, HDITEMA *hdi1, HDITEMA *hdi2, BOOL fUnicode)
 341 {
 342     ok(hdi1->mask == hdi2->mask, "Notify %d mask mismatch (%08x != %08x)\n", iCode, hdi1->mask, hdi2->mask);
 343     if (hdi1->mask & HDI_WIDTH)
 344     {
 345         ok(hdi1->cxy == hdi2->cxy, "Notify %d cxy mismatch (%08x != %08x)\n", iCode, hdi1->cxy, hdi2->cxy);
 346     }
 347     if (hdi1->mask & HDI_TEXT)
 348     {
 349         if (hdi1->pszText == LPSTR_TEXTCALLBACKA)
 350         {
 351             ok(hdi1->pszText == LPSTR_TEXTCALLBACKA, "Notify %d - only one item is LPSTR_TEXTCALLBACK\n", iCode);
 352         }
 353         else
 354         if (fUnicode)
 355         {
 356             char buf1[260];
 357             char buf2[260];
 358             WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi1->pszText, -1, buf1, 260, NULL, NULL);
 359             WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi2->pszText, -1, buf2, 260, NULL, NULL);
 360             ok(lstrcmpW((LPWSTR)hdi1->pszText, (LPWSTR)hdi2->pszText)==0,
 361                 "Notify %d text mismatch (L\"%s\" vs L\"%s\")\n",
 362                     iCode, buf1, buf2);
 363         }
 364         else
 365         {
 366             ok(strcmp(hdi1->pszText, hdi2->pszText)==0,
 367                 "Notify %d text mismatch (\"%s\" vs \"%s\")\n",
 368                     iCode, hdi1->pszText, hdi2->pszText);
 369             }
 370     }
 371 }
 372
 373 static char pszFirstItem[]      = "First Item";
 374 static char pszSecondItem[]     = "Second Item";
 375 static char pszThirdItem[]      = "Third Item";
 376 static char pszFourthItem[]     = "Fourth Item";
 377 static char pszReplaceItem[]    = "Replace Item";
 378 static char pszOutOfRangeItem[] = "Out Of Range Item";
 379
 380 static char *str_items[] =
 381     {pszFirstItem, pszSecondItem, pszThirdItem, pszFourthItem, pszReplaceItem, pszOutOfRangeItem};
 382
 383 static char pszUniTestA[]  = "TST";
 384 static WCHAR pszUniTestW[] = {'T','S','T',0};
 385
 386
 387 #define TEST_GET_ITEM(i,c)\
 388 {   res = getItem(hWndHeader, i, buffer);\
 389     ok(res != 0, "Getting item[%d] using valid index failed unexpectedly (%d)\n", i, res);\
 390     ok(strcmp(str_items[c], buffer) == 0, "Getting item[%d] returned \"%s\" expecting \"%s\"\n", i, buffer, str_items[c]);\
 391 }
 392
 393 #define TEST_GET_ITEMCOUNT(i)\
 394 {   res = getItemCount(hWndHeader);\
 395     ok(res == i, "Got Item Count as %d\n", res);\
 396 }
 397
 398 struct subclass_info
 399 {
 400     WNDPROC oldproc;
 401 };
 402
 403 static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 404 {
 405     struct subclass_info *info = (struct subclass_info *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 406     static LONG defwndproc_counter = 0;
 407     LRESULT ret;
 408     struct message msg;
 409
 410     trace("header: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 411     msg.message = message;
 412     msg.flags = sent|wparam|lparam;
 413     if (defwndproc_counter) msg.flags |= defwinproc;
 414     msg.wParam = wParam;
 415     msg.lParam = lParam;
 416     add_message(sequences, HEADER_SEQ_INDEX, &msg);
 417
 418     defwndproc_counter++;
 419     ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
 420     defwndproc_counter--;
 421
 422     return ret;
 423 }
 424
 425 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 426 {
 427     static LONG defwndproc_counter = 0;
 428     LRESULT ret;
 429     struct message msg;
 430
 431     /* do not log painting messages */
 432     if (message != WM_PAINT &&
 433         message != WM_ERASEBKGND &&
 434         message != WM_NCPAINT &&
 435         message != WM_NCHITTEST &&
 436         message != WM_GETTEXT &&
 437         message != WM_GETICON &&
 438         message != WM_DEVICECHANGE)
 439
 440     {
 441         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 442
 443         msg.message = message;
 444         msg.flags = sent|wparam|lparam;
 445         if (defwndproc_counter) msg.flags |= defwinproc;
 446         msg.wParam = wParam;
 447         msg.lParam = lParam;
 448         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 449    }
 450
 451     defwndproc_counter++;
 452     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 453     defwndproc_counter--;
 454
 455     return ret;
 456 }
 457
 458 static BOOL register_parent_wnd_class(void)
 459 {
 460     WNDCLASSA cls;
 461
 462     cls.style = 0;
 463     cls.lpfnWndProc = parent_wnd_proc;
 464     cls.cbClsExtra = 0;
 465     cls.cbWndExtra = 0;
 466     cls.hInstance = GetModuleHandleA(NULL);
 467     cls.hIcon = 0;
 468     cls.hCursor = LoadCursorA(0, IDC_ARROW);
 469     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 470     cls.lpszMenuName = NULL;
 471     cls.lpszClassName = "Header test parent class";
 472     return RegisterClassA(&cls);
 473 }
 474
 475 static HWND create_custom_parent_window(void)
 476 {
 477     if (!register_parent_wnd_class())
 478         return NULL;
 479
 480     return CreateWindowExA(0, "Header test parent class", "Header Message Sequence Testing",
 481                            WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
 482                            672+2*GetSystemMetrics(SM_CXSIZEFRAME),
 483                            226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
 484                            NULL, NULL, GetModuleHandleA(NULL), 0);
 485 }
 486
 487 static HWND create_custom_header_control(HWND hParent, BOOL preloadHeaderItems)
 488 {
 489     struct subclass_info *info;
 490     HWND childHandle;
 491     HDLAYOUT hlayout;
 492     RECT rectwin;
 493     WINDOWPOS winpos;
 494     int retVal;
 495     int loopcnt;
 496     static char firstHeaderItem[] = "Name";
 497     static char secondHeaderItem[] = "Size";
 498     static char *items[] = {secondHeaderItem, firstHeaderItem};
 499     HDITEM hdItem;
 500     hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
 501     hdItem.fmt = HDF_LEFT;
 502     hdItem.cxy = 80;
 503     hdItem.cchTextMax = 260;
 504
 505
 506     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 507     info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
 508     if (!info)
 509          return NULL;
 510
 511     childHandle = CreateWindowEx(0, WC_HEADER, NULL,
 512                            WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
 513                            0, 0, 0, 0,
 514                            hParent, NULL, NULL, NULL);
 515     assert(childHandle);
 516     if (preloadHeaderItems)
 517     {
 518          for ( loopcnt = 0 ; loopcnt < 2 ; loopcnt++ )
 519          {
 520              hdItem.pszText = items[loopcnt];
 521              retVal = SendMessage(childHandle, HDM_INSERTITEM, loopcnt, (LPARAM) &hdItem);
 522              ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
 523           }
 524     }
 525
 526     if (winetest_interactive)
 527        ShowWindow (hParent, SW_SHOW);
 528
 529     GetClientRect(hParent,&rectwin);
 530     hlayout.prc = &rectwin;
 531     hlayout.pwpos = &winpos;
 532     SendMessageA(childHandle,HDM_LAYOUT,0,(LPARAM) &hlayout);
 533     SetWindowPos(childHandle, winpos.hwndInsertAfter, winpos.x, winpos.y,
 534                  winpos.cx, winpos.cy, 0);
 535
 536     info->oldproc = (WNDPROC)SetWindowLongPtrA(childHandle, GWLP_WNDPROC,
 537                                                (LONG_PTR)header_subclass_proc);
 538     SetWindowLongPtrA(childHandle, GWLP_USERDATA, (LONG_PTR)info);
 539     return childHandle;
 540 }
 541
 542 static void check_auto_format(void)
 543 {
 544     HDITEMA hdiCreate;
 545     HDITEMA hdiRead;
 546     static CHAR text[] = "Test";
 547     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
 548
 549     /* Windows implicitly sets some format bits in INSERTITEM */
 550
 551     /* HDF_STRING is automatically set and cleared for no text */
 552     hdiCreate.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;
 553     hdiCreate.pszText = text;
 554     hdiCreate.cxy = 100;
 555     hdiCreate.fmt=HDF_CENTER;
 556     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 557     ok(hdiRead.fmt == (HDF_STRING|HDF_CENTER), "HDF_STRING not set automatically (fmt=%x)\n", hdiRead.fmt);
 558
 559     hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
 560     hdiCreate.pszText = text;
 561     hdiCreate.fmt = HDF_CENTER|HDF_STRING;
 562     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 563     ok(hdiRead.fmt == (HDF_CENTER), "HDF_STRING should be automatically cleared (fmt=%x)\n", hdiRead.fmt);
 564
 565     /* HDF_BITMAP is automatically set and cleared for a NULL bitmap or no bitmap */
 566     hdiCreate.mask = HDI_BITMAP|HDI_WIDTH|HDI_FORMAT;
 567     hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
 568     hdiCreate.fmt = HDF_CENTER;
 569     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 570     ok(hdiRead.fmt == (HDF_BITMAP|HDF_CENTER), "HDF_BITMAP not set automatically (fmt=%x)\n", hdiRead.fmt);
 571     DeleteObject(hdiCreate.hbm);
 572
 573     hdiCreate.hbm = NULL;
 574     hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
 575     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 576     ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for NULL bitmap (fmt=%x)\n", hdiRead.fmt);
 577
 578     hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
 579     hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
 580     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 581     ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for no bitmap (fmt=%x)\n", hdiRead.fmt);
 582
 583     /* HDF_IMAGE is automatically set but not cleared */
 584     hdiCreate.mask = HDI_IMAGE|HDI_WIDTH|HDI_FORMAT;
 585     hdiCreate.iImage = 17;
 586     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 587     ok(hdiRead.fmt == (HDF_IMAGE|HDF_CENTER), "HDF_IMAGE not set automatically (fmt=%x)\n", hdiRead.fmt);
 588
 589     hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
 590     hdiCreate.fmt = HDF_CENTER|HDF_IMAGE;
 591     hdiCreate.iImage = 0;
 592     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 593     ok(hdiRead.fmt == (HDF_CENTER|HDF_IMAGE), "HDF_IMAGE shouldn't be cleared automatically (fmt=%x)\n", hdiRead.fmt);
 594 }
 595
 596 static void check_auto_fields(void)
 597 {
 598     HDITEMA hdiCreate;
 599     HDITEMA hdiRead;
 600     static CHAR text[] = "Test";
 601     LONG res;
 602
 603     /* Windows stores the format, width, lparam even if they are not in the item's mask */
 604     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
 605     hdiCreate.mask = HDI_TEXT;
 606     hdiCreate.cxy = 100;
 607     hdiCreate.pszText = text;
 608     addReadDelItem(hWndHeader, &hdiCreate, HDI_WIDTH, &hdiRead);
 609     TEST_GET_ITEMCOUNT(6);
 610     ok(hdiRead.cxy == hdiCreate.cxy, "cxy should be automatically set\n");
 611
 612     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
 613     hdiCreate.mask = HDI_TEXT;
 614     hdiCreate.pszText = text;
 615     hdiCreate.lParam = 0x12345678;
 616     addReadDelItem(hWndHeader, &hdiCreate, HDI_LPARAM, &hdiRead);
 617     TEST_GET_ITEMCOUNT(6);
 618     ok(hdiRead.lParam == hdiCreate.lParam, "lParam should be automatically set\n");
 619
 620     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
 621     hdiCreate.mask = HDI_TEXT;
 622     hdiCreate.pszText = text;
 623     hdiCreate.fmt = HDF_STRING|HDF_CENTER;
 624     addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
 625     TEST_GET_ITEMCOUNT(6);
 626     ok(hdiRead.fmt == hdiCreate.fmt, "fmt should be automatically set\n");
 627
 628     /* others fields are not set */
 629     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
 630     hdiCreate.mask = HDI_TEXT;
 631     hdiCreate.pszText = text;
 632     hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
 633     addReadDelItem(hWndHeader, &hdiCreate, HDI_BITMAP, &hdiRead);
 634     TEST_GET_ITEMCOUNT(6);
 635     ok(hdiRead.hbm == NULL, "hbm should not be automatically set\n");
 636     DeleteObject(hdiCreate.hbm);
 637
 638     ZeroMemory(&hdiCreate, sizeof(HDITEMA));
 639     hdiCreate.mask = HDI_IMAGE;
 640     hdiCreate.iImage = 17;
 641     hdiCreate.pszText = text;
 642     addReadDelItem(hWndHeader, &hdiCreate, HDI_TEXT, &hdiRead);
 643     TEST_GET_ITEMCOUNT(6);
 644     ok(hdiRead.pszText==NULL, "pszText shouldn't be automatically set\n");
 645
 646     /* field from comctl >4.0 not tested as the system probably won't touch them */
 647 }
 648
 649 static void check_mask(void)
 650 {
 651     HDITEMA hdi;
 652     static CHAR text[] = "ABC";
 653     LRESULT ret;
 654
 655     /* don't create items if the mask is zero */
 656     ZeroMemory(&hdi, sizeof(hdi));
 657     hdi.mask = 0;
 658     hdi.cxy = 200;
 659     hdi.pszText = text;
 660     hdi.fmt = 0;
 661     hdi.iOrder = 0;
 662     hdi.lParam = 17;
 663     hdi.cchTextMax = 260;
 664     ret = SendMessage(hWndHeader, HDM_INSERTITEM, 0, (LPARAM)&hdi);
 665     ok(ret == -1, "Creating an item with a zero mask should have failed\n");
 666     if (ret != -1) SendMessage(hWndHeader, HDM_DELETEITEM, 0, 0);
 667
 668     /* with a non-zero mask creation will succeed */
 669     ZeroMemory(&hdi, sizeof(hdi));
 670     hdi.mask = HDI_LPARAM;
 671     ret = SendMessage(hWndHeader, HDM_INSERTITEM, 0, (LPARAM)&hdi);
 672     ok(ret != -1, "Adding item with non-zero mask failed\n");
 673     if (ret != -1)
 674         SendMessage(hWndHeader, HDM_DELETEITEM, 0, 0);
 675
 676     /* in SETITEM if the mask contains a unknown bit, it is ignored */
 677     ZeroMemory(&hdi, sizeof(hdi));
 678     hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
 679     hdi.lParam = 133;
 680     hdi.iImage = 17;
 681     ret = SendMessage(hWndHeader, HDM_INSERTITEM, 0, (LPARAM)&hdi);
 682     ok(ret != -1, "Adding item failed\n");
 683
 684     if (ret != -1)
 685     {
 686         /* check result */
 687         ZeroMemory(&hdi, sizeof(hdi));
 688         hdi.mask = HDI_LPARAM | HDI_IMAGE;
 689         SendMessage(hWndHeader, HDM_GETITEM, 0, (LPARAM)&hdi);
 690         ok(hdi.lParam == 133, "comctl32 4.0 field not set\n");
 691         ok(hdi.iImage == 17, "comctl32 >4.0 field not set\n");
 692
 693         /* but in GETITEM if an unknown bit is set, comctl32 uses only version 4.0 fields */
 694         ZeroMemory(&hdi, sizeof(hdi));
 695         hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
 696         SendMessage(hWndHeader, HDM_GETITEM, 0, (LPARAM)&hdi);
 697         ok(hdi.lParam == 133, "comctl32 4.0 field not read\n");
 698         ok(hdi.iImage == 0, "comctl32 >4.0 field shouldn't be read\n");
 699
 700         SendMessage(hWndHeader, HDM_DELETEITEM, 0, 0);
 701     }
 702 }
 703
 704 static void test_header_control (void)
 705 {
 706     LONG res;
 707     static char buffer[MAX_CHARS];
 708     int i;
 709
 710     hWndHeader = create_header_control ();
 711
 712     for (i = 3; i >= 0; i--)
 713     {
 714         TEST_GET_ITEMCOUNT(3-i);
 715         res = addItem(hWndHeader, 0, str_items[i]);
 716         ok(res == 0, "Adding simple item failed (%d)\n", res);
 717     }
 718
 719     TEST_GET_ITEMCOUNT(4);
 720     res = addItem(hWndHeader, 99, str_items[i+1]);
 721     ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
 722     TEST_GET_ITEMCOUNT(5);
 723     res = addItem(hWndHeader, 5, str_items[i+1]);
 724     ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
 725     TEST_GET_ITEMCOUNT(6);
 726
 727     for (i = 0; i < 4; i++) { TEST_GET_ITEM(i,i); TEST_GET_ITEMCOUNT(6); }
 728
 729     res=getItem(hWndHeader, 99, buffer);
 730     ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
 731     res=getItem(hWndHeader, 5, buffer);
 732     ok(res == 1, "Getting Out of Range item should fail with 1 (%d), got %s\n", res,buffer);
 733     res=getItem(hWndHeader, -2, buffer);
 734     ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
 735
 736     if (winetest_interactive)
 737     {
 738         UpdateWindow(hHeaderParentWnd);
 739         UpdateWindow(hWndHeader);
 740     }
 741
 742     TEST_GET_ITEMCOUNT(6);
 743     res=setItem(hWndHeader, 99, str_items[5], FALSE);
 744     ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
 745     res=setItem(hWndHeader, 5, str_items[5], TRUE);
 746     ok(res == 1, "Setting Out of Range item should fail with 1 (%d)\n", res);
 747     res=setItem(hWndHeader, -2, str_items[5], FALSE);
 748     ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
 749     TEST_GET_ITEMCOUNT(6);
 750
 751     for (i = 0; i < 4; i++)
 752     {
 753         res = setItem(hWndHeader, i, str_items[4], TRUE);
 754         ok(res != 0, "Setting %d item failed (%d)\n", i+1, res);
 755         TEST_GET_ITEM(i, 4);
 756         TEST_GET_ITEMCOUNT(6);
 757     }
 758
 759     SendMessageA(hWndHeader, HDM_SETUNICODEFORMAT, (WPARAM)TRUE, 0);
 760     setItemUnicodeNotify(hWndHeader, 3, pszUniTestA, pszUniTestW);
 761     SendMessageA(hWndHeader, WM_NOTIFYFORMAT, (WPARAM)hHeaderParentWnd, (LPARAM)NF_REQUERY);
 762     setItem(hWndHeader, 3, str_items[4], TRUE);
 763
 764     dont_expect_notify(HDN_GETDISPINFOA);
 765     dont_expect_notify(HDN_GETDISPINFOW);
 766     addItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA);
 767     setItem(hWndHeader, 0, str_items[4], TRUE);
 768     /* unexpected notifies cleared by notifies_received in setItem */
 769     dont_expect_notify(HDN_GETDISPINFOA);
 770     dont_expect_notify(HDN_GETDISPINFOW);
 771     setItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA, TRUE);
 772     /* unexpected notifies cleared by notifies_received in setItem */
 773     delItem(hWndHeader, 0);
 774
 775     check_auto_format();
 776     TEST_GET_ITEMCOUNT(6);
 777     check_auto_fields();
 778     TEST_GET_ITEMCOUNT(6);
 779     check_mask();
 780     TEST_GET_ITEMCOUNT(6);
 781
 782     res = delItem(hWndHeader, 5);
 783     ok(res == 1, "Deleting Out of Range item should fail with 1 (%d)\n", res);
 784     res = delItem(hWndHeader, -2);
 785     ok(res == 0, "Deleting Out of Range item should fail with 0 (%d)\n", res);
 786     TEST_GET_ITEMCOUNT(5);
 787
 788     res = delItem(hWndHeader, 3);
 789     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
 790     TEST_GET_ITEMCOUNT(4);
 791     res = delItem(hWndHeader, 0);
 792     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
 793     TEST_GET_ITEMCOUNT(3);
 794     res = delItem(hWndHeader, 0);
 795     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
 796     TEST_GET_ITEMCOUNT(2);
 797     res = delItem(hWndHeader, 0);
 798     ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
 799     TEST_GET_ITEMCOUNT(1);
 800
 801     DestroyWindow(hWndHeader);
 802 }
 803
 804 static void test_hdm_getitemrect(HWND hParent)
 805 {
 806
 807     HWND hChild;
 808     RECT rect;
 809     int retVal;
 810
 811     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 812     hChild = create_custom_header_control(hParent, TRUE);
 813     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 814                                     "adder header control to parent", FALSE);
 815
 816     retVal = SendMessage(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
 817     ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
 818     /* check bounding rectangle information of 2nd header item */
 819     expect(80, rect.left);
 820     expect(0, rect.top);
 821     expect(160, rect.right);
 822     expect(g_customheight, rect.bottom);
 823
 824     retVal = SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
 825
 826     ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
 827     /* check bounding rectangle information of 1st header item */
 828     expect(0, rect.left);
 829     expect(0, rect.top);
 830
 831     expect(80, rect.right);
 832     expect(g_customheight, rect.bottom);
 833
 834     retVal = SendMessage(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
 835     ok(retVal == 0, "Getting rect of nonexistent item should return 0, got %d\n", retVal);
 836
 837     ok_sequence(sequences, HEADER_SEQ_INDEX, getItemRect_seq, "getItemRect sequence testing", FALSE);
 838     DestroyWindow(hChild);
 839 }
 840
 841 static void test_hdm_layout(HWND hParent)
 842 {
 843     HWND hChild;
 844     int retVal;
 845     RECT rect;
 846     HDLAYOUT hdLayout;
 847     WINDOWPOS windowPos;
 848     hdLayout.prc = &rect;
 849     hdLayout.pwpos = &windowPos;
 850
 851     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 852     hChild = create_custom_header_control(hParent, TRUE);
 853     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 854                                     "adder header control to parent", FALSE);
 855
 856     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 857     retVal = SendMessage(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
 858     expect(TRUE, retVal);
 859
 860     ok_sequence(sequences, HEADER_SEQ_INDEX, layout_seq, "layout sequence testing", FALSE);
 861
 862     DestroyWindow(hChild);
 863 }
 864
 865 static void test_hdm_ordertoindex(HWND hParent)
 866 {
 867     HWND hChild;
 868     int retVal;
 869
 870     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 871     hChild = create_custom_header_control(hParent, TRUE);
 872     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 873                                     "adder header control to parent", FALSE);
 874
 875     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 876     retVal = SendMessage(hChild, HDM_ORDERTOINDEX, 1, 0);
 877     expect(1, retVal);
 878
 879     ok_sequence(sequences, HEADER_SEQ_INDEX, orderToIndex_seq, "orderToIndex sequence testing", FALSE);
 880     DestroyWindow(hChild);
 881 }
 882
 883 static void test_hdm_hittest(HWND hParent)
 884 {
 885     HWND hChild;
 886     int retVal;
 887     POINT pt;
 888     HDHITTESTINFO hdHitTestInfo;
 889     const int firstItemRightBoundary = 80;
 890     const int secondItemRightBoundary = 160;
 891     const int bottomBoundary = g_customheight;
 892
 893     pt.x = firstItemRightBoundary - 1;
 894     pt.y = bottomBoundary - 1;
 895     hdHitTestInfo.pt = pt;
 896
 897
 898     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 899     hChild = create_custom_header_control(hParent, TRUE);
 900     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 901                                     "adder header control to parent", FALSE);
 902
 903     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 904     retVal = SendMessage(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
 905     expect(0, retVal);
 906     expect(0, hdHitTestInfo.iItem);
 907     expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
 908
 909     pt.x = secondItemRightBoundary - 1;
 910     pt.y = bottomBoundary - 1;
 911     hdHitTestInfo.pt = pt;
 912     retVal = SendMessage(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
 913     expect(1, retVal);
 914     expect(1, hdHitTestInfo.iItem);
 915     expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
 916
 917     pt.x = secondItemRightBoundary;
 918     pt.y = bottomBoundary + 1;
 919     hdHitTestInfo.pt = pt;
 920     retVal = SendMessage(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
 921     expect(-1, retVal);
 922     expect(-1, hdHitTestInfo.iItem);
 923     expect(HHT_BELOW, hdHitTestInfo.flags);
 924
 925     ok_sequence(sequences, HEADER_SEQ_INDEX, hittest_seq, "hittest sequence testing", FALSE);
 926
 927     DestroyWindow(hChild);
 928 }
 929
 930 static void test_hdm_sethotdivider(HWND hParent)
 931 {
 932     HWND hChild;
 933     int retVal;
 934     /*  low word: x coordinate = 5
 935      *  high word:  y coordinate = 5
 936      */
 937
 938     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 939     hChild = create_custom_header_control(hParent, TRUE);
 940     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 941                                     "adder header control to parent", FALSE);
 942
 943     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 944     retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, TRUE, MAKELPARAM(5, 5));
 945     expect(0, retVal);
 946
 947     retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
 948     expect(100, retVal);
 949     retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
 950     expect(1, retVal);
 951     if (winetest_interactive)
 952        ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_interactive,
 953                    "setHotDivider sequence testing", TRUE);
 954     else
 955        ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_noninteractive,
 956                    "setHotDivider sequence testing", FALSE);
 957
 958     DestroyWindow(hChild);
 959 }
 960
 961 static void test_hdm_imageMessages(HWND hParent)
 962 {
 963     HIMAGELIST hImageList = ImageList_Create (4, 4, 0, 1, 0);
 964     HIMAGELIST hImageListRetVal;
 965     HWND hChild;
 966
 967     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 968     hChild = create_custom_header_control(hParent, TRUE);
 969     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 970                                     "adder header control to parent", FALSE);
 971
 972     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 973
 974     hImageListRetVal = (HIMAGELIST) SendMessage(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
 975     ok(hImageListRetVal == NULL, "Expected NULL, got %p\n", hImageListRetVal);
 976
 977     hImageListRetVal = (HIMAGELIST) SendMessage(hChild, HDM_GETIMAGELIST, 0, 0);
 978     ok(hImageListRetVal != NULL, "Expected non-NULL handle, got %p\n", hImageListRetVal);
 979
 980     hImageListRetVal = (HIMAGELIST) SendMessage(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
 981     ok(hImageListRetVal != NULL, "Expected non-NULL handle, got %p\n", hImageListRetVal);
 982
 983     ok_sequence(sequences, HEADER_SEQ_INDEX, imageMessages_seq, "imageMessages sequence testing", FALSE);
 984
 985     DestroyWindow(hChild);
 986 }
 987
 988 static void test_hdm_filterMessages(HWND hParent)
 989 {
 990     HWND hChild;
 991     int retVal, timeout;
 992
 993     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 994     hChild = create_custom_header_control(hParent, TRUE);
 995     assert(hChild);
 996     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
 997                                     "adder header control to parent", FALSE);
 998
 999     timeout = SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1000     SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
1001
1002     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1003
1004     /* msdn incorrectly states that return value
1005      * is the index of the filter control being
1006      * modified. The sendMessage here should
1007      * return previous filter timeout value
1008      */
1009
1010     retVal = SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1011     expect(timeout, retVal);
1012
1013     todo_wine
1014     {
1015         retVal = SendMessage(hChild, HDM_CLEARFILTER, 0, 1);
1016         if (retVal == 0)
1017             win_skip("HDM_CLEARFILTER needs 5.80\n");
1018         else
1019             expect(1, retVal);
1020
1021         retVal = SendMessage(hChild, HDM_EDITFILTER, 1, 0);
1022         if (retVal == 0)
1023             win_skip("HDM_EDITFILTER needs 5.80\n");
1024         else
1025             expect(1, retVal);
1026     }
1027     if (winetest_interactive)
1028          ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_interactive,
1029                      "filterMessages sequence testing", TRUE);
1030     else
1031          ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_noninteractive,
1032                      "filterMessages sequence testing", FALSE);
1033     /* Some Win9x versions don't send a WM_KILLFOCUS.
1034      * Set the focus explicitly to the parent to avoid a crash.
1035      */
1036     SetFocus(hParent);
1037     DestroyWindow(hChild);
1038
1039 }
1040
1041 static void test_hdm_unicodeformatMessages(HWND hParent)
1042 {
1043     HWND hChild;
1044     int retVal;
1045
1046     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1047     hChild = create_custom_header_control(hParent, TRUE);
1048     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1049                                     "adder header control to parent", FALSE);
1050
1051     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1052     retVal = SendMessage(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
1053     expect(0, retVal);
1054     retVal = SendMessage(hChild, HDM_GETUNICODEFORMAT, 0, 0);
1055     expect(1, retVal);
1056
1057     ok_sequence(sequences, HEADER_SEQ_INDEX, unicodeformatMessages_seq,
1058                      "unicodeformatMessages sequence testing", FALSE);
1059     DestroyWindow(hChild);
1060 }
1061
1062 static void test_hdm_bitmapmarginMessages(HWND hParent)
1063 {
1064     HWND hChild;
1065     int retVal;
1066
1067     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1068     hChild = create_custom_header_control(hParent, TRUE);
1069     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1070                                     "adder header control to parent", FALSE);
1071
1072     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1073     retVal = SendMessage(hChild, HDM_GETBITMAPMARGIN, 0, 0);
1074     if (retVal == 0)
1075         win_skip("HDM_GETBITMAPMARGIN needs 5.80\n");
1076     else
1077         expect(6, retVal);
1078
1079     ok_sequence(sequences, HEADER_SEQ_INDEX, bitmapmarginMessages_seq,
1080                       "bitmapmarginMessages sequence testing", FALSE);
1081     DestroyWindow(hChild);
1082 }
1083
1084 static void test_hdm_index_messages(HWND hParent)
1085 {
1086
1087     HWND hChild;
1088     int retVal;
1089     int loopcnt;
1090     int strcmpResult;
1091     int iSize;
1092     static const int lpiarray[2] = {1, 0};
1093     static int lpiarrayReceived[2];
1094     static char firstHeaderItem[] = "Name";
1095     static char secondHeaderItem[] = "Size";
1096     static char thirdHeaderItem[] = "Type";
1097     static char fourthHeaderItem[] = "Date Modified";
1098     static char *items[] = {firstHeaderItem, secondHeaderItem, thirdHeaderItem, fourthHeaderItem};
1099     RECT rect;
1100     HDITEM hdItem;
1101     hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
1102     hdItem.fmt = HDF_LEFT;
1103     hdItem.cxy = 80;
1104     hdItem.cchTextMax = 260;
1105
1106     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1107     hChild = create_custom_header_control(hParent, FALSE);
1108     if (winetest_interactive)
1109          ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq_interactive,
1110                                               "adder header control to parent", TRUE);
1111     else
1112          ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1113                                      "adder header control to parent", FALSE);
1114     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1115     for ( loopcnt = 0 ; loopcnt < 4 ; loopcnt++ )
1116     {
1117       hdItem.pszText = items[loopcnt];
1118       retVal = SendMessage(hChild, HDM_INSERTITEM, loopcnt, (LPARAM) &hdItem);
1119       ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), 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 = SendMessage(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1126     ok(retVal == TRUE, "Deleting item 3 should return TRUE, got %d\n", retVal);
1127     retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
1128     ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
1129
1130     retVal = SendMessage(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1131     ok(retVal == FALSE, "Deleting already-deleted item should return FALSE, got %d\n", retVal);
1132     retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
1133     ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
1134
1135     retVal = SendMessage(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
1136     ok(retVal == TRUE, "Deleting item 2 should return TRUE, got %d\n", retVal);
1137     retVal = SendMessage(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     retVal = SendMessage(hChild, HDM_GETITEM, 3, (LPARAM) &hdItem);
1146     ok(retVal == FALSE, "Getting already-deleted item should return FALSE, got %d\n", retVal);
1147
1148     retVal = SendMessage(hChild, HDM_GETITEM, 0, (LPARAM) &hdItem);
1149     ok(retVal == TRUE, "Getting the 1st header item should return TRUE, got %d\n", retVal);
1150
1151     ok_sequence(sequences, HEADER_SEQ_INDEX, getItem_seq, "getItem sequence testing", FALSE);
1152
1153     /* check if the item is the right one */
1154     strcmpResult =  strcmp(hdItem.pszText, firstHeaderItem);
1155     expect(0, strcmpResult);
1156     expect(80, hdItem.cxy);
1157
1158     iSize = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
1159
1160     /* item should be updated just after accepting new array */
1161     ShowWindow(hChild, SW_HIDE);
1162     retVal = SendMessage(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1163     expect(TRUE, retVal);
1164     rect.left = 0;
1165     retVal = SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
1166     expect(TRUE, retVal);
1167     ok(rect.left != 0, "Expected updated rectangle\n");
1168
1169     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1170
1171     retVal = SendMessage(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1172     ok(retVal == TRUE, "Setting header items order should return TRUE, got %d\n", retVal);
1173
1174     retVal = SendMessage(hChild, HDM_GETORDERARRAY, iSize, (LPARAM) lpiarrayReceived);
1175     ok(retVal == TRUE, "Getting header items order should return TRUE, got %d\n", retVal);
1176
1177     ok_sequence(sequences, HEADER_SEQ_INDEX, orderArray_seq, "set_get_orderArray sequence testing", FALSE);
1178
1179     /* check if the array order is set correctly and the size of the array is correct. */
1180     expect(2, iSize);
1181     expect(lpiarray[0], lpiarrayReceived[0]);
1182     expect(lpiarray[1], lpiarrayReceived[1]);
1183
1184     hdItem.mask = HDI_FORMAT;
1185     hdItem.fmt = HDF_CENTER | HDF_STRING;
1186
1187     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1188
1189     retVal = SendMessage(hChild, HDM_SETITEM, 0, (LPARAM) &hdItem);
1190     ok(retVal == TRUE, "Aligning 1st header item to center should return TRUE, got %d\n", retVal);
1191     hdItem.fmt = HDF_RIGHT | HDF_STRING;
1192     retVal = SendMessage(hChild, HDM_SETITEM, 1, (LPARAM) &hdItem);
1193     ok(retVal == TRUE, "Aligning 2nd header item to right should return TRUE, got %d\n", retVal);
1194
1195     ok_sequence(sequences, HEADER_SEQ_INDEX, setItem_seq, "setItem sequence testing", FALSE);
1196     DestroyWindow(hChild);
1197 }
1198
1199 #define TEST_NMCUSTOMDRAW(draw_stage, item_spec, lparam, _left, _top, _right, _bottom) \
1200     ok(nm->dwDrawStage == draw_stage, "Invalid dwDrawStage %d vs %d\n", draw_stage, nm->dwDrawStage); \
1201     if (item_spec != -1) \
1202         ok(nm->dwItemSpec == item_spec, "Invalid dwItemSpec %d vs %ld\n", item_spec, nm->dwItemSpec); \
1203     ok(nm->lItemlParam == lparam, "Invalid lItemlParam %d vs %ld\n", lparam, nm->lItemlParam); \
1204     ok((nm->rc.top == _top && nm->rc.bottom == _bottom && nm->rc.left == _left && nm->rc.right == _right) || \
1205         broken(draw_stage != CDDS_ITEMPREPAINT), /* comctl32 < 5.80 */ \
1206         "Invalid rect (%d,%d) (%d,%d) vs (%d,%d) (%d,%d)\n", _left, _top, _right, _bottom, \
1207         nm->rc.left, nm->rc.top, nm->rc.right, nm->rc.bottom);
1208
1209 static LRESULT customdraw_1(int n, NMCUSTOMDRAW *nm)
1210 {
1211     if (nm == NULL) {  /* test ended */
1212         ok(n==1, "NM_CUSTOMDRAW messages: %d, expected: 1\n", n);
1213         return 0;
1214     }
1215
1216     switch (n)
1217     {
1218     case 0:
1219         /* don't test dwItemSpec - it's 0 no comctl5 but 1308756 on comctl6 */
1220         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1221         return 0;
1222     }
1223
1224     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1225     return -1;
1226 }
1227
1228 static LRESULT customdraw_2(int n, NMCUSTOMDRAW *nm)
1229 {
1230     if (nm == NULL) {  /* test ended */
1231         ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
1232         return 0;
1233     }
1234
1235     switch (n)
1236     {
1237     case 0:
1238         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1239         return CDRF_NOTIFYITEMDRAW;
1240     case 1:
1241         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1242         return 0;
1243     case 2:
1244         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1245         return 0;
1246     case 3:
1247         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1248         return 0;
1249     }
1250
1251     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1252     return 0;
1253 }
1254
1255 static LRESULT customdraw_3(int n, NMCUSTOMDRAW *nm)
1256 {
1257     if (nm == NULL) {  /* test ended */
1258         ok(n==5, "NM_CUSTOMDRAW messages: %d, expected: 5\n", n);
1259         return 0;
1260     }
1261
1262     switch (n)
1263     {
1264     case 0:
1265         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1266         return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTERASE|CDRF_NOTIFYPOSTPAINT|CDRF_SKIPDEFAULT;
1267     case 1:
1268         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1269         return 0;
1270     case 2:
1271         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1272         return 0;
1273     case 3:
1274         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1275         return 0;
1276     case 4:
1277         TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1278         return 0;
1279     }
1280
1281     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1282     return 0;
1283 }
1284
1285
1286 static LRESULT customdraw_4(int n, NMCUSTOMDRAW *nm)
1287 {
1288     if (nm == NULL) {  /* test ended */
1289         ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
1290         return 0;
1291     }
1292
1293     switch (n)
1294     {
1295     case 0:
1296         TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1297         return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTPAINT;
1298     case 1:
1299         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1300         return 0;
1301     case 2:
1302         TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1303         return 0;
1304     case 3:
1305         TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1306         return 0;
1307     }
1308
1309     ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1310     return 0;
1311 }
1312
1313 static void run_customdraw_scenario(CUSTOMDRAWPROC proc)
1314 {
1315     g_CustomDrawProc = proc;
1316     g_CustomDrawCount = 0;
1317     InvalidateRect(hWndHeader, NULL, TRUE);
1318     UpdateWindow(hWndHeader);
1319     proc(g_CustomDrawCount, NULL);
1320     g_CustomDrawProc = NULL;
1321 }
1322
1323 static void test_customdraw(void)
1324 {
1325     int i;
1326     HDITEM item;
1327     RECT rect;
1328     CHAR name[] = "Test";
1329     hWndHeader = create_header_control();
1330     GetClientRect(hWndHeader, &rect);
1331     ok(rect.right - rect.left == 670 && rect.bottom - rect.top == g_customheight,
1332         "Tests will fail as header size is %dx%d instead of 670x%d\n",
1333         rect.right - rect.left, rect.bottom - rect.top, g_customheight);
1334
1335     for (i = 0; i < 3; i++)
1336     {
1337         ZeroMemory(&item, sizeof(item));
1338         item.mask = HDI_TEXT|HDI_WIDTH;
1339         item.cxy = 50*(i+1);
1340         item.pszText = name;
1341         item.lParam = i*5;
1342         SendMessage(hWndHeader, HDM_INSERTITEM, i, (LPARAM)&item);
1343     }
1344
1345     run_customdraw_scenario(customdraw_1);
1346     run_customdraw_scenario(customdraw_2);
1347     run_customdraw_scenario(customdraw_3);
1348
1349     ZeroMemory(&item, sizeof(item));
1350     item.mask = HDI_FORMAT;
1351     item.fmt = HDF_OWNERDRAW;
1352     SendMessage(hWndHeader, HDM_SETITEM, 1, (LPARAM)&item);
1353     g_DrawItem.CtlID = 0;
1354     g_DrawItem.CtlType = ODT_HEADER;
1355     g_DrawItem.hwndItem = hWndHeader;
1356     g_DrawItem.itemID = 1;
1357     g_DrawItem.itemState = 0;
1358     SendMessage(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
1359     run_customdraw_scenario(customdraw_4);
1360     ok(g_DrawItemReceived, "WM_DRAWITEM not received\n");
1361     DestroyWindow(hWndHeader);
1362     hWndHeader = NULL;
1363     g_DrawItem.CtlType = 0;
1364     g_DrawItemReceived = FALSE;
1365 }
1366
1367 static void check_order(const int expected_id[], const int expected_order[],
1368                         int count, const char *type)
1369 {
1370     int i;
1371     HDITEMA hdi;
1372
1373     ok(getItemCount(hWndHeader) == count, "Invalid item count in order tests\n");
1374     for (i = 0; i < count; i++)
1375     {
1376         hdi.mask = HDI_LPARAM|HDI_ORDER;
1377         SendMessage(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
1378         ok(hdi.lParam == expected_id[i],
1379             "Invalid item ids after '%s'- item %d has lParam %d\n", type, i, (int)hdi.lParam);
1380         ok(hdi.iOrder == expected_order[i],
1381             "Invalid item order after '%s'- item %d has iOrder %d\n", type, i, hdi.iOrder);
1382     }
1383 }
1384
1385 static void test_header_order (void)
1386 {
1387     const int rand1[] = {0, 1, 1, 0, 4};
1388     const int rand2[] = {4, 5, 6, 7, 4};
1389     const int rand3[] = {5, 5, 1, 6, 1};
1390     const int rand4[] = {1, 5, 2, 7, 6, 1, 4, 2, 3, 2};
1391     const int rand5[] = {7, 8, 5, 6, 7, 2, 1, 9, 10, 10};
1392     const int rand6[] = {2, 8, 3, 4, 0};
1393
1394     const int ids1[] = {3, 0, 2, 1, 4};
1395     const int ord1[] = {0, 1, 2, 3, 4};
1396     const int ids2[] = {3, 9, 7, 0, 2, 1, 4, 8, 6, 5};
1397     const int ord2[] = {0, 4, 7, 1, 2, 3, 9, 8, 6, 5};
1398     const int ord3[] = {0, 3, 9, 2, 1, 8, 7, 6, 5, 4};
1399     const int ids4[] = {9, 0, 1, 8, 6};
1400     const int ord4[] = {1, 0, 4, 3, 2};
1401
1402     char buffer[20];
1403     HDITEMA hdi;
1404     int i;
1405
1406     hWndHeader = create_header_control();
1407
1408     ZeroMemory(&hdi, sizeof(HDITEMA));
1409     hdi.mask = HDI_TEXT | HDI_LPARAM;
1410     hdi.pszText = buffer;
1411     strcpy(buffer, "test");
1412
1413     for (i = 0; i < 5; i++)
1414     {
1415         hdi.lParam = i;
1416         SendMessage(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
1417         rand();
1418     }
1419     check_order(ids1, ord1, 5, "insert without iOrder");
1420
1421     hdi.mask |= HDI_ORDER;
1422     for (i = 0; i < 5; i++)
1423     {
1424         hdi.lParam = i + 5;
1425         hdi.iOrder = rand2[i];
1426         SendMessage(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
1427         rand(); rand();
1428     }
1429     check_order(ids2, ord2, 10, "insert with order");
1430
1431     hdi.mask = HDI_ORDER;
1432     for (i=0; i<10; i++)
1433     {
1434         hdi.iOrder = rand5[i];
1435         SendMessage(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
1436         rand(); rand();
1437     }
1438     check_order(ids2, ord3, 10, "setitems changing order");
1439
1440     for (i=0; i<5; i++)
1441         SendMessage(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
1442     check_order(ids4, ord4, 5, "deleteitem");
1443
1444     DestroyWindow(hWndHeader);
1445 }
1446
1447 static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1448 {
1449     DRAWITEMSTRUCT *di;
1450     switch(msg) {
1451
1452     case WM_NOTIFY:
1453     {
1454         NMHEADERA *hdr = (NMHEADER *)lParam;
1455         EXPECTEDNOTIFY *expected;
1456         int i;
1457
1458         if (hdr->hdr.code == NM_CUSTOMDRAW)
1459             if (g_CustomDrawProc)
1460                 return g_CustomDrawProc(g_CustomDrawCount++, (NMCUSTOMDRAW*)hdr);
1461
1462         for (i=0; i<nUnexpectedNotify; i++)
1463             ok(hdr->hdr.code != unexpectedNotify[i], "Received invalid notify %d\n", hdr->hdr.code);
1464
1465         if (nReceivedNotify >= nExpectedNotify || hdr->hdr.hwndFrom != hWndHeader )
1466             break;
1467
1468         expected = &expectedNotify[nReceivedNotify];
1469         if (hdr->hdr.code != expected->iCode)
1470             break;
1471
1472         nReceivedNotify++;
1473         compare_items(hdr->hdr.code, &expected->hdItem, hdr->pitem, expected->fUnicode);
1474         break;
1475     }
1476
1477     case WM_DRAWITEM:
1478         di = (DRAWITEMSTRUCT *)lParam;
1479         ok(g_DrawItem.CtlType != 0, "Unexpected WM_DRAWITEM\n");
1480         if (g_DrawItem.CtlType == 0) return 0;
1481         g_DrawItemReceived = TRUE;
1482         compare(di->CtlType,   g_DrawItem.CtlType, "%d");
1483         compare(di->CtlID,     g_DrawItem.CtlID, "%d");
1484         compare(di->hwndItem,  g_DrawItem.hwndItem, "%p");
1485         compare(di->itemID,    g_DrawItem.itemID, "%d");
1486         compare(di->itemState, g_DrawItem.itemState, "%d");
1487         compare(di->rcItem.left,   g_DrawItem.rcItem.left, "%d");
1488         compare(di->rcItem.top,    g_DrawItem.rcItem.top, "%d");
1489         compare(di->rcItem.right,  g_DrawItem.rcItem.right, "%d");
1490         compare(di->rcItem.bottom, g_DrawItem.rcItem.bottom, "%d");
1491         break;
1492
1493     case WM_DESTROY:
1494         PostQuitMessage(0);
1495         break;
1496
1497     default:
1498         return DefWindowProcA(hWnd, msg, wParam, lParam);
1499     }
1500
1501     return 0L;
1502 }
1503
1504 static int init(void)
1505 {
1506     HMODULE hComctl32;
1507     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
1508     WNDCLASSA wc;
1509     INITCOMMONCONTROLSEX iccex;
1510     TEXTMETRICA tm;
1511     HFONT hOldFont;
1512     HDC hdc;
1513
1514     hComctl32 = GetModuleHandleA("comctl32.dll");
1515     pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
1516     if (!pInitCommonControlsEx)
1517     {
1518         skip("InitCommonControlsEx() is missing. Skipping the tests\n");
1519         return 0;
1520     }
1521
1522     iccex.dwSize = sizeof(iccex);
1523     iccex.dwICC  = ICC_USEREX_CLASSES;
1524     pInitCommonControlsEx(&iccex);
1525
1526     wc.style = CS_HREDRAW | CS_VREDRAW;
1527     wc.cbClsExtra = 0;
1528     wc.cbWndExtra = 0;
1529     wc.hInstance = GetModuleHandleA(NULL);
1530     wc.hIcon = NULL;
1531     wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
1532     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1533     wc.lpszMenuName = NULL;
1534     wc.lpszClassName = "HeaderTestClass";
1535     wc.lpfnWndProc = HeaderTestWndProc;
1536     RegisterClassA(&wc);
1537
1538     /* The height of the header control depends on the height of the system font.
1539        The height of the system font is dpi dependent */
1540     hdc = GetDC(0);
1541     hOldFont = SelectObject(hdc, GetStockObject(SYSTEM_FONT));
1542     GetTextMetricsA(hdc, &tm);
1543     /* 2 dot extra space are needed for the border */
1544     g_customheight = tm.tmHeight + 2;
1545     trace("customdraw height: %d (dpi: %d)\n", g_customheight, GetDeviceCaps(hdc, LOGPIXELSY));
1546     SelectObject(hdc, hOldFont);
1547     ReleaseDC(0, hdc);
1548
1549     hHeaderParentWnd = CreateWindowExA(0, "HeaderTestClass", "Header test", WS_OVERLAPPEDWINDOW,
1550       CW_USEDEFAULT, CW_USEDEFAULT, 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
1551       226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
1552       NULL, NULL, GetModuleHandleA(NULL), 0);
1553     assert(hHeaderParentWnd != NULL);
1554     ShowWindow(hHeaderParentWnd, SW_SHOW);
1555     return 1;
1556 }
1557
1558 START_TEST(header)
1559 {
1560     HWND parent_hwnd;
1561
1562     if (!init())
1563         return;
1564
1565     test_header_control();
1566     test_header_order();
1567     test_customdraw();
1568
1569     DestroyWindow(hHeaderParentWnd);
1570
1571     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1572     parent_hwnd = create_custom_parent_window();
1573     ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_wnd_seq, "create parent windows", FALSE);
1574
1575     test_hdm_index_messages(parent_hwnd);
1576     test_hdm_getitemrect(parent_hwnd);
1577     test_hdm_hittest(parent_hwnd);
1578     test_hdm_layout(parent_hwnd);
1579     test_hdm_ordertoindex(parent_hwnd);
1580     test_hdm_sethotdivider(parent_hwnd);
1581     test_hdm_imageMessages(parent_hwnd);
1582     test_hdm_filterMessages(parent_hwnd);
1583     test_hdm_unicodeformatMessages(parent_hwnd);
1584     test_hdm_bitmapmarginMessages(parent_hwnd);
1585
1586     DestroyWindow(parent_hwnd);
1587
1588 }