header.c 61.8 KB
Newer Older
1 2
/* Unit test suite for header control.
 *
3 4
 * Copyright 2005 Vijay Kiran Kamuju
 * Copyright 2007 Shanren Zhou
5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 23 24 25
 */


#include <windows.h>
#include <commctrl.h>

#include "wine/test.h"
26
#include "v6util.h"
27
#include "msg.h"
28

29 30 31
static HIMAGELIST (WINAPI *pImageList_Create)(int, int, UINT, int, int);
static BOOL (WINAPI *pImageList_Destroy)(HIMAGELIST);

32 33 34 35 36 37 38
typedef struct tagEXPECTEDNOTIFY
{
    INT iCode;
    BOOL fUnicode;
    HDITEMA hdItem;
} EXPECTEDNOTIFY;

39 40
typedef LRESULT (*CUSTOMDRAWPROC)(int n, NMCUSTOMDRAW *nm);

41 42 43 44
static CUSTOMDRAWPROC g_CustomDrawProc;
static int g_CustomDrawCount;
static DRAWITEMSTRUCT g_DrawItem;
static BOOL g_DrawItemReceived;
45
static DWORD g_customheight;
46

47 48 49 50 51
static EXPECTEDNOTIFY expectedNotify[10];
static INT nExpectedNotify = 0;
static INT nReceivedNotify = 0;
static INT unexpectedNotify[10];
static INT nUnexpectedNotify = 0;
52

53
static HWND hHeaderParentWnd;
54
static HWND hWndHeader;
55 56
#define MAX_CHARS 100

57 58
#define compare(val, exp, fmt)  ok((val) == (exp), #val " value: " fmt ", expected: " fmt "\n", (val), (exp))

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

61 62 63 64 65 66
#define NUM_MSG_SEQUENCES    2
#define PARENT_SEQ_INDEX     0
#define HEADER_SEQ_INDEX     1

static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
static const struct message create_parent_wnd_seq[] = {
    { WM_GETMINMAXINFO, sent },
    { WM_NCCREATE, sent },
    { WM_NCCALCSIZE, sent|wparam, 0 },
    { WM_CREATE, sent },
    { 0 }
};

static const struct message add_header_to_parent_seq_interactive[] = {
    { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
    { WM_QUERYUISTATE, sent },
    { WM_PARENTNOTIFY, sent|wparam, 1 },
    { WM_SHOWWINDOW, sent|wparam, 1 },
    { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
    { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
    { WM_ACTIVATEAPP, sent|wparam, 1 },
    { WM_NCACTIVATE, sent|wparam, 1 },
    { WM_ACTIVATE, sent|wparam, 1 },
    { WM_IME_SETCONTEXT, sent|defwinproc|wparam, 1 },
    { WM_IME_NOTIFY, sent|defwinproc|wparam, 2 },
    { WM_SETFOCUS, sent|defwinproc|wparam, 0 },
    { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
    { WM_SIZE, sent|wparam, 0 },
    { WM_MOVE, sent|wparam, 0 },
    { 0 }
};

static const struct message add_header_to_parent_seq[] = {
    { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
96
    { WM_QUERYUISTATE, sent|optional },
97 98 99 100 101
    { WM_PARENTNOTIFY, sent },
    { 0 }
};

static const struct message insertItem_seq[] = {
102 103 104 105
    { HDM_INSERTITEMA, sent|wparam, 0 },
    { HDM_INSERTITEMA, sent|wparam, 1 },
    { HDM_INSERTITEMA, sent|wparam, 2 },
    { HDM_INSERTITEMA, sent|wparam, 3 },
106 107 108 109
    { 0 }
};

static const struct message getItem_seq[] = {
110 111
    { HDM_GETITEMA, sent|wparam, 3 },
    { HDM_GETITEMA, sent|wparam, 0 },
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
    { 0 }
};


static const struct message deleteItem_getItemCount_seq[] = {
    { HDM_DELETEITEM, sent|wparam, 3 },
    { HDM_GETITEMCOUNT, sent },
    { HDM_DELETEITEM, sent|wparam, 3 },
    { HDM_GETITEMCOUNT, sent },
    { HDM_DELETEITEM, sent|wparam, 2 },
    { HDM_GETITEMCOUNT, sent },
    { 0 }
};

static const struct message orderArray_seq[] = {
    { HDM_SETORDERARRAY, sent|wparam, 2 },
    { HDM_GETORDERARRAY, sent|wparam, 2 },
    { 0 }
};

static const struct message setItem_seq[] = {
133 134
    { HDM_SETITEMA, sent|wparam, 0 },
    { HDM_SETITEMA, sent|wparam, 1 },
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
    { 0 }
};

static const struct message getItemRect_seq[] = {
    { HDM_GETITEMRECT, sent|wparam, 1 },
    { HDM_GETITEMRECT, sent|wparam, 0 },
    { HDM_GETITEMRECT, sent|wparam, 10 },
    { 0 }
};

static const struct message layout_seq[] = {
    { HDM_LAYOUT, sent },
    { 0 }
};

static const struct message orderToIndex_seq[] = {
    { HDM_ORDERTOINDEX, sent|wparam, 1 },
    { 0 }
};

static const struct message hittest_seq[] = {
    { HDM_HITTEST, sent },
    { HDM_HITTEST, sent },
    { HDM_HITTEST, sent },
    { 0 }
};

static const struct message setHotDivider_seq_interactive[] = {
    { HDM_SETHOTDIVIDER, sent|wparam, TRUE },
    { WM_PAINT, sent|defwinproc},
    { WM_NCPAINT, sent|defwinproc},
    { WM_ERASEBKGND, sent|defwinproc},
    { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 100 },
    { WM_PAINT, sent|defwinproc},
    { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 1},
    { WM_PAINT, sent|defwinproc},
    { 0 }
};

static const struct message setHotDivider_seq_noninteractive[] = {
    { HDM_SETHOTDIVIDER, sent|wparam, TRUE },
    { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 100 },
    { HDM_SETHOTDIVIDER, sent|wparam|lparam, FALSE, 1},
    { 0 }
};

static const struct message imageMessages_seq[] = {
    { HDM_SETIMAGELIST, sent },
    { HDM_GETIMAGELIST, sent },
    { HDM_CREATEDRAGIMAGE, sent },
    { 0 }
};

static const struct message filterMessages_seq_interactive[] = {
    { HDM_SETFILTERCHANGETIMEOUT, sent|wparam|lparam, 1, 100 },
    { HDM_CLEARFILTER, sent|wparam|lparam, 0, 1 },
    { HDM_EDITFILTER,  sent|wparam|lparam, 1, 0 },
    { WM_PARENTNOTIFY, sent|wparam|defwinproc, WM_CREATE },
    { WM_CTLCOLOREDIT, sent|defwinproc },
    { WM_COMMAND, sent|defwinproc },
    { 0 }
};

static const struct message filterMessages_seq_noninteractive[] = {
    { HDM_SETFILTERCHANGETIMEOUT, sent|wparam|lparam, 1, 100 },
    { HDM_CLEARFILTER, sent|wparam|lparam, 0, 1 },
    { HDM_EDITFILTER,  sent|wparam|lparam, 1, 0 },
202 203
    { WM_PARENTNOTIFY, sent|wparam|defwinproc|optional, WM_CREATE },
    { WM_COMMAND, sent|defwinproc|optional },
204 205 206 207 208 209 210 211 212 213 214 215 216 217
    { 0 }
};

static const struct message unicodeformatMessages_seq[] = {
    { HDM_SETUNICODEFORMAT, sent|wparam, TRUE },
    { HDM_GETUNICODEFORMAT, sent },
    { 0 }
};

static const struct message bitmapmarginMessages_seq[] = {
    { HDM_GETBITMAPMARGIN, sent },
    { 0 }
};

218

219 220
static void expect_notify(INT iCode, BOOL fUnicode, HDITEMA *lpItem)
{
221 222 223 224 225 226 227 228
    ok(nExpectedNotify < 10, "notification count %d\n", nExpectedNotify);
    if (nExpectedNotify < 10)
    {
        expectedNotify[nExpectedNotify].iCode = iCode;
        expectedNotify[nExpectedNotify].fUnicode = fUnicode;
        expectedNotify[nExpectedNotify].hdItem = *lpItem;
        nExpectedNotify++;
    }
229 230
}

231 232
static void dont_expect_notify(INT iCode)
{
233 234 235
    ok(nExpectedNotify < 10, "notification count %d\n", nExpectedNotify);
    if (nExpectedNotify < 10)
        unexpectedNotify[nUnexpectedNotify++] = iCode;
236 237
}

238
static BOOL notifies_received(void)
239 240 241
{
    BOOL fRet = (nExpectedNotify == nReceivedNotify);
    nExpectedNotify = nReceivedNotify = 0;
242
    nUnexpectedNotify = 0;
243 244 245
    return fRet;
}

246
static LONG addItem(HWND hdex, int idx, LPSTR text)
247 248 249 250
{
    HDITEMA hdItem;
    hdItem.mask       = HDI_TEXT | HDI_WIDTH;
    hdItem.cxy        = 100;
251
    hdItem.pszText    = text;
252
    hdItem.cchTextMax = 0;
253
    return SendMessageA(hdex, HDM_INSERTITEMA, idx, (LPARAM)&hdItem);
254 255
}

256
static LONG setItem(HWND hdex, int idx, LPSTR text, BOOL fCheckNotifies)
257
{
258
    LONG ret;
259 260
    HDITEMA hdexItem;
    hdexItem.mask       = HDI_TEXT;
261
    hdexItem.pszText    = text;
262
    hdexItem.cchTextMax = 0;
263 264 265 266 267
    if (fCheckNotifies)
    {
        expect_notify(HDN_ITEMCHANGINGA, FALSE, &hdexItem);
        expect_notify(HDN_ITEMCHANGEDA, FALSE, &hdexItem);
    }
268
    ret = SendMessageA(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
269 270 271 272 273
    if (fCheckNotifies)
        ok(notifies_received(), "setItem(): not all expected notifies were received\n");
    return ret;
}

274
static LONG setItemUnicodeNotify(HWND hdex, int idx, LPSTR text, LPWSTR wText)
275 276 277 278 279
{
    LONG ret;
    HDITEMA hdexItem;
    HDITEMW hdexNotify;
    hdexItem.mask       = HDI_TEXT;
280
    hdexItem.pszText    = text;
281 282 283
    hdexItem.cchTextMax = 0;
    
    hdexNotify.mask    = HDI_TEXT;
284
    hdexNotify.pszText = wText;
285 286 287
    
    expect_notify(HDN_ITEMCHANGINGW, TRUE, (HDITEMA*)&hdexNotify);
    expect_notify(HDN_ITEMCHANGEDW, TRUE, (HDITEMA*)&hdexNotify);
288
    ret = SendMessageA(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
289 290
    ok(notifies_received(), "setItemUnicodeNotify(): not all expected notifies were received\n");
    return ret;
291 292 293 294
}

static LONG delItem(HWND hdex, int idx)
{
295
    return SendMessageA(hdex, HDM_DELETEITEM, idx, 0);
296 297 298 299
}

static LONG getItemCount(HWND hdex)
{
300
    return SendMessageA(hdex, HDM_GETITEMCOUNT, 0, 0);
301 302 303 304 305 306 307 308
}

static LONG getItem(HWND hdex, int idx, LPSTR textBuffer)
{
    HDITEMA hdItem;
    hdItem.mask         = HDI_TEXT;
    hdItem.pszText      = textBuffer;
    hdItem.cchTextMax   = MAX_CHARS;
309
    return SendMessageA(hdex, HDM_GETITEMA, idx, (LPARAM)&hdItem);
310 311
}

312 313
static void addReadDelItem(HWND hdex, HDITEMA *phdiCreate, int maskRead, HDITEMA *phdiRead)
{
314
    ok(SendMessageA(hdex, HDM_INSERTITEMA, 0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
315 316
    ZeroMemory(phdiRead, sizeof(HDITEMA));
    phdiRead->mask = maskRead;
317 318
    ok(SendMessageA(hdex, HDM_GETITEMA, 0, (LPARAM)phdiRead)!=0, "Getting item data failed\n");
    ok(SendMessageA(hdex, HDM_DELETEITEM, 0, 0)!=0, "Deleting item failed\n");
319 320
}

321 322 323 324 325 326 327
static HWND create_header_control (void)
{
    HWND handle;
    HDLAYOUT hlayout;
    RECT rectwin;
    WINDOWPOS winpos;

328 329 330 331
    handle = CreateWindowExA(0, WC_HEADERA, NULL,
			     WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
			     0, 0, 0, 0,
			     hHeaderParentWnd, NULL, NULL, NULL);
332
    ok(handle != NULL, "failed to create header window\n");
333 334 335 336 337 338 339

    if (winetest_interactive)
	ShowWindow (hHeaderParentWnd, SW_SHOW);

    GetClientRect(hHeaderParentWnd,&rectwin);
    hlayout.prc = &rectwin;
    hlayout.pwpos = &winpos;
340
    SendMessageA(handle, HDM_LAYOUT, 0, (LPARAM)&hlayout);
341 342 343 344 345 346
    SetWindowPos(handle, winpos.hwndInsertAfter, winpos.x, winpos.y, 
                 winpos.cx, winpos.cy, 0);

    return handle;
}

347 348 349 350 351 352 353 354 355
static void compare_items(INT iCode, HDITEMA *hdi1, HDITEMA *hdi2, BOOL fUnicode)
{
    ok(hdi1->mask == hdi2->mask, "Notify %d mask mismatch (%08x != %08x)\n", iCode, hdi1->mask, hdi2->mask);
    if (hdi1->mask & HDI_WIDTH)
    {
        ok(hdi1->cxy == hdi2->cxy, "Notify %d cxy mismatch (%08x != %08x)\n", iCode, hdi1->cxy, hdi2->cxy);
    }
    if (hdi1->mask & HDI_TEXT)
    {
356 357 358 359 360
        if (hdi1->pszText == LPSTR_TEXTCALLBACKA)
        {
            ok(hdi1->pszText == LPSTR_TEXTCALLBACKA, "Notify %d - only one item is LPSTR_TEXTCALLBACK\n", iCode);
        }
        else
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
        if (fUnicode)
        {
            char buf1[260];
            char buf2[260];
            WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi1->pszText, -1, buf1, 260, NULL, NULL);
            WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)hdi2->pszText, -1, buf2, 260, NULL, NULL);
            ok(lstrcmpW((LPWSTR)hdi1->pszText, (LPWSTR)hdi2->pszText)==0,
                "Notify %d text mismatch (L\"%s\" vs L\"%s\")\n",
                    iCode, buf1, buf2);
        }
        else
        {
            ok(strcmp(hdi1->pszText, hdi2->pszText)==0,
                "Notify %d text mismatch (\"%s\" vs \"%s\")\n",
                    iCode, hdi1->pszText, hdi2->pszText);
            }
    }
}

380 381 382 383 384 385 386 387 388
static char pszFirstItem[]      = "First Item";
static char pszSecondItem[]     = "Second Item";
static char pszThirdItem[]      = "Third Item";
static char pszFourthItem[]     = "Fourth Item";
static char pszReplaceItem[]    = "Replace Item";
static char pszOutOfRangeItem[] = "Out Of Range Item";

static char *str_items[] =
    {pszFirstItem, pszSecondItem, pszThirdItem, pszFourthItem, pszReplaceItem, pszOutOfRangeItem};
389

390 391
static char pszUniTestA[]  = "TST";
static WCHAR pszUniTestW[] = {'T','S','T',0};
392

393 394 395

#define TEST_GET_ITEM(i,c)\
{   res = getItem(hWndHeader, i, buffer);\
396
    ok(res != 0, "Getting item[%d] using valid index failed unexpectedly (%d)\n", i, res);\
397 398 399 400 401
    ok(strcmp(str_items[c], buffer) == 0, "Getting item[%d] returned \"%s\" expecting \"%s\"\n", i, buffer, str_items[c]);\
}

#define TEST_GET_ITEMCOUNT(i)\
{   res = getItemCount(hWndHeader);\
402
    ok(res == i, "Got Item Count as %d\n", res);\
403 404
}

405 406
static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
407
    WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
408
    static LONG defwndproc_counter = 0;
409
    struct message msg = { 0 };
410 411 412 413 414 415 416 417 418 419
    LRESULT ret;

    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    msg.wParam = wParam;
    msg.lParam = lParam;
    add_message(sequences, HEADER_SEQ_INDEX, &msg);

    defwndproc_counter++;
420
    ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
421 422 423 424 425 426 427
    defwndproc_counter--;

    return ret;
}

static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
428
    static LONG defwndproc_counter = 0;
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
    LRESULT ret;
    struct message msg;

    /* do not log painting messages */
    if (message != WM_PAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCPAINT &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        message != WM_GETICON &&
        message != WM_DEVICECHANGE)

    {
        msg.message = message;
        msg.flags = sent|wparam|lparam;
        if (defwndproc_counter) msg.flags |= defwinproc;
        msg.wParam = wParam;
        msg.lParam = lParam;
447
        msg.id = 0;
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
        add_message(sequences, PARENT_SEQ_INDEX, &msg);
   }

    defwndproc_counter++;
    ret = DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;

    return ret;
}

static BOOL register_parent_wnd_class(void)
{
    WNDCLASSA cls;

    cls.style = 0;
    cls.lpfnWndProc = parent_wnd_proc;
    cls.cbClsExtra = 0;
    cls.cbWndExtra = 0;
    cls.hInstance = GetModuleHandleA(NULL);
    cls.hIcon = 0;
468
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
    cls.lpszMenuName = NULL;
    cls.lpszClassName = "Header test parent class";
    return RegisterClassA(&cls);
}

static HWND create_custom_parent_window(void)
{
    if (!register_parent_wnd_class())
        return NULL;

    return CreateWindowExA(0, "Header test parent class", "Header Message Sequence Testing",
                           WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
                           672+2*GetSystemMetrics(SM_CXSIZEFRAME),
                           226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
                           NULL, NULL, GetModuleHandleA(NULL), 0);
}

static HWND create_custom_header_control(HWND hParent, BOOL preloadHeaderItems)
{
489
    WNDPROC oldproc;
490 491 492 493 494 495 496 497 498
    HWND childHandle;
    HDLAYOUT hlayout;
    RECT rectwin;
    WINDOWPOS winpos;
    int retVal;
    int loopcnt;
    static char firstHeaderItem[] = "Name";
    static char secondHeaderItem[] = "Size";
    static char *items[] = {secondHeaderItem, firstHeaderItem};
499
    HDITEMA hdItem;
500 501 502 503 504
    hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
    hdItem.fmt = HDF_LEFT;
    hdItem.cxy = 80;
    hdItem.cchTextMax = 260;

505
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
506

507
    childHandle = CreateWindowExA(0, WC_HEADERA, NULL,
508 509 510
                           WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
                           0, 0, 0, 0,
                           hParent, NULL, NULL, NULL);
511
    ok(childHandle != NULL, "failed to create child window\n");
512 513 514 515 516
    if (preloadHeaderItems)
    {
         for ( loopcnt = 0 ; loopcnt < 2 ; loopcnt++ )
         {
             hdItem.pszText = items[loopcnt];
517
             retVal = SendMessageA(childHandle, HDM_INSERTITEMA, loopcnt, (LPARAM) &hdItem);
518 519 520 521 522 523 524 525 526 527 528 529 530 531
             ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
          }
    }

    if (winetest_interactive)
       ShowWindow (hParent, SW_SHOW);

    GetClientRect(hParent,&rectwin);
    hlayout.prc = &rectwin;
    hlayout.pwpos = &winpos;
    SendMessageA(childHandle,HDM_LAYOUT,0,(LPARAM) &hlayout);
    SetWindowPos(childHandle, winpos.hwndInsertAfter, winpos.x, winpos.y,
                 winpos.cx, winpos.cy, 0);

532 533 534
    oldproc = (WNDPROC)SetWindowLongPtrA(childHandle, GWLP_WNDPROC,
                                         (LONG_PTR)header_subclass_proc);
    SetWindowLongPtrA(childHandle, GWLP_USERDATA, (LONG_PTR)oldproc);
535 536 537
    return childHandle;
}

538
static void header_item_getback(HWND hwnd, UINT mask, HDITEMA *item)
539
{
540
    int ret;
541

542 543
    ret = SendMessageA(hwnd, HDM_INSERTITEMA, 0, (LPARAM)item);
    ok(ret != -1, "Failed to add header item.\n");
544

545 546
    memset(item, 0, sizeof(*item));
    item->mask = mask;
547

548 549 550 551 552
    ret = SendMessageA(hwnd, HDM_GETITEMA, 0, (LPARAM)item);
    ok(ret != 0, "Failed to get item data.\n");
    ret = SendMessageA(hwnd, HDM_DELETEITEM, 0, 0);
    ok(ret != 0, "Failed to delete item.\n");
}
553

554 555 556 557 558 559
static void test_item_auto_format(HWND parent)
{
    static char text[] = "Test";
    HDITEMA item;
    HBITMAP hbm;
    HWND hwnd;
560

561
    hwnd = create_custom_header_control(parent, FALSE);
562

563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
    /* Windows implicitly sets some format bits in INSERTITEM */

    /* HDF_STRING is automatically set and cleared for no text */
    item.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
    item.pszText = text;
    item.cxy = 100;
    item.fmt = HDF_CENTER;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == (HDF_STRING | HDF_CENTER), "Unexpected item format mask %#x.\n", item.fmt);

    item.mask = HDI_WIDTH | HDI_FORMAT;
    item.pszText = text;
    item.fmt = HDF_CENTER | HDF_STRING;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == HDF_CENTER, "Unexpected item format mask %#x.\n", item.fmt);

    /* HDF_BITMAP is automatically set and cleared for a NULL bitmap or no bitmap */
    item.mask = HDI_BITMAP | HDI_WIDTH | HDI_FORMAT;
    item.hbm = hbm = CreateBitmap(16, 16, 1, 8, NULL);
    item.fmt = HDF_CENTER;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == (HDF_BITMAP | HDF_CENTER), "Unexpected item format mask %#x.\n", item.fmt);
    DeleteObject(hbm);

    item.mask = HDI_BITMAP | HDI_WIDTH | HDI_FORMAT;
    item.hbm = NULL;
    item.fmt = HDF_CENTER | HDF_BITMAP;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == HDF_CENTER, "Unexpected item format mask %#x.\n", item.fmt);

    item.mask = HDI_WIDTH | HDI_FORMAT;
    item.fmt = HDF_CENTER | HDF_BITMAP;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == HDF_CENTER, "Unexpected item format mask %#x.\n", item.fmt);
597 598

    /* HDF_IMAGE is automatically set but not cleared */
599 600 601 602
    item.mask = HDI_IMAGE | HDI_WIDTH | HDI_FORMAT;
    item.iImage = 17;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == (HDF_IMAGE | HDF_CENTER), "Unexpected item format mask %#x.\n", item.fmt);
603

604 605 606 607 608 609 610
    item.mask = HDI_WIDTH | HDI_FORMAT;
    item.fmt = HDF_CENTER | HDF_IMAGE;
    item.iImage = 0;
    header_item_getback(hwnd, HDI_FORMAT, &item);
    ok(item.fmt == (HDF_CENTER | HDF_IMAGE), "Unexpected item format mask %#x.\n", item.fmt);

    DestroyWindow(hwnd);
611 612
}

613 614 615 616
static void check_auto_fields(void)
{
    HDITEMA hdiCreate;
    HDITEMA hdiRead;
617
    static CHAR text[] = "Test";
618
    LONG res;
619 620 621 622 623

    /* Windows stores the format, width, lparam even if they are not in the item's mask */
    ZeroMemory(&hdiCreate, sizeof(HDITEMA));
    hdiCreate.mask = HDI_TEXT;
    hdiCreate.cxy = 100;
624
    hdiCreate.pszText = text;
625 626 627 628 629 630
    addReadDelItem(hWndHeader, &hdiCreate, HDI_WIDTH, &hdiRead);
    TEST_GET_ITEMCOUNT(6);
    ok(hdiRead.cxy == hdiCreate.cxy, "cxy should be automatically set\n");

    ZeroMemory(&hdiCreate, sizeof(HDITEMA));
    hdiCreate.mask = HDI_TEXT;
631
    hdiCreate.pszText = text;
632 633 634 635 636 637 638
    hdiCreate.lParam = 0x12345678;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_LPARAM, &hdiRead);
    TEST_GET_ITEMCOUNT(6);
    ok(hdiRead.lParam == hdiCreate.lParam, "lParam should be automatically set\n");

    ZeroMemory(&hdiCreate, sizeof(HDITEMA));
    hdiCreate.mask = HDI_TEXT;
639
    hdiCreate.pszText = text;
640 641 642 643 644 645 646 647
    hdiCreate.fmt = HDF_STRING|HDF_CENTER;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    TEST_GET_ITEMCOUNT(6);
    ok(hdiRead.fmt == hdiCreate.fmt, "fmt should be automatically set\n");

    /* others fields are not set */
    ZeroMemory(&hdiCreate, sizeof(HDITEMA));
    hdiCreate.mask = HDI_TEXT;
648
    hdiCreate.pszText = text;
649 650 651 652 653 654 655 656 657
    hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
    addReadDelItem(hWndHeader, &hdiCreate, HDI_BITMAP, &hdiRead);
    TEST_GET_ITEMCOUNT(6);
    ok(hdiRead.hbm == NULL, "hbm should not be automatically set\n");
    DeleteObject(hdiCreate.hbm);

    ZeroMemory(&hdiCreate, sizeof(HDITEMA));
    hdiCreate.mask = HDI_IMAGE;
    hdiCreate.iImage = 17;
658
    hdiCreate.pszText = text;
659 660 661 662 663 664 665
    addReadDelItem(hWndHeader, &hdiCreate, HDI_TEXT, &hdiRead);
    TEST_GET_ITEMCOUNT(6);
    ok(hdiRead.pszText==NULL, "pszText shouldn't be automatically set\n");

    /* field from comctl >4.0 not tested as the system probably won't touch them */
}

666
static void check_mask(void)
667 668
{
    HDITEMA hdi;
669
    static CHAR text[] = "ABC";
670 671 672 673 674 675
    LRESULT ret;

    /* don't create items if the mask is zero */
    ZeroMemory(&hdi, sizeof(hdi));
    hdi.mask = 0;
    hdi.cxy = 200;
676
    hdi.pszText = text;
677 678 679 680
    hdi.fmt = 0;
    hdi.iOrder = 0;
    hdi.lParam = 17;
    hdi.cchTextMax = 260;
681
    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
682
    ok(ret == -1, "Creating an item with a zero mask should have failed\n");
683
    if (ret != -1) SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
684 685 686 687

    /* with a non-zero mask creation will succeed */
    ZeroMemory(&hdi, sizeof(hdi));
    hdi.mask = HDI_LPARAM;
688
    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
689 690
    ok(ret != -1, "Adding item with non-zero mask failed\n");
    if (ret != -1)
691
        SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
692 693 694 695 696 697

    /* in SETITEM if the mask contains a unknown bit, it is ignored */
    ZeroMemory(&hdi, sizeof(hdi));
    hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
    hdi.lParam = 133;
    hdi.iImage = 17;
698
    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
699 700 701 702 703 704 705
    ok(ret != -1, "Adding item failed\n");

    if (ret != -1)
    {
        /* check result */
        ZeroMemory(&hdi, sizeof(hdi));
        hdi.mask = HDI_LPARAM | HDI_IMAGE;
706
        SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
707 708 709 710 711 712
        ok(hdi.lParam == 133, "comctl32 4.0 field not set\n");
        ok(hdi.iImage == 17, "comctl32 >4.0 field not set\n");

        /* but in GETITEM if an unknown bit is set, comctl32 uses only version 4.0 fields */
        ZeroMemory(&hdi, sizeof(hdi));
        hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
713
        SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
714 715 716
        ok(hdi.lParam == 133, "comctl32 4.0 field not read\n");
        ok(hdi.iImage == 0, "comctl32 >4.0 field shouldn't be read\n");

717
        SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
718 719 720
    }
}

721 722 723 724 725 726 727 728 729 730 731 732
static void test_header_control (void)
{
    LONG res;
    static char buffer[MAX_CHARS];
    int i;

    hWndHeader = create_header_control ();

    for (i = 3; i >= 0; i--)
    {
        TEST_GET_ITEMCOUNT(3-i);
        res = addItem(hWndHeader, 0, str_items[i]);
733
        ok(res == 0, "Adding simple item failed (%d)\n", res);
734 735 736 737
    }

    TEST_GET_ITEMCOUNT(4);
    res = addItem(hWndHeader, 99, str_items[i+1]);
738
    ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
739 740
    TEST_GET_ITEMCOUNT(5);
    res = addItem(hWndHeader, 5, str_items[i+1]);
741
    ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
742 743 744 745 746
    TEST_GET_ITEMCOUNT(6);

    for (i = 0; i < 4; i++) { TEST_GET_ITEM(i,i); TEST_GET_ITEMCOUNT(6); }

    res=getItem(hWndHeader, 99, buffer);
747
    ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
748
    res=getItem(hWndHeader, 5, buffer);
749
    ok(res == 1, "Getting Out of Range item should fail with 1 (%d), got %s\n", res,buffer);
750
    res=getItem(hWndHeader, -2, buffer);
751
    ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
752 753 754 755 756 757 758 759

    if (winetest_interactive)
    {
        UpdateWindow(hHeaderParentWnd);
        UpdateWindow(hWndHeader);
    }

    TEST_GET_ITEMCOUNT(6);
760
    res=setItem(hWndHeader, 99, str_items[5], FALSE);
761
    ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
762
    res=setItem(hWndHeader, 5, str_items[5], TRUE);
763
    ok(res == 1, "Setting Out of Range item should fail with 1 (%d)\n", res);
764
    res=setItem(hWndHeader, -2, str_items[5], FALSE);
765
    ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
766 767 768 769
    TEST_GET_ITEMCOUNT(6);

    for (i = 0; i < 4; i++)
    {
770
        res = setItem(hWndHeader, i, str_items[4], TRUE);
771
        ok(res != 0, "Setting %d item failed (%d)\n", i+1, res);
772 773 774
        TEST_GET_ITEM(i, 4);
        TEST_GET_ITEMCOUNT(6);
    }
775 776

    SendMessageA(hWndHeader, HDM_SETUNICODEFORMAT, TRUE, 0);
777
    setItemUnicodeNotify(hWndHeader, 3, pszUniTestA, pszUniTestW);
778
    SendMessageA(hWndHeader, WM_NOTIFYFORMAT, (WPARAM)hHeaderParentWnd, NF_REQUERY);
779
    setItem(hWndHeader, 3, str_items[4], TRUE);
780 781 782 783 784 785 786 787 788 789 790
    
    dont_expect_notify(HDN_GETDISPINFOA);
    dont_expect_notify(HDN_GETDISPINFOW);
    addItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA);
    setItem(hWndHeader, 0, str_items[4], TRUE);
    /* unexpected notifies cleared by notifies_received in setItem */
    dont_expect_notify(HDN_GETDISPINFOA);
    dont_expect_notify(HDN_GETDISPINFOW);
    setItem(hWndHeader, 0, LPSTR_TEXTCALLBACKA, TRUE);
    /* unexpected notifies cleared by notifies_received in setItem */
    delItem(hWndHeader, 0);
791

792
    TEST_GET_ITEMCOUNT(6);
793 794
    check_auto_fields();
    TEST_GET_ITEMCOUNT(6);
795 796
    check_mask();
    TEST_GET_ITEMCOUNT(6);
797

798
    res = delItem(hWndHeader, 5);
799
    ok(res == 1, "Deleting Out of Range item should fail with 1 (%d)\n", res);
800
    res = delItem(hWndHeader, -2);
801
    ok(res == 0, "Deleting Out of Range item should fail with 0 (%d)\n", res);
802 803 804
    TEST_GET_ITEMCOUNT(5);

    res = delItem(hWndHeader, 3);
805
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
806 807
    TEST_GET_ITEMCOUNT(4);
    res = delItem(hWndHeader, 0);
808
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
809 810
    TEST_GET_ITEMCOUNT(3);
    res = delItem(hWndHeader, 0);
811
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
812 813
    TEST_GET_ITEMCOUNT(2);
    res = delItem(hWndHeader, 0);
814
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
815 816 817 818 819
    TEST_GET_ITEMCOUNT(1);

    DestroyWindow(hWndHeader);
}

820
static void test_hdm_getitemrect(HWND hParent)
821
{
822 823

    HWND hChild;
824 825
    RECT rect;
    int retVal;
826 827

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
828
    hChild = create_custom_header_control(hParent, TRUE);
829
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
830
                                    "adder header control to parent", FALSE);
831

832
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
833
    ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
834
    /* check bounding rectangle information of 2nd header item */
835 836 837
    expect(80, rect.left);
    expect(0, rect.top);
    expect(160, rect.right);
838 839
    expect(g_customheight, rect.bottom);

840
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
841 842

    ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
843
    /* check bounding rectangle information of 1st header item */
844 845
    expect(0, rect.left);
    expect(0, rect.top);
846

847
    expect(80, rect.right);
848 849
    expect(g_customheight, rect.bottom);

850
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
851
    ok(retVal == 0, "Getting rect of nonexistent item should return 0, got %d\n", retVal);
852 853

    ok_sequence(sequences, HEADER_SEQ_INDEX, getItemRect_seq, "getItemRect sequence testing", FALSE);
854
    DestroyWindow(hChild);
855 856
}

857
static void test_hdm_layout(HWND hParent)
858
{
859
    HWND hChild;
860 861 862 863 864 865
    int retVal;
    RECT rect;
    HDLAYOUT hdLayout;
    WINDOWPOS windowPos;
    hdLayout.prc = &rect;
    hdLayout.pwpos = &windowPos;
866 867

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
868
    hChild = create_custom_header_control(hParent, TRUE);
869
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
870
                                    "adder header control to parent", FALSE);
871 872

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
873
    retVal = SendMessageA(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
874
    expect(TRUE, retVal);
875 876 877

    ok_sequence(sequences, HEADER_SEQ_INDEX, layout_seq, "layout sequence testing", FALSE);

878
    DestroyWindow(hChild);
879 880
}

881
static void test_hdm_ordertoindex(HWND hParent)
882
{
883
    HWND hChild;
884
    int retVal;
885

886
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
887
    hChild = create_custom_header_control(hParent, TRUE);
888
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
889
                                    "adder header control to parent", FALSE);
890 891

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
892
    retVal = SendMessageA(hChild, HDM_ORDERTOINDEX, 1, 0);
893
    expect(1, retVal);
894 895

    ok_sequence(sequences, HEADER_SEQ_INDEX, orderToIndex_seq, "orderToIndex sequence testing", FALSE);
896
    DestroyWindow(hChild);
897 898
}

899
static void test_hdm_hittest(HWND hParent)
900
{
901
    HWND hChild;
902 903 904
    int retVal;
    POINT pt;
    HDHITTESTINFO hdHitTestInfo;
905 906
    const int firstItemRightBoundary = 80;
    const int secondItemRightBoundary = 160;
907
    const int bottomBoundary = g_customheight;
908 909 910

    pt.x = firstItemRightBoundary - 1;
    pt.y = bottomBoundary - 1;
911 912
    hdHitTestInfo.pt = pt;

913 914

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
915
    hChild = create_custom_header_control(hParent, TRUE);
916
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
917
                                    "adder header control to parent", FALSE);
918 919

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
920
    retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
921 922
    expect(0, retVal);
    expect(0, hdHitTestInfo.iItem);
923
    expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
924 925 926

    pt.x = secondItemRightBoundary - 1;
    pt.y = bottomBoundary - 1;
927
    hdHitTestInfo.pt = pt;
928
    retVal = SendMessageA(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
929
    expect(1, retVal);
930
    expect(1, hdHitTestInfo.iItem);
931
    expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
932

933 934
    pt.x = secondItemRightBoundary;
    pt.y = bottomBoundary + 1;
935
    hdHitTestInfo.pt = pt;
936
    retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
937 938 939
    expect(-1, retVal);
    expect(-1, hdHitTestInfo.iItem);
    expect(HHT_BELOW, hdHitTestInfo.flags);
940

941 942
    ok_sequence(sequences, HEADER_SEQ_INDEX, hittest_seq, "hittest sequence testing", FALSE);

943
    DestroyWindow(hChild);
944 945
}

946
static void test_hdm_sethotdivider(HWND hParent)
947
{
948
    HWND hChild;
949 950 951 952
    int retVal;
    /*  low word: x coordinate = 5
     *  high word:  y coordinate = 5
     */
953 954

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
955
    hChild = create_custom_header_control(hParent, TRUE);
956
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
957
                                    "adder header control to parent", FALSE);
958

959
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
960
    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, TRUE, MAKELPARAM(5, 5));
961 962
    expect(0, retVal);

963
    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
964
    expect(100, retVal);
965
    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
966
    expect(1, retVal);
967 968 969 970 971 972
    if (winetest_interactive)
       ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_interactive,
                   "setHotDivider sequence testing", TRUE);
    else
       ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_noninteractive,
                   "setHotDivider sequence testing", FALSE);
973 974

    DestroyWindow(hChild);
975 976
}

977
static void test_hdm_imageMessages(HWND hParent)
978
{
979
    HIMAGELIST hImageList = pImageList_Create (4, 4, 0, 1, 0);
980
    HIMAGELIST hIml;
981
    BOOL wasValid;
982 983
    HWND hChild;

984
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
985
    hChild = create_custom_header_control(hParent, TRUE);
986
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
987
                                    "adder header control to parent", FALSE);
988 989

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
990

991
    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
992
    ok(hIml == NULL, "Expected NULL, got %p\n", hIml);
993

994
    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_GETIMAGELIST, 0, 0);
995
    ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
996

997
    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
998
    ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
999
    pImageList_Destroy(hIml);
1000

1001 1002
    ok_sequence(sequences, HEADER_SEQ_INDEX, imageMessages_seq, "imageMessages sequence testing", FALSE);

1003
    DestroyWindow(hChild);
1004

1005
    wasValid = pImageList_Destroy(hImageList);
1006
    ok(wasValid, "Header must not free image list at destruction!\n");
1007 1008
}

1009
static void test_hdm_filterMessages(HWND hParent)
1010
{
1011
    HWND hChild;
1012
    int retVal, timeout;
1013

1014
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1015
    hChild = create_custom_header_control(hParent, TRUE);
1016
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1017
                                    "adder header control to parent", FALSE);
1018

1019 1020 1021 1022 1023 1024 1025 1026 1027
    timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 0, 0);
    ok(timeout == 1000, "got %d\n", timeout);

    timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 0, 0);
    ok(timeout == 1000, "got %d\n", timeout);

    timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 0, -100);
    ok(timeout == 1000, "got %d\n", timeout);

1028
    timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1029 1030 1031
    ok(timeout == -100, "got %d\n", timeout);
    retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
    ok(retVal == 100, "got %d\n", retVal);
1032

1033
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1034 1035 1036 1037 1038 1039 1040

    /* msdn incorrectly states that return value
     * is the index of the filter control being
     * modified. The sendMessage here should
     * return previous filter timeout value
     */

1041
    retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1042 1043
    expect(timeout, retVal);

1044 1045
    todo_wine
    {
1046
        retVal = SendMessageA(hChild, HDM_CLEARFILTER, 0, 1);
1047 1048 1049 1050 1051
        if (retVal == 0)
            win_skip("HDM_CLEARFILTER needs 5.80\n");
        else
            expect(1, retVal);

1052
        retVal = SendMessageA(hChild, HDM_EDITFILTER, 1, 0);
1053 1054 1055 1056
        if (retVal == 0)
            win_skip("HDM_EDITFILTER needs 5.80\n");
        else
            expect(1, retVal);
1057
    }
1058 1059 1060 1061 1062
    if (winetest_interactive)
         ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_interactive,
                     "filterMessages sequence testing", TRUE);
    else
         ok_sequence(sequences, HEADER_SEQ_INDEX, filterMessages_seq_noninteractive,
1063
                     "filterMessages sequence testing", FALSE);
1064 1065
    DestroyWindow(hChild);

1066 1067
}

1068
static void test_hdm_unicodeformatMessages(HWND hParent)
1069
{
1070
    HWND hChild;
1071
    int retVal;
1072 1073

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1074
    hChild = create_custom_header_control(hParent, TRUE);
1075
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1076
                                    "adder header control to parent", FALSE);
1077 1078

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1079
    retVal = SendMessageA(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
1080
    expect(0, retVal);
1081
    retVal = SendMessageA(hChild, HDM_GETUNICODEFORMAT, 0, 0);
1082
    expect(1, retVal);
1083 1084 1085

    ok_sequence(sequences, HEADER_SEQ_INDEX, unicodeformatMessages_seq,
                     "unicodeformatMessages sequence testing", FALSE);
1086
    DestroyWindow(hChild);
1087 1088
}

1089
static void test_hdm_bitmapmarginMessages(HWND hParent)
1090
{
1091
    HWND hChild;
1092
    int retVal;
1093 1094

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1095
    hChild = create_custom_header_control(hParent, TRUE);
1096
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1097
                                    "adder header control to parent", FALSE);
1098 1099

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1100
    retVal = SendMessageA(hChild, HDM_GETBITMAPMARGIN, 0, 0);
1101 1102 1103 1104
    if (retVal == 0)
        win_skip("HDM_GETBITMAPMARGIN needs 5.80\n");
    else
        expect(6, retVal);
1105 1106 1107

    ok_sequence(sequences, HEADER_SEQ_INDEX, bitmapmarginMessages_seq,
                      "bitmapmarginMessages sequence testing", FALSE);
1108
    DestroyWindow(hChild);
1109 1110
}

1111
static void test_hdm_index_messages(HWND hParent)
1112
{
1113
    HWND hChild;
1114
    int retVal, i, iSize;
1115
    static const int lpiarray[2] = {1, 0};
1116 1117 1118
    static const char *item_texts[] = {
        "Name", "Size", "Type", "Date Modified"
    };
1119
    RECT rect;
1120
    HDITEMA hdItem;
1121
    char buffA[32];
1122
    int array[2];
1123

1124
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1125
    hChild = create_custom_header_control(hParent, FALSE);
1126 1127 1128 1129 1130
    if (winetest_interactive)
         ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq_interactive,
                                              "adder header control to parent", TRUE);
    else
         ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1131
                                     "adder header control to parent", FALSE);
1132
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1133
    for (i = 0; i < ARRAY_SIZE(item_texts); i++)
1134
    {
1135
        hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
1136
        hdItem.pszText = (char*)item_texts[i];
1137 1138 1139 1140 1141
        hdItem.fmt = HDF_LEFT;
        hdItem.cxy = 80;

        retVal = SendMessageA(hChild, HDM_INSERTITEMA, i, (LPARAM) &hdItem);
        ok(retVal == i, "Adding item %d failed with return value %d\n", i, retVal);
1142
    }
1143 1144 1145
    ok_sequence(sequences, HEADER_SEQ_INDEX, insertItem_seq, "insertItem sequence testing", FALSE);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1146

1147
    retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1148
    ok(retVal == TRUE, "Deleting item 3 should return TRUE, got %d\n", retVal);
1149
    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1150 1151
    ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);

1152
    retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1153
    ok(retVal == FALSE, "Deleting already-deleted item should return FALSE, got %d\n", retVal);
1154
    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1155 1156
    ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);

1157
    retVal = SendMessageA(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
1158
    ok(retVal == TRUE, "Deleting item 2 should return TRUE, got %d\n", retVal);
1159
    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1160 1161
    ok(retVal == 2, "Getting item count should return 2, got %d\n", retVal);

1162 1163 1164 1165 1166
    ok_sequence(sequences, HEADER_SEQ_INDEX, deleteItem_getItemCount_seq,
                         "deleteItem_getItemCount sequence testing", FALSE);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

1167
    hdItem.mask = HDI_WIDTH;
1168
    retVal = SendMessageA(hChild, HDM_GETITEMA, 3, (LPARAM) &hdItem);
1169 1170
    ok(retVal == FALSE, "Getting already-deleted item should return FALSE, got %d\n", retVal);

1171 1172
    hdItem.mask = HDI_TEXT | HDI_WIDTH;
    hdItem.pszText = buffA;
1173
    hdItem.cchTextMax = ARRAY_SIZE(buffA);
1174
    retVal = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM) &hdItem);
1175
    ok(retVal == TRUE, "Getting the 1st header item should return TRUE, got %d\n", retVal);
1176 1177 1178

    ok_sequence(sequences, HEADER_SEQ_INDEX, getItem_seq, "getItem sequence testing", FALSE);

1179
    /* check if the item is the right one */
1180 1181
    ok(!strcmp(hdItem.pszText, item_texts[0]), "got wrong item %s, expected %s\n",
        hdItem.pszText, item_texts[0]);
1182 1183
    expect(80, hdItem.cxy);

1184
    iSize = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1185 1186 1187

    /* item should be updated just after accepting new array */
    ShowWindow(hChild, SW_HIDE);
1188
    retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1189 1190
    expect(TRUE, retVal);
    rect.left = 0;
1191
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
1192
    expect(TRUE, retVal);
1193
    ok(rect.left != 0, "Expected updated rectangle\n");
1194

1195 1196
    flush_sequences(sequences, NUM_MSG_SEQUENCES);

1197
    retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1198
    ok(retVal == TRUE, "Setting header items order should return TRUE, got %d\n", retVal);
1199

1200
    retVal = SendMessageA(hChild, HDM_GETORDERARRAY, 2, (LPARAM) array);
1201
    ok(retVal == TRUE, "Getting header items order should return TRUE, got %d\n", retVal);
1202 1203 1204

    ok_sequence(sequences, HEADER_SEQ_INDEX, orderArray_seq, "set_get_orderArray sequence testing", FALSE);

1205
    /* check if the array order is set correctly and the size of the array is correct. */
1206
    expect(2, iSize);
1207 1208
    ok(lpiarray[0] == array[0], "got %d, expected %d\n", array[0], lpiarray[0]);
    ok(lpiarray[1] == array[1], "got %d, expected %d\n", array[1], lpiarray[1]);
1209 1210 1211

    hdItem.mask = HDI_FORMAT;
    hdItem.fmt = HDF_CENTER | HDF_STRING;
1212 1213 1214

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

1215
    retVal = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM) &hdItem);
1216 1217
    ok(retVal == TRUE, "Aligning 1st header item to center should return TRUE, got %d\n", retVal);
    hdItem.fmt = HDF_RIGHT | HDF_STRING;
1218
    retVal = SendMessageA(hChild, HDM_SETITEMA, 1, (LPARAM) &hdItem);
1219 1220
    ok(retVal == TRUE, "Aligning 2nd header item to right should return TRUE, got %d\n", retVal);

1221 1222
    ok_sequence(sequences, HEADER_SEQ_INDEX, setItem_seq, "setItem sequence testing", FALSE);
    DestroyWindow(hChild);
1223
}
1224

1225 1226 1227
static void test_hdf_fixedwidth(HWND hParent)
{
    HWND hChild;
1228
    HDITEMA hdItem;
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
    DWORD ret;
    RECT rect;
    HDHITTESTINFO ht;

    hChild = create_custom_header_control(hParent, FALSE);

    hdItem.mask = HDI_WIDTH | HDI_FORMAT;
    hdItem.fmt = HDF_FIXEDWIDTH;
    hdItem.cxy = 80;

1239
    ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
1240 1241 1242 1243
    expect(0, ret);

    /* try to change width */
    rect.right = rect.bottom = 0;
1244
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1245 1246 1247
    ok(rect.right  != 0, "Expected not zero width\n");
    ok(rect.bottom != 0, "Expected not zero height\n");

1248 1249 1250
    SendMessageA(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
    SendMessageA(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
    SendMessageA(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
1251

1252
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264

    if (hdItem.cxy != rect.right)
    {
        win_skip("HDF_FIXEDWIDTH format not supported\n");
        DestroyWindow(hChild);
        return;
    }

    /* try to adjust with message */
    hdItem.mask = HDI_WIDTH;
    hdItem.cxy = 90;

1265
    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1266 1267 1268
    expect(TRUE, ret);

    rect.right = 0;
1269
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1270 1271 1272 1273 1274
    expect(90, rect.right);

    /* hittesting doesn't report ondivider flag for HDF_FIXEDWIDTH */
    ht.pt.x = rect.right - 1;
    ht.pt.y = rect.bottom / 2;
1275
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1276 1277 1278 1279 1280 1281
    expect(HHT_ONHEADER, ht.flags);

    /* try to adjust with message */
    hdItem.mask = HDI_FORMAT;
    hdItem.fmt  = 0;

1282
    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1283 1284 1285 1286
    expect(TRUE, ret);

    ht.pt.x = 90;
    ht.pt.y = rect.bottom / 2;
1287
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1288 1289 1290 1291 1292
    expect(HHT_ONDIVIDER, ht.flags);

    DestroyWindow(hChild);
}

1293 1294 1295
static void test_hds_nosizing(HWND hParent)
{
    HWND hChild;
1296
    HDITEMA hdItem;
1297 1298 1299 1300 1301 1302
    DWORD ret;
    RECT rect;
    HDHITTESTINFO ht;

    hChild = create_custom_header_control(hParent, FALSE);

1303
    memset(&hdItem, 0, sizeof(hdItem));
1304 1305 1306
    hdItem.mask = HDI_WIDTH;
    hdItem.cxy = 80;

1307
    ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
1308 1309 1310
    expect(0, ret);

    /* HDS_NOSIZING only blocks hittesting */
1311 1312
    ret = GetWindowLongA(hChild, GWL_STYLE);
    SetWindowLongA(hChild, GWL_STYLE, ret | HDS_NOSIZING);
1313 1314 1315

    /* try to change width with mouse gestures */
    rect.right = rect.bottom = 0;
1316
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1317 1318 1319
    ok(rect.right  != 0, "Expected not zero width\n");
    ok(rect.bottom != 0, "Expected not zero height\n");

1320 1321 1322
    SendMessageA(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
    SendMessageA(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
    SendMessageA(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
1323

1324
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334

    if (hdItem.cxy != rect.right)
    {
        win_skip("HDS_NOSIZING style not supported\n");
        DestroyWindow(hChild);
        return;
    }

    /* this style doesn't set HDF_FIXEDWIDTH for items */
    hdItem.mask = HDI_FORMAT;
1335
    ret = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM)&hdItem);
1336 1337 1338 1339 1340 1341 1342
    expect(TRUE, ret);
    ok(!(hdItem.fmt & HDF_FIXEDWIDTH), "Unexpected HDF_FIXEDWIDTH\n");

    /* try to adjust with message */
    hdItem.mask = HDI_WIDTH;
    hdItem.cxy = 90;

1343
    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1344 1345 1346
    expect(TRUE, ret);

    rect.right = 0;
1347
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1348 1349 1350 1351 1352
    expect(90, rect.right);

    /* hittesting doesn't report ondivider flags for HDS_NOSIZING */
    ht.pt.x = rect.right - 1;
    ht.pt.y = rect.bottom / 2;
1353
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1354 1355 1356
    expect(HHT_ONHEADER, ht.flags);

    /* try to adjust with message */
1357 1358
    ret = GetWindowLongA(hChild, GWL_STYLE);
    SetWindowLongA(hChild, GWL_STYLE, ret & ~HDS_NOSIZING);
1359 1360 1361

    ht.pt.x = 90;
    ht.pt.y = rect.bottom / 2;
1362
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1363 1364 1365 1366 1367
    expect(HHT_ONDIVIDER, ht.flags);

    DestroyWindow(hChild);
}

1368 1369 1370 1371 1372
#define TEST_NMCUSTOMDRAW(draw_stage, item_spec, lparam, _left, _top, _right, _bottom) \
    ok(nm->dwDrawStage == draw_stage, "Invalid dwDrawStage %d vs %d\n", draw_stage, nm->dwDrawStage); \
    if (item_spec != -1) \
        ok(nm->dwItemSpec == item_spec, "Invalid dwItemSpec %d vs %ld\n", item_spec, nm->dwItemSpec); \
    ok(nm->lItemlParam == lparam, "Invalid lItemlParam %d vs %ld\n", lparam, nm->lItemlParam); \
1373 1374
    ok((nm->rc.top == _top && nm->rc.bottom == _bottom && nm->rc.left == _left && nm->rc.right == _right) || \
        broken(draw_stage != CDDS_ITEMPREPAINT), /* comctl32 < 5.80 */ \
1375 1376
        "Invalid rect (%d,%d)-(%d,%d) vs %s\n", _left, _top, _right, _bottom, \
        wine_dbgstr_rect(&nm->rc));
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388

static LRESULT customdraw_1(int n, NMCUSTOMDRAW *nm)
{
    if (nm == NULL) {  /* test ended */
        ok(n==1, "NM_CUSTOMDRAW messages: %d, expected: 1\n", n);
        return 0;
    }

    switch (n)
    {
    case 0:
        /* don't test dwItemSpec - it's 0 no comctl5 but 1308756 on comctl6 */
1389
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1390 1391 1392
        return 0;
    }

1393
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
    return -1;
}

static LRESULT customdraw_2(int n, NMCUSTOMDRAW *nm)
{
    if (nm == NULL) {  /* test ended */
        ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
        return 0;
    }

    switch (n)
    {
    case 0:
1407
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1408 1409
        return CDRF_NOTIFYITEMDRAW;
    case 1:
1410
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1411 1412
        return 0;
    case 2:
1413
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1414 1415
        return 0;
    case 3:
1416
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1417 1418 1419
        return 0;
    }

1420
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
    return 0;
}

static LRESULT customdraw_3(int n, NMCUSTOMDRAW *nm)
{
    if (nm == NULL) {  /* test ended */
        ok(n==5, "NM_CUSTOMDRAW messages: %d, expected: 5\n", n);
        return 0;
    }

    switch (n)
    {
    case 0:
1434
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1435 1436
        return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTERASE|CDRF_NOTIFYPOSTPAINT|CDRF_SKIPDEFAULT;
    case 1:
1437
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1438 1439
        return 0;
    case 2:
1440
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1441 1442
        return 0;
    case 3:
1443
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1444 1445
        return 0;
    case 4:
1446
        TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1447 1448 1449
        return 0;
    }

1450
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
    return 0;
}


static LRESULT customdraw_4(int n, NMCUSTOMDRAW *nm)
{
    if (nm == NULL) {  /* test ended */
        ok(n==4, "NM_CUSTOMDRAW messages: %d, expected: 4\n", n);
        return 0;
    }

    switch (n)
    {
    case 0:
1465
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1466 1467
        return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTPAINT;
    case 1:
1468
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1469 1470
        return 0;
    case 2:
1471
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1472 1473
        return 0;
    case 3:
1474
        TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1475 1476 1477
        return 0;
    }

1478
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
    return 0;
}

static void run_customdraw_scenario(CUSTOMDRAWPROC proc)
{
    g_CustomDrawProc = proc;
    g_CustomDrawCount = 0;
    InvalidateRect(hWndHeader, NULL, TRUE);
    UpdateWindow(hWndHeader);
    proc(g_CustomDrawCount, NULL);
    g_CustomDrawProc = NULL;
}

1492
static void test_customdraw(void)
1493 1494
{
    int i;
1495
    HDITEMA item;
1496 1497 1498 1499
    RECT rect;
    CHAR name[] = "Test";
    hWndHeader = create_header_control();
    GetClientRect(hWndHeader, &rect);
1500 1501 1502
    ok(rect.right - rect.left == 670 && rect.bottom - rect.top == g_customheight,
        "Tests will fail as header size is %dx%d instead of 670x%d\n",
        rect.right - rect.left, rect.bottom - rect.top, g_customheight);
1503 1504 1505 1506 1507 1508 1509 1510

    for (i = 0; i < 3; i++)
    {
        ZeroMemory(&item, sizeof(item));
        item.mask = HDI_TEXT|HDI_WIDTH;
        item.cxy = 50*(i+1);
        item.pszText = name;
        item.lParam = i*5;
1511
        SendMessageA(hWndHeader, HDM_INSERTITEMA, i, (LPARAM)&item);
1512 1513 1514 1515 1516 1517 1518 1519 1520
    }

    run_customdraw_scenario(customdraw_1);
    run_customdraw_scenario(customdraw_2);
    run_customdraw_scenario(customdraw_3);

    ZeroMemory(&item, sizeof(item));
    item.mask = HDI_FORMAT;
    item.fmt = HDF_OWNERDRAW;
1521
    SendMessageA(hWndHeader, HDM_SETITEMA, 1, (LPARAM)&item);
1522 1523 1524 1525 1526
    g_DrawItem.CtlID = 0;
    g_DrawItem.CtlType = ODT_HEADER;
    g_DrawItem.hwndItem = hWndHeader;
    g_DrawItem.itemID = 1;
    g_DrawItem.itemState = 0;
1527
    SendMessageA(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
1528 1529 1530 1531 1532 1533 1534 1535
    run_customdraw_scenario(customdraw_4);
    ok(g_DrawItemReceived, "WM_DRAWITEM not received\n");
    DestroyWindow(hWndHeader);
    hWndHeader = NULL;
    g_DrawItem.CtlType = 0;
    g_DrawItemReceived = FALSE;
}

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
static void check_order(const int expected_id[], const int expected_order[],
                        int count, const char *type)
{
    int i;
    HDITEMA hdi;

    ok(getItemCount(hWndHeader) == count, "Invalid item count in order tests\n");
    for (i = 0; i < count; i++)
    {
        hdi.mask = HDI_LPARAM|HDI_ORDER;
1546
        SendMessageA(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
        ok(hdi.lParam == expected_id[i],
            "Invalid item ids after '%s'- item %d has lParam %d\n", type, i, (int)hdi.lParam);
        ok(hdi.iOrder == expected_order[i],
            "Invalid item order after '%s'- item %d has iOrder %d\n", type, i, hdi.iOrder);
    }
}

static void test_header_order (void)
{
    const int rand1[] = {0, 1, 1, 0, 4};
    const int rand2[] = {4, 5, 6, 7, 4};
    const int rand3[] = {5, 5, 1, 6, 1};
    const int rand4[] = {1, 5, 2, 7, 6, 1, 4, 2, 3, 2};
    const int rand5[] = {7, 8, 5, 6, 7, 2, 1, 9, 10, 10};
    const int rand6[] = {2, 8, 3, 4, 0};

    const int ids1[] = {3, 0, 2, 1, 4};
    const int ord1[] = {0, 1, 2, 3, 4};
    const int ids2[] = {3, 9, 7, 0, 2, 1, 4, 8, 6, 5};
    const int ord2[] = {0, 4, 7, 1, 2, 3, 9, 8, 6, 5};
    const int ord3[] = {0, 3, 9, 2, 1, 8, 7, 6, 5, 4};
    const int ids4[] = {9, 0, 1, 8, 6};
    const int ord4[] = {1, 0, 4, 3, 2};

    char buffer[20];
    HDITEMA hdi;
    int i;

    hWndHeader = create_header_control();

    ZeroMemory(&hdi, sizeof(HDITEMA));
    hdi.mask = HDI_TEXT | HDI_LPARAM;
    hdi.pszText = buffer;
    strcpy(buffer, "test");

    for (i = 0; i < 5; i++)
    {
        hdi.lParam = i;
1585
        SendMessageA(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
1586 1587 1588 1589 1590 1591 1592 1593
    }
    check_order(ids1, ord1, 5, "insert without iOrder");

    hdi.mask |= HDI_ORDER;
    for (i = 0; i < 5; i++)
    {
        hdi.lParam = i + 5;
        hdi.iOrder = rand2[i];
1594
        SendMessageA(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
1595 1596 1597 1598 1599 1600 1601
    }
    check_order(ids2, ord2, 10, "insert with order");

    hdi.mask = HDI_ORDER;
    for (i=0; i<10; i++)
    {
        hdi.iOrder = rand5[i];
1602
        SendMessageA(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
1603 1604 1605 1606
    }
    check_order(ids2, ord3, 10, "setitems changing order");

    for (i=0; i<5; i++)
1607
        SendMessageA(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
1608 1609 1610 1611 1612
    check_order(ids4, ord4, 5, "deleteitem");

    DestroyWindow(hWndHeader);
}

1613
static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1614
{
1615
    DRAWITEMSTRUCT *di;
1616 1617 1618 1619
    switch(msg) {

    case WM_NOTIFY:
    {
1620
        NMHEADERA *hdr = (NMHEADERA*)lParam;
1621
        EXPECTEDNOTIFY *expected;
1622
        int i;
1623 1624 1625 1626 1627

        if (hdr->hdr.code == NM_CUSTOMDRAW)
            if (g_CustomDrawProc)
                return g_CustomDrawProc(g_CustomDrawCount++, (NMCUSTOMDRAW*)hdr);

1628 1629
        for (i=0; i<nUnexpectedNotify; i++)
            ok(hdr->hdr.code != unexpectedNotify[i], "Received invalid notify %d\n", hdr->hdr.code);
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
        
        if (nReceivedNotify >= nExpectedNotify || hdr->hdr.hwndFrom != hWndHeader )
            break;

        expected = &expectedNotify[nReceivedNotify];
        if (hdr->hdr.code != expected->iCode)
            break;
        
        nReceivedNotify++;
        compare_items(hdr->hdr.code, &expected->hdItem, hdr->pitem, expected->fUnicode);
        break;
    }
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658

    case WM_DRAWITEM:
        di = (DRAWITEMSTRUCT *)lParam;
        ok(g_DrawItem.CtlType != 0, "Unexpected WM_DRAWITEM\n");
        if (g_DrawItem.CtlType == 0) return 0;
        g_DrawItemReceived = TRUE;
        compare(di->CtlType,   g_DrawItem.CtlType, "%d");
        compare(di->CtlID,     g_DrawItem.CtlID, "%d");
        compare(di->hwndItem,  g_DrawItem.hwndItem, "%p");
        compare(di->itemID,    g_DrawItem.itemID, "%d");
        compare(di->itemState, g_DrawItem.itemState, "%d");
        compare(di->rcItem.left,   g_DrawItem.rcItem.left, "%d");
        compare(di->rcItem.top,    g_DrawItem.rcItem.top, "%d");
        compare(di->rcItem.right,  g_DrawItem.rcItem.right, "%d");
        compare(di->rcItem.bottom, g_DrawItem.rcItem.bottom, "%d");
        break;

1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
  
    default:
        return DefWindowProcA(hWnd, msg, wParam, lParam);
    }
    
    return 0L;
}

1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
static void init_functions(void)
{
    HMODULE hComCtl32 = LoadLibraryA("comctl32.dll");

#define X(f) p##f = (void*)GetProcAddress(hComCtl32, #f);
    X(ImageList_Create);
    X(ImageList_Destroy);
#undef X
}

1680
static BOOL init(void)
1681
{
1682
    WNDCLASSA wc;
1683 1684 1685
    TEXTMETRICA tm;
    HFONT hOldFont;
    HDC hdc;
1686

1687 1688 1689 1690 1691
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = GetModuleHandleA(NULL);
    wc.hIcon = NULL;
1692
    wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
1693 1694 1695 1696 1697 1698
    wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "HeaderTestClass";
    wc.lpfnWndProc = HeaderTestWndProc;
    RegisterClassA(&wc);

1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
    /* The height of the header control depends on the height of the system font.
       The height of the system font is dpi dependent */
    hdc = GetDC(0);
    hOldFont = SelectObject(hdc, GetStockObject(SYSTEM_FONT));
    GetTextMetricsA(hdc, &tm);
    /* 2 dot extra space are needed for the border */
    g_customheight = tm.tmHeight + 2;
    trace("customdraw height: %d (dpi: %d)\n", g_customheight, GetDeviceCaps(hdc, LOGPIXELSY));
    SelectObject(hdc, hOldFont);
    ReleaseDC(0, hdc);

1710
    hHeaderParentWnd = CreateWindowExA(0, "HeaderTestClass", "Header test", WS_OVERLAPPEDWINDOW, 
1711 1712 1713
      CW_USEDEFAULT, CW_USEDEFAULT, 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
      226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
      NULL, NULL, GetModuleHandleA(NULL), 0);
1714 1715
    ok(hHeaderParentWnd != NULL, "failed to create parent wnd\n");

1716
    ShowWindow(hHeaderParentWnd, SW_SHOW);
1717
    return hHeaderParentWnd != NULL;
1718 1719
}

1720 1721
/* maximum 8 items allowed */
static void check_orderarray(HWND hwnd, DWORD start, DWORD set, DWORD expected,
1722
                             BOOL todo, int line)
1723 1724 1725 1726 1727
{
    int count, i;
    INT order[8];
    DWORD ret, array = 0;

1728
    count = SendMessageA(hwnd, HDM_GETITEMCOUNT, 0, 0);
1729 1730 1731 1732 1733

    /* initial order */
    for(i = 1; i<=count; i++)
        order[i-1] = start>>(4*(count-i)) & 0xf;

1734
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
1735
    ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARRAY to succeed, got %d\n", ret);
1736 1737 1738 1739

    /* new order */
    for(i = 1; i<=count; i++)
        order[i-1] = set>>(4*(count-i)) & 0xf;
1740
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
1741
    ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARRAY to succeed, got %d\n", ret);
1742 1743

    /* check actual order */
1744
    ret = SendMessageA(hwnd, HDM_GETORDERARRAY, count, (LPARAM)order);
1745
    ok_(__FILE__, line)(ret, "Expected HDM_GETORDERARRAY to succeed, got %d\n", ret);
1746 1747 1748
    for(i = 1; i<=count; i++)
        array |= order[i-1]<<(4*(count-i));

1749
    todo_wine_if(todo)
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
        ok_(__FILE__, line)(array == expected, "Expected %x, got %x\n", expected, array);
}

static void test_hdm_orderarray(void)
{
    HWND hwnd;
    INT order[5];
    DWORD ret;

    hwnd = create_header_control();

    /* three items */
    addItem(hwnd, 0, NULL);
    addItem(hwnd, 1, NULL);
    addItem(hwnd, 2, NULL);

1766
    ret = SendMessageA(hwnd, HDM_GETORDERARRAY, 3, (LPARAM)order);
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
    if (!ret)
    {
        win_skip("HDM_GETORDERARRAY not implemented.\n");
        DestroyWindow(hwnd);
        return;
    }

    expect(0, order[0]);
    expect(1, order[1]);
    expect(2, order[2]);

if (0)
{
    /* null pointer, crashes native */
1781
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 3, 0);
1782 1783 1784
    expect(FALSE, ret);
}
    /* count out of limits */
1785
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 5, (LPARAM)order);
1786 1787
    expect(FALSE, ret);
    /* count out of limits */
1788
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 2, (LPARAM)order);
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
    expect(FALSE, ret);

    /* try with out of range item index */
    /* (0,1,2)->(1,0,3) => (1,0,2) */
    check_orderarray(hwnd, 0x120, 0x103, 0x102, FALSE, __LINE__);
    /* (1,0,2)->(3,0,1) => (0,2,1) */
    check_orderarray(hwnd, 0x102, 0x301, 0x021, TRUE, __LINE__);
    /* (0,2,1)->(2,3,1) => (2,0,1) */
    check_orderarray(hwnd, 0x021, 0x231, 0x201, FALSE, __LINE__);

    /* (0,1,2)->(0,2,2) => (0,1,2) */
    check_orderarray(hwnd, 0x012, 0x022, 0x012, FALSE, __LINE__);

    addItem(hwnd, 3, NULL);

    /* (0,1,2,3)->(0,1,2,2) => (0,1,3,2) */
    check_orderarray(hwnd, 0x0123, 0x0122, 0x0132, FALSE, __LINE__);
    /* (0,1,2,3)->(0,1,3,3) => (0,1,2,3) */
    check_orderarray(hwnd, 0x0123, 0x0133, 0x0123, FALSE, __LINE__);
    /* (0,1,2,3)->(0,4,2,3) => (0,1,2,3) */
    check_orderarray(hwnd, 0x0123, 0x0423, 0x0123, FALSE, __LINE__);
    /* (0,1,2,3)->(4,0,1,2) => (0,1,3,2) */
    check_orderarray(hwnd, 0x0123, 0x4012, 0x0132, TRUE, __LINE__);
    /* (0,1,3,2)->(4,0,1,4) => (0,3,1,2) */
    check_orderarray(hwnd, 0x0132, 0x4014, 0x0312, TRUE, __LINE__);
    /* (0,1,2,3)->(4,1,0,2) => (1,0,3,2) */
    check_orderarray(hwnd, 0x0123, 0x4102, 0x1032, TRUE, __LINE__);
    /* (0,1,2,3)->(0,1,4,2) => (0,1,2,3) */
    check_orderarray(hwnd, 0x0123, 0x0142, 0x0132, FALSE, __LINE__);
    /* (0,1,2,3)->(4,4,4,4) => (0,1,2,3) */
    check_orderarray(hwnd, 0x0123, 0x4444, 0x0123, FALSE, __LINE__);
    /* (0,1,2,3)->(4,4,1,2) => (0,1,3,2) */
    check_orderarray(hwnd, 0x0123, 0x4412, 0x0132, TRUE, __LINE__);
    /* (0,1,2,3)->(4,4,4,1) => (0,2,3,1) */
    check_orderarray(hwnd, 0x0123, 0x4441, 0x0231, TRUE, __LINE__);
    /* (0,1,2,3)->(1,4,4,4) => (1,0,2,3) */
    check_orderarray(hwnd, 0x0123, 0x1444, 0x1023, FALSE, __LINE__);
    /* (0,1,2,3)->(4,2,4,1) => (0,2,3,1) */
    check_orderarray(hwnd, 0x0123, 0x4241, 0x0231, FALSE, __LINE__);
    /* (0,1,2,3)->(4,2,0,1) => (2,0,3,1) */
    check_orderarray(hwnd, 0x0123, 0x4201, 0x2031, TRUE, __LINE__);
    /* (3,2,1,0)->(4,2,0,1) => (3,2,0,1) */
    check_orderarray(hwnd, 0x3210, 0x4201, 0x3201, FALSE, __LINE__);

    DestroyWindow(hwnd);
}

1836 1837
START_TEST(header)
{
1838
    HWND parent_hwnd;
1839
    ULONG_PTR ctx_cookie;
1840
    HANDLE hCtx;
1841

1842
    init_functions();
1843
    init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1844

1845 1846
    if (!init())
        return;
1847 1848

    test_header_control();
1849
    test_item_auto_format(hHeaderParentWnd);
1850
    test_header_order();
1851
    test_hdm_orderarray();
1852
    test_customdraw();
1853 1854

    DestroyWindow(hHeaderParentWnd);
1855

1856
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1857
    parent_hwnd = create_custom_parent_window();
1858
    ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_wnd_seq, "create parent windows", FALSE);
1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870

    test_hdm_index_messages(parent_hwnd);
    test_hdm_getitemrect(parent_hwnd);
    test_hdm_hittest(parent_hwnd);
    test_hdm_layout(parent_hwnd);
    test_hdm_ordertoindex(parent_hwnd);
    test_hdm_sethotdivider(parent_hwnd);
    test_hdm_imageMessages(parent_hwnd);
    test_hdm_filterMessages(parent_hwnd);
    test_hdm_unicodeformatMessages(parent_hwnd);
    test_hdm_bitmapmarginMessages(parent_hwnd);

1871
    if (!load_v6_module(&ctx_cookie, &hCtx))
1872 1873 1874 1875 1876
    {
        DestroyWindow(parent_hwnd);
        return;
    }

1877 1878
    init_functions();

1879 1880
    /* comctl32 version 6 tests start here */
    test_hdf_fixedwidth(parent_hwnd);
1881
    test_hds_nosizing(parent_hwnd);
1882
    test_item_auto_format(parent_hwnd);
1883

1884
    unload_v6_module(ctx_cookie, hCtx);
1885 1886

    DestroyWindow(parent_hwnd);
1887
}