header.c 61.7 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 32 33 34 35
typedef struct tagEXPECTEDNOTIFY
{
    INT iCode;
    BOOL fUnicode;
    HDITEMA hdItem;
} EXPECTEDNOTIFY;

36 37
typedef LRESULT (*CUSTOMDRAWPROC)(int n, NMCUSTOMDRAW *nm);

38 39 40 41
static CUSTOMDRAWPROC g_CustomDrawProc;
static int g_CustomDrawCount;
static DRAWITEMSTRUCT g_DrawItem;
static BOOL g_DrawItemReceived;
42
static DWORD g_customheight;
43

44 45 46 47 48
static EXPECTEDNOTIFY expectedNotify[10];
static INT nExpectedNotify = 0;
static INT nReceivedNotify = 0;
static INT unexpectedNotify[10];
static INT nUnexpectedNotify = 0;
49

50
static HWND hHeaderParentWnd;
51
static HWND hWndHeader;
52 53
#define MAX_CHARS 100

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

56 57
#define expect(expected, got) ok(expected == got, "expected %d, got %d\n", expected,got)

58 59 60 61 62 63
#define NUM_MSG_SEQUENCES    2
#define PARENT_SEQ_INDEX     0
#define HEADER_SEQ_INDEX     1

static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];

64 65 66 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
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 },
93
    { WM_QUERYUISTATE, sent|optional },
94 95 96 97 98
    { WM_PARENTNOTIFY, sent },
    { 0 }
};

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

static const struct message getItem_seq[] = {
107 108
    { HDM_GETITEMA, sent|wparam, 3 },
    { HDM_GETITEMA, sent|wparam, 0 },
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
    { 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[] = {
130 131
    { HDM_SETITEMA, sent|wparam, 0 },
    { HDM_SETITEMA, sent|wparam, 1 },
132 133 134 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
    { 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 },
199 200
    { WM_PARENTNOTIFY, sent|wparam|defwinproc|optional, WM_CREATE },
    { WM_COMMAND, sent|defwinproc|optional },
201 202 203 204 205 206 207 208 209 210 211 212 213 214
    { 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 }
};

215

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

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

235
static BOOL notifies_received(void)
236 237 238
{
    BOOL fRet = (nExpectedNotify == nReceivedNotify);
    nExpectedNotify = nReceivedNotify = 0;
239
    nUnexpectedNotify = 0;
240 241 242
    return fRet;
}

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

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

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

static LONG delItem(HWND hdex, int idx)
{
292
    return SendMessageA(hdex, HDM_DELETEITEM, idx, 0);
293 294 295 296
}

static LONG getItemCount(HWND hdex)
{
297
    return SendMessageA(hdex, HDM_GETITEMCOUNT, 0, 0);
298 299 300 301 302 303 304 305
}

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

309 310
static void addReadDelItem(HWND hdex, HDITEMA *phdiCreate, int maskRead, HDITEMA *phdiRead)
{
311
    ok(SendMessageA(hdex, HDM_INSERTITEMA, 0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
312 313
    ZeroMemory(phdiRead, sizeof(HDITEMA));
    phdiRead->mask = maskRead;
314 315
    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");
316 317
}

318 319 320 321 322 323 324
static HWND create_header_control (void)
{
    HWND handle;
    HDLAYOUT hlayout;
    RECT rectwin;
    WINDOWPOS winpos;

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

    if (winetest_interactive)
	ShowWindow (hHeaderParentWnd, SW_SHOW);

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

    return handle;
}

344 345 346 347 348 349 350 351 352
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)
    {
353 354 355 356 357
        if (hdi1->pszText == LPSTR_TEXTCALLBACKA)
        {
            ok(hdi1->pszText == LPSTR_TEXTCALLBACKA, "Notify %d - only one item is LPSTR_TEXTCALLBACK\n", iCode);
        }
        else
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
        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);
            }
    }
}

377 378 379 380 381 382 383 384 385
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};
386

387 388
static char pszUniTestA[]  = "TST";
static WCHAR pszUniTestW[] = {'T','S','T',0};
389

390 391 392

#define TEST_GET_ITEM(i,c)\
{   res = getItem(hWndHeader, i, buffer);\
393
    ok(res != 0, "Getting item[%d] using valid index failed unexpectedly (%d)\n", i, res);\
394 395 396 397 398
    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);\
399
    ok(res == i, "Got Item Count as %d\n", res);\
400 401
}

402 403
static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
404
    WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
405
    static LONG defwndproc_counter = 0;
406
    struct message msg = { 0 };
407 408 409 410 411 412 413 414 415 416
    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++;
417
    ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
418 419 420 421 422 423 424
    defwndproc_counter--;

    return ret;
}

static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
425
    static LONG defwndproc_counter = 0;
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
    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;
444
        msg.id = 0;
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
        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;
465
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
    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)
{
486
    WNDPROC oldproc;
487 488 489 490 491 492 493 494 495
    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};
496
    HDITEMA hdItem;
497 498 499 500 501
    hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
    hdItem.fmt = HDF_LEFT;
    hdItem.cxy = 80;
    hdItem.cchTextMax = 260;

502
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
503

504
    childHandle = CreateWindowExA(0, WC_HEADERA, NULL,
505 506 507
                           WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
                           0, 0, 0, 0,
                           hParent, NULL, NULL, NULL);
508
    ok(childHandle != NULL, "failed to create child window\n");
509 510 511 512 513
    if (preloadHeaderItems)
    {
         for ( loopcnt = 0 ; loopcnt < 2 ; loopcnt++ )
         {
             hdItem.pszText = items[loopcnt];
514
             retVal = SendMessageA(childHandle, HDM_INSERTITEMA, loopcnt, (LPARAM) &hdItem);
515 516 517 518 519 520 521 522 523 524 525 526 527 528
             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);

529 530 531
    oldproc = (WNDPROC)SetWindowLongPtrA(childHandle, GWLP_WNDPROC,
                                         (LONG_PTR)header_subclass_proc);
    SetWindowLongPtrA(childHandle, GWLP_USERDATA, (LONG_PTR)oldproc);
532 533 534
    return childHandle;
}

535 536 537 538
static void check_auto_format(void)
{
    HDITEMA hdiCreate;
    HDITEMA hdiRead;
539
    static CHAR text[] = "Test";
540 541 542 543
    ZeroMemory(&hdiCreate, sizeof(HDITEMA));

    /* Windows implicitly sets some format bits in INSERTITEM */

544
    /* HDF_STRING is automatically set and cleared for no text */
545
    hdiCreate.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;
546
    hdiCreate.pszText = text;
547 548 549 550 551 552
    hdiCreate.cxy = 100;
    hdiCreate.fmt=HDF_CENTER;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == (HDF_STRING|HDF_CENTER), "HDF_STRING not set automatically (fmt=%x)\n", hdiRead.fmt);

    hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
553
    hdiCreate.pszText = text;
554 555 556 557 558 559 560 561 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
    hdiCreate.fmt = HDF_CENTER|HDF_STRING;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == (HDF_CENTER), "HDF_STRING should be automatically cleared (fmt=%x)\n", hdiRead.fmt);

    /* HDF_BITMAP is automatically set and cleared for a NULL bitmap or no bitmap */
    hdiCreate.mask = HDI_BITMAP|HDI_WIDTH|HDI_FORMAT;
    hdiCreate.hbm = CreateBitmap(16, 16, 1, 8, NULL);
    hdiCreate.fmt = HDF_CENTER;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == (HDF_BITMAP|HDF_CENTER), "HDF_BITMAP not set automatically (fmt=%x)\n", hdiRead.fmt);
    DeleteObject(hdiCreate.hbm);

    hdiCreate.hbm = NULL;
    hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for NULL bitmap (fmt=%x)\n", hdiRead.fmt);

    hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
    hdiCreate.fmt = HDF_CENTER|HDF_BITMAP;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == HDF_CENTER, "HDF_BITMAP not cleared automatically for no bitmap (fmt=%x)\n", hdiRead.fmt);

    /* HDF_IMAGE is automatically set but not cleared */
    hdiCreate.mask = HDI_IMAGE|HDI_WIDTH|HDI_FORMAT;
    hdiCreate.iImage = 17;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == (HDF_IMAGE|HDF_CENTER), "HDF_IMAGE not set automatically (fmt=%x)\n", hdiRead.fmt);

    hdiCreate.mask = HDI_WIDTH|HDI_FORMAT;
    hdiCreate.fmt = HDF_CENTER|HDF_IMAGE;
    hdiCreate.iImage = 0;
    addReadDelItem(hWndHeader, &hdiCreate, HDI_FORMAT, &hdiRead);
    ok(hdiRead.fmt == (HDF_CENTER|HDF_IMAGE), "HDF_IMAGE shouldn't be cleared automatically (fmt=%x)\n", hdiRead.fmt);
}

589 590 591 592
static void check_auto_fields(void)
{
    HDITEMA hdiCreate;
    HDITEMA hdiRead;
593
    static CHAR text[] = "Test";
594
    LONG res;
595 596 597 598 599

    /* 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;
600
    hdiCreate.pszText = text;
601 602 603 604 605 606
    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;
607
    hdiCreate.pszText = text;
608 609 610 611 612 613 614
    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;
615
    hdiCreate.pszText = text;
616 617 618 619 620 621 622 623
    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;
624
    hdiCreate.pszText = text;
625 626 627 628 629 630 631 632 633
    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;
634
    hdiCreate.pszText = text;
635 636 637 638 639 640 641
    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 */
}

642
static void check_mask(void)
643 644
{
    HDITEMA hdi;
645
    static CHAR text[] = "ABC";
646 647 648 649 650 651
    LRESULT ret;

    /* don't create items if the mask is zero */
    ZeroMemory(&hdi, sizeof(hdi));
    hdi.mask = 0;
    hdi.cxy = 200;
652
    hdi.pszText = text;
653 654 655 656
    hdi.fmt = 0;
    hdi.iOrder = 0;
    hdi.lParam = 17;
    hdi.cchTextMax = 260;
657
    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
658
    ok(ret == -1, "Creating an item with a zero mask should have failed\n");
659
    if (ret != -1) SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
660 661 662 663

    /* with a non-zero mask creation will succeed */
    ZeroMemory(&hdi, sizeof(hdi));
    hdi.mask = HDI_LPARAM;
664
    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
665 666
    ok(ret != -1, "Adding item with non-zero mask failed\n");
    if (ret != -1)
667
        SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
668 669 670 671 672 673

    /* 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;
674
    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
675 676 677 678 679 680 681
    ok(ret != -1, "Adding item failed\n");

    if (ret != -1)
    {
        /* check result */
        ZeroMemory(&hdi, sizeof(hdi));
        hdi.mask = HDI_LPARAM | HDI_IMAGE;
682
        SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
683 684 685 686 687 688
        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;
689
        SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
690 691 692
        ok(hdi.lParam == 133, "comctl32 4.0 field not read\n");
        ok(hdi.iImage == 0, "comctl32 >4.0 field shouldn't be read\n");

693
        SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
694 695 696
    }
}

697 698 699 700 701 702 703 704 705 706 707 708
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]);
709
        ok(res == 0, "Adding simple item failed (%d)\n", res);
710 711 712 713
    }

    TEST_GET_ITEMCOUNT(4);
    res = addItem(hWndHeader, 99, str_items[i+1]);
714
    ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
715 716
    TEST_GET_ITEMCOUNT(5);
    res = addItem(hWndHeader, 5, str_items[i+1]);
717
    ok(res != -1, "Adding Out of Range item should fail with -1 got (%d)\n", res);
718 719 720 721 722
    TEST_GET_ITEMCOUNT(6);

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

    res=getItem(hWndHeader, 99, buffer);
723
    ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
724
    res=getItem(hWndHeader, 5, buffer);
725
    ok(res == 1, "Getting Out of Range item should fail with 1 (%d), got %s\n", res,buffer);
726
    res=getItem(hWndHeader, -2, buffer);
727
    ok(res == 0, "Getting Out of Range item should fail with 0 (%d), got %s\n", res,buffer);
728 729 730 731 732 733 734 735

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

    TEST_GET_ITEMCOUNT(6);
736
    res=setItem(hWndHeader, 99, str_items[5], FALSE);
737
    ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
738
    res=setItem(hWndHeader, 5, str_items[5], TRUE);
739
    ok(res == 1, "Setting Out of Range item should fail with 1 (%d)\n", res);
740
    res=setItem(hWndHeader, -2, str_items[5], FALSE);
741
    ok(res == 0, "Setting Out of Range item should fail with 0 (%d)\n", res);
742 743 744 745
    TEST_GET_ITEMCOUNT(6);

    for (i = 0; i < 4; i++)
    {
746
        res = setItem(hWndHeader, i, str_items[4], TRUE);
747
        ok(res != 0, "Setting %d item failed (%d)\n", i+1, res);
748 749 750
        TEST_GET_ITEM(i, 4);
        TEST_GET_ITEMCOUNT(6);
    }
751 752

    SendMessageA(hWndHeader, HDM_SETUNICODEFORMAT, TRUE, 0);
753
    setItemUnicodeNotify(hWndHeader, 3, pszUniTestA, pszUniTestW);
754
    SendMessageA(hWndHeader, WM_NOTIFYFORMAT, (WPARAM)hHeaderParentWnd, NF_REQUERY);
755
    setItem(hWndHeader, 3, str_items[4], TRUE);
756 757 758 759 760 761 762 763 764 765 766
    
    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);
767

768 769
    check_auto_format();
    TEST_GET_ITEMCOUNT(6);
770 771
    check_auto_fields();
    TEST_GET_ITEMCOUNT(6);
772 773
    check_mask();
    TEST_GET_ITEMCOUNT(6);
774

775
    res = delItem(hWndHeader, 5);
776
    ok(res == 1, "Deleting Out of Range item should fail with 1 (%d)\n", res);
777
    res = delItem(hWndHeader, -2);
778
    ok(res == 0, "Deleting Out of Range item should fail with 0 (%d)\n", res);
779 780 781
    TEST_GET_ITEMCOUNT(5);

    res = delItem(hWndHeader, 3);
782
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
783 784
    TEST_GET_ITEMCOUNT(4);
    res = delItem(hWndHeader, 0);
785
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
786 787
    TEST_GET_ITEMCOUNT(3);
    res = delItem(hWndHeader, 0);
788
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
789 790
    TEST_GET_ITEMCOUNT(2);
    res = delItem(hWndHeader, 0);
791
    ok(res != 0, "Deleting using out of range index failed (%d)\n", res);
792 793 794 795 796
    TEST_GET_ITEMCOUNT(1);

    DestroyWindow(hWndHeader);
}

797
static void test_hdm_getitemrect(HWND hParent)
798
{
799 800

    HWND hChild;
801 802
    RECT rect;
    int retVal;
803 804

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
805
    hChild = create_custom_header_control(hParent, TRUE);
806
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
807
                                    "adder header control to parent", FALSE);
808

809
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
810
    ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
811
    /* check bounding rectangle information of 2nd header item */
812 813 814
    expect(80, rect.left);
    expect(0, rect.top);
    expect(160, rect.right);
815 816
    expect(g_customheight, rect.bottom);

817
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
818 819

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

824
    expect(80, rect.right);
825 826
    expect(g_customheight, rect.bottom);

827
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
828
    ok(retVal == 0, "Getting rect of nonexistent item should return 0, got %d\n", retVal);
829 830

    ok_sequence(sequences, HEADER_SEQ_INDEX, getItemRect_seq, "getItemRect sequence testing", FALSE);
831
    DestroyWindow(hChild);
832 833
}

834
static void test_hdm_layout(HWND hParent)
835
{
836
    HWND hChild;
837 838 839 840 841 842
    int retVal;
    RECT rect;
    HDLAYOUT hdLayout;
    WINDOWPOS windowPos;
    hdLayout.prc = &rect;
    hdLayout.pwpos = &windowPos;
843 844

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
845
    hChild = create_custom_header_control(hParent, TRUE);
846
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
847
                                    "adder header control to parent", FALSE);
848 849

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
850
    retVal = SendMessageA(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
851
    expect(TRUE, retVal);
852 853 854

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

855
    DestroyWindow(hChild);
856 857
}

858
static void test_hdm_ordertoindex(HWND hParent)
859
{
860
    HWND hChild;
861
    int retVal;
862

863
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
864
    hChild = create_custom_header_control(hParent, TRUE);
865
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
866
                                    "adder header control to parent", FALSE);
867 868

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
869
    retVal = SendMessageA(hChild, HDM_ORDERTOINDEX, 1, 0);
870
    expect(1, retVal);
871 872

    ok_sequence(sequences, HEADER_SEQ_INDEX, orderToIndex_seq, "orderToIndex sequence testing", FALSE);
873
    DestroyWindow(hChild);
874 875
}

876
static void test_hdm_hittest(HWND hParent)
877
{
878
    HWND hChild;
879 880 881
    int retVal;
    POINT pt;
    HDHITTESTINFO hdHitTestInfo;
882 883
    const int firstItemRightBoundary = 80;
    const int secondItemRightBoundary = 160;
884
    const int bottomBoundary = g_customheight;
885 886 887

    pt.x = firstItemRightBoundary - 1;
    pt.y = bottomBoundary - 1;
888 889
    hdHitTestInfo.pt = pt;

890 891

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
892
    hChild = create_custom_header_control(hParent, TRUE);
893
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
894
                                    "adder header control to parent", FALSE);
895 896

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
897
    retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
898 899
    expect(0, retVal);
    expect(0, hdHitTestInfo.iItem);
900
    expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
901 902 903

    pt.x = secondItemRightBoundary - 1;
    pt.y = bottomBoundary - 1;
904
    hdHitTestInfo.pt = pt;
905
    retVal = SendMessageA(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
906
    expect(1, retVal);
907
    expect(1, hdHitTestInfo.iItem);
908
    expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
909

910 911
    pt.x = secondItemRightBoundary;
    pt.y = bottomBoundary + 1;
912
    hdHitTestInfo.pt = pt;
913
    retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
914 915 916
    expect(-1, retVal);
    expect(-1, hdHitTestInfo.iItem);
    expect(HHT_BELOW, hdHitTestInfo.flags);
917

918 919
    ok_sequence(sequences, HEADER_SEQ_INDEX, hittest_seq, "hittest sequence testing", FALSE);

920
    DestroyWindow(hChild);
921 922
}

923
static void test_hdm_sethotdivider(HWND hParent)
924
{
925
    HWND hChild;
926 927 928 929
    int retVal;
    /*  low word: x coordinate = 5
     *  high word:  y coordinate = 5
     */
930 931

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
932
    hChild = create_custom_header_control(hParent, TRUE);
933
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
934
                                    "adder header control to parent", FALSE);
935

936
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
937
    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, TRUE, MAKELPARAM(5, 5));
938 939
    expect(0, retVal);

940
    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
941
    expect(100, retVal);
942
    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
943
    expect(1, retVal);
944 945 946 947 948 949
    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);
950 951

    DestroyWindow(hChild);
952 953
}

954
static void test_hdm_imageMessages(HWND hParent)
955
{
956
    HIMAGELIST hImageList = ImageList_Create (4, 4, 0, 1, 0);
957
    HIMAGELIST hIml;
958
    BOOL wasValid;
959 960
    HWND hChild;

961
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
962
    hChild = create_custom_header_control(hParent, TRUE);
963
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
964
                                    "adder header control to parent", FALSE);
965 966

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
967

968
    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
969
    ok(hIml == NULL, "Expected NULL, got %p\n", hIml);
970

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

974
    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
975 976
    ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
    ImageList_Destroy(hIml);
977

978 979
    ok_sequence(sequences, HEADER_SEQ_INDEX, imageMessages_seq, "imageMessages sequence testing", FALSE);

980
    DestroyWindow(hChild);
981 982 983

    wasValid = ImageList_Destroy(hImageList);
    ok(wasValid, "Header must not free image list at destruction!\n");
984 985
}

986
static void test_hdm_filterMessages(HWND hParent)
987
{
988
    HWND hChild;
989
    int retVal, timeout;
990

991
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
992
    hChild = create_custom_header_control(hParent, TRUE);
993
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
994
                                    "adder header control to parent", FALSE);
995

996 997 998 999 1000 1001 1002 1003 1004
    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);

1005
    timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1006 1007 1008
    ok(timeout == -100, "got %d\n", timeout);
    retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
    ok(retVal == 100, "got %d\n", retVal);
1009

1010
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1011 1012 1013 1014 1015 1016 1017

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

1018
    retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
1019 1020
    expect(timeout, retVal);

1021 1022
    todo_wine
    {
1023
        retVal = SendMessageA(hChild, HDM_CLEARFILTER, 0, 1);
1024 1025 1026 1027 1028
        if (retVal == 0)
            win_skip("HDM_CLEARFILTER needs 5.80\n");
        else
            expect(1, retVal);

1029
        retVal = SendMessageA(hChild, HDM_EDITFILTER, 1, 0);
1030 1031 1032 1033
        if (retVal == 0)
            win_skip("HDM_EDITFILTER needs 5.80\n");
        else
            expect(1, retVal);
1034
    }
1035 1036 1037 1038 1039
    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,
1040
                     "filterMessages sequence testing", FALSE);
1041 1042
    DestroyWindow(hChild);

1043 1044
}

1045
static void test_hdm_unicodeformatMessages(HWND hParent)
1046
{
1047
    HWND hChild;
1048
    int retVal;
1049 1050

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1051
    hChild = create_custom_header_control(hParent, TRUE);
1052
    ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
1053
                                    "adder header control to parent", FALSE);
1054 1055

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1056
    retVal = SendMessageA(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
1057
    expect(0, retVal);
1058
    retVal = SendMessageA(hChild, HDM_GETUNICODEFORMAT, 0, 0);
1059
    expect(1, retVal);
1060 1061 1062

    ok_sequence(sequences, HEADER_SEQ_INDEX, unicodeformatMessages_seq,
                     "unicodeformatMessages sequence testing", FALSE);
1063
    DestroyWindow(hChild);
1064 1065
}

1066
static void test_hdm_bitmapmarginMessages(HWND hParent)
1067
{
1068
    HWND hChild;
1069
    int retVal;
1070 1071

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

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1077
    retVal = SendMessageA(hChild, HDM_GETBITMAPMARGIN, 0, 0);
1078 1079 1080 1081
    if (retVal == 0)
        win_skip("HDM_GETBITMAPMARGIN needs 5.80\n");
    else
        expect(6, retVal);
1082 1083 1084

    ok_sequence(sequences, HEADER_SEQ_INDEX, bitmapmarginMessages_seq,
                      "bitmapmarginMessages sequence testing", FALSE);
1085
    DestroyWindow(hChild);
1086 1087
}

1088
static void test_hdm_index_messages(HWND hParent)
1089
{
1090
    HWND hChild;
1091
    int retVal, i, iSize;
1092
    static const int lpiarray[2] = {1, 0};
1093 1094 1095
    static const char *item_texts[] = {
        "Name", "Size", "Type", "Date Modified"
    };
1096
    RECT rect;
1097
    HDITEMA hdItem;
1098
    char buffA[32];
1099
    int array[2];
1100

1101
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1102
    hChild = create_custom_header_control(hParent, FALSE);
1103 1104 1105 1106 1107
    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,
1108
                                     "adder header control to parent", FALSE);
1109
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1110
    for (i = 0; i < sizeof(item_texts)/sizeof(item_texts[0]); i++)
1111
    {
1112
        hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
1113
        hdItem.pszText = (char*)item_texts[i];
1114 1115 1116 1117 1118
        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);
1119
    }
1120 1121 1122
    ok_sequence(sequences, HEADER_SEQ_INDEX, insertItem_seq, "insertItem sequence testing", FALSE);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
1123

1124
    retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1125
    ok(retVal == TRUE, "Deleting item 3 should return TRUE, got %d\n", retVal);
1126
    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1127 1128
    ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);

1129
    retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
1130
    ok(retVal == FALSE, "Deleting already-deleted item should return FALSE, got %d\n", retVal);
1131
    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1132 1133
    ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);

1134
    retVal = SendMessageA(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
1135
    ok(retVal == TRUE, "Deleting item 2 should return TRUE, got %d\n", retVal);
1136
    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1137 1138
    ok(retVal == 2, "Getting item count should return 2, got %d\n", retVal);

1139 1140 1141 1142 1143
    ok_sequence(sequences, HEADER_SEQ_INDEX, deleteItem_getItemCount_seq,
                         "deleteItem_getItemCount sequence testing", FALSE);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

1144
    hdItem.mask = HDI_WIDTH;
1145
    retVal = SendMessageA(hChild, HDM_GETITEMA, 3, (LPARAM) &hdItem);
1146 1147
    ok(retVal == FALSE, "Getting already-deleted item should return FALSE, got %d\n", retVal);

1148 1149 1150
    hdItem.mask = HDI_TEXT | HDI_WIDTH;
    hdItem.pszText = buffA;
    hdItem.cchTextMax = sizeof(buffA)/sizeof(buffA[0]);
1151
    retVal = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM) &hdItem);
1152
    ok(retVal == TRUE, "Getting the 1st header item should return TRUE, got %d\n", retVal);
1153 1154 1155

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

1156
    /* check if the item is the right one */
1157 1158
    ok(!strcmp(hdItem.pszText, item_texts[0]), "got wrong item %s, expected %s\n",
        hdItem.pszText, item_texts[0]);
1159 1160
    expect(80, hdItem.cxy);

1161
    iSize = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
1162 1163 1164

    /* item should be updated just after accepting new array */
    ShowWindow(hChild, SW_HIDE);
1165
    retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
1166 1167
    expect(TRUE, retVal);
    rect.left = 0;
1168
    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
1169
    expect(TRUE, retVal);
1170
    ok(rect.left != 0, "Expected updated rectangle\n");
1171

1172 1173
    flush_sequences(sequences, NUM_MSG_SEQUENCES);

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

1177
    retVal = SendMessageA(hChild, HDM_GETORDERARRAY, 2, (LPARAM) array);
1178
    ok(retVal == TRUE, "Getting header items order should return TRUE, got %d\n", retVal);
1179 1180 1181

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

1182
    /* check if the array order is set correctly and the size of the array is correct. */
1183
    expect(2, iSize);
1184 1185
    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]);
1186 1187 1188

    hdItem.mask = HDI_FORMAT;
    hdItem.fmt = HDF_CENTER | HDF_STRING;
1189 1190 1191

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

1192
    retVal = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM) &hdItem);
1193 1194
    ok(retVal == TRUE, "Aligning 1st header item to center should return TRUE, got %d\n", retVal);
    hdItem.fmt = HDF_RIGHT | HDF_STRING;
1195
    retVal = SendMessageA(hChild, HDM_SETITEMA, 1, (LPARAM) &hdItem);
1196 1197
    ok(retVal == TRUE, "Aligning 2nd header item to right should return TRUE, got %d\n", retVal);

1198 1199
    ok_sequence(sequences, HEADER_SEQ_INDEX, setItem_seq, "setItem sequence testing", FALSE);
    DestroyWindow(hChild);
1200
}
1201

1202 1203 1204
static void test_hdf_fixedwidth(HWND hParent)
{
    HWND hChild;
1205
    HDITEMA hdItem;
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
    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;

1216
    ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
1217 1218 1219 1220
    expect(0, ret);

    /* try to change width */
    rect.right = rect.bottom = 0;
1221
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1222 1223 1224
    ok(rect.right  != 0, "Expected not zero width\n");
    ok(rect.bottom != 0, "Expected not zero height\n");

1225 1226 1227
    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));
1228

1229
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241

    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;

1242
    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1243 1244 1245
    expect(TRUE, ret);

    rect.right = 0;
1246
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1247 1248 1249 1250 1251
    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;
1252
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1253 1254 1255 1256 1257 1258
    expect(HHT_ONHEADER, ht.flags);

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

1259
    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1260 1261 1262 1263
    expect(TRUE, ret);

    ht.pt.x = 90;
    ht.pt.y = rect.bottom / 2;
1264
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1265 1266 1267 1268 1269
    expect(HHT_ONDIVIDER, ht.flags);

    DestroyWindow(hChild);
}

1270 1271 1272
static void test_hds_nosizing(HWND hParent)
{
    HWND hChild;
1273
    HDITEMA hdItem;
1274 1275 1276 1277 1278 1279
    DWORD ret;
    RECT rect;
    HDHITTESTINFO ht;

    hChild = create_custom_header_control(hParent, FALSE);

1280
    memset(&hdItem, 0, sizeof(hdItem));
1281 1282 1283
    hdItem.mask = HDI_WIDTH;
    hdItem.cxy = 80;

1284
    ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
1285 1286 1287
    expect(0, ret);

    /* HDS_NOSIZING only blocks hittesting */
1288 1289
    ret = GetWindowLongA(hChild, GWL_STYLE);
    SetWindowLongA(hChild, GWL_STYLE, ret | HDS_NOSIZING);
1290 1291 1292

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

1297 1298 1299
    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));
1300

1301
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311

    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;
1312
    ret = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM)&hdItem);
1313 1314 1315 1316 1317 1318 1319
    expect(TRUE, ret);
    ok(!(hdItem.fmt & HDF_FIXEDWIDTH), "Unexpected HDF_FIXEDWIDTH\n");

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

1320
    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
1321 1322 1323
    expect(TRUE, ret);

    rect.right = 0;
1324
    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
1325 1326 1327 1328 1329
    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;
1330
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1331 1332 1333
    expect(HHT_ONHEADER, ht.flags);

    /* try to adjust with message */
1334 1335
    ret = GetWindowLongA(hChild, GWL_STYLE);
    SetWindowLongA(hChild, GWL_STYLE, ret & ~HDS_NOSIZING);
1336 1337 1338

    ht.pt.x = 90;
    ht.pt.y = rect.bottom / 2;
1339
    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
1340 1341 1342 1343 1344
    expect(HHT_ONDIVIDER, ht.flags);

    DestroyWindow(hChild);
}

1345 1346 1347 1348 1349
#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); \
1350 1351
    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 */ \
1352 1353
        "Invalid rect (%d,%d)-(%d,%d) vs %s\n", _left, _top, _right, _bottom, \
        wine_dbgstr_rect(&nm->rc));
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365

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 */
1366
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1367 1368 1369
        return 0;
    }

1370
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
    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:
1384
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1385 1386
        return CDRF_NOTIFYITEMDRAW;
    case 1:
1387
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1388 1389
        return 0;
    case 2:
1390
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1391 1392
        return 0;
    case 3:
1393
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1394 1395 1396
        return 0;
    }

1397
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
    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:
1411
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1412 1413
        return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTERASE|CDRF_NOTIFYPOSTPAINT|CDRF_SKIPDEFAULT;
    case 1:
1414
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1415 1416
        return 0;
    case 2:
1417
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 1, 5, 50, 0, 150, g_customheight);
1418 1419
        return 0;
    case 3:
1420
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1421 1422
        return 0;
    case 4:
1423
        TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1424 1425 1426
        return 0;
    }

1427
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
    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:
1442
        TEST_NMCUSTOMDRAW(CDDS_PREPAINT, -1, 0, 0, 0, 670, g_customheight);
1443 1444
        return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTPAINT;
    case 1:
1445
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 0, 0, 0, 0, 50, g_customheight);
1446 1447
        return 0;
    case 2:
1448
        TEST_NMCUSTOMDRAW(CDDS_ITEMPREPAINT, 2, 10, 150, 0, 300, g_customheight);
1449 1450
        return 0;
    case 3:
1451
        TEST_NMCUSTOMDRAW(CDDS_POSTPAINT, -1, 0, 0, 0, 670, g_customheight);
1452 1453 1454
        return 0;
    }

1455
    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
    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;
}

1469
static void test_customdraw(void)
1470 1471
{
    int i;
1472
    HDITEMA item;
1473 1474 1475 1476
    RECT rect;
    CHAR name[] = "Test";
    hWndHeader = create_header_control();
    GetClientRect(hWndHeader, &rect);
1477 1478 1479
    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);
1480 1481 1482 1483 1484 1485 1486 1487

    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;
1488
        SendMessageA(hWndHeader, HDM_INSERTITEMA, i, (LPARAM)&item);
1489 1490 1491 1492 1493 1494 1495 1496 1497
    }

    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;
1498
    SendMessageA(hWndHeader, HDM_SETITEMA, 1, (LPARAM)&item);
1499 1500 1501 1502 1503
    g_DrawItem.CtlID = 0;
    g_DrawItem.CtlType = ODT_HEADER;
    g_DrawItem.hwndItem = hWndHeader;
    g_DrawItem.itemID = 1;
    g_DrawItem.itemState = 0;
1504
    SendMessageA(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
1505 1506 1507 1508 1509 1510 1511 1512
    run_customdraw_scenario(customdraw_4);
    ok(g_DrawItemReceived, "WM_DRAWITEM not received\n");
    DestroyWindow(hWndHeader);
    hWndHeader = NULL;
    g_DrawItem.CtlType = 0;
    g_DrawItemReceived = FALSE;
}

1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
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;
1523
        SendMessageA(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
        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;
1562
        SendMessageA(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
1563 1564 1565 1566 1567 1568 1569 1570
    }
    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];
1571
        SendMessageA(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
1572 1573 1574 1575 1576 1577 1578
    }
    check_order(ids2, ord2, 10, "insert with order");

    hdi.mask = HDI_ORDER;
    for (i=0; i<10; i++)
    {
        hdi.iOrder = rand5[i];
1579
        SendMessageA(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
1580 1581 1582 1583
    }
    check_order(ids2, ord3, 10, "setitems changing order");

    for (i=0; i<5; i++)
1584
        SendMessageA(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
1585 1586 1587 1588 1589
    check_order(ids4, ord4, 5, "deleteitem");

    DestroyWindow(hWndHeader);
}

1590
static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1591
{
1592
    DRAWITEMSTRUCT *di;
1593 1594 1595 1596
    switch(msg) {

    case WM_NOTIFY:
    {
1597
        NMHEADERA *hdr = (NMHEADERA*)lParam;
1598
        EXPECTEDNOTIFY *expected;
1599
        int i;
1600 1601 1602 1603 1604

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

1605 1606
        for (i=0; i<nUnexpectedNotify; i++)
            ok(hdr->hdr.code != unexpectedNotify[i], "Received invalid notify %d\n", hdr->hdr.code);
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
        
        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;
    }
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635

    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;

1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
  
    default:
        return DefWindowProcA(hWnd, msg, wParam, lParam);
    }
    
    return 0L;
}

1647
static BOOL init(void)
1648 1649 1650
{
    HMODULE hComctl32;
    BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
1651
    WNDCLASSA wc;
1652
    INITCOMMONCONTROLSEX iccex;
1653 1654 1655
    TEXTMETRICA tm;
    HFONT hOldFont;
    HDC hdc;
1656 1657 1658 1659 1660

    hComctl32 = GetModuleHandleA("comctl32.dll");
    pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
    if (!pInitCommonControlsEx)
    {
1661
        win_skip("InitCommonControlsEx() is missing. Skipping the tests\n");
1662
        return FALSE;
1663
    }
1664

1665 1666 1667
    iccex.dwSize = sizeof(iccex);
    iccex.dwICC  = ICC_USEREX_CLASSES;
    pInitCommonControlsEx(&iccex);
1668 1669 1670 1671 1672 1673

    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = GetModuleHandleA(NULL);
    wc.hIcon = NULL;
1674
    wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
1675 1676 1677 1678 1679 1680
    wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "HeaderTestClass";
    wc.lpfnWndProc = HeaderTestWndProc;
    RegisterClassA(&wc);

1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
    /* 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);

1692
    hHeaderParentWnd = CreateWindowExA(0, "HeaderTestClass", "Header test", WS_OVERLAPPEDWINDOW, 
1693 1694 1695
      CW_USEDEFAULT, CW_USEDEFAULT, 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
      226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
      NULL, NULL, GetModuleHandleA(NULL), 0);
1696 1697
    ok(hHeaderParentWnd != NULL, "failed to create parent wnd\n");

1698
    ShowWindow(hHeaderParentWnd, SW_SHOW);
1699
    return hHeaderParentWnd != NULL;
1700 1701
}

1702 1703
/* maximum 8 items allowed */
static void check_orderarray(HWND hwnd, DWORD start, DWORD set, DWORD expected,
1704
                             BOOL todo, int line)
1705 1706 1707 1708 1709
{
    int count, i;
    INT order[8];
    DWORD ret, array = 0;

1710
    count = SendMessageA(hwnd, HDM_GETITEMCOUNT, 0, 0);
1711 1712 1713 1714 1715

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

1716
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
1717
    ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARRAY to succeed, got %d\n", ret);
1718 1719 1720 1721

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

    /* check actual order */
1726
    ret = SendMessageA(hwnd, HDM_GETORDERARRAY, count, (LPARAM)order);
1727
    ok_(__FILE__, line)(ret, "Expected HDM_GETORDERARRAY to succeed, got %d\n", ret);
1728 1729 1730
    for(i = 1; i<=count; i++)
        array |= order[i-1]<<(4*(count-i));

1731
    todo_wine_if(todo)
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747
        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);

1748
    ret = SendMessageA(hwnd, HDM_GETORDERARRAY, 3, (LPARAM)order);
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
    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 */
1763
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 3, 0);
1764 1765 1766
    expect(FALSE, ret);
}
    /* count out of limits */
1767
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 5, (LPARAM)order);
1768 1769
    expect(FALSE, ret);
    /* count out of limits */
1770
    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 2, (LPARAM)order);
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 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
    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);
}

1818 1819
START_TEST(header)
{
1820
    HWND parent_hwnd;
1821
    ULONG_PTR ctx_cookie;
1822
    HANDLE hCtx;
1823

1824 1825
    if (!init())
        return;
1826 1827

    test_header_control();
1828
    test_header_order();
1829
    test_hdm_orderarray();
1830
    test_customdraw();
1831 1832

    DestroyWindow(hHeaderParentWnd);
1833 1834 1835

    init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
    parent_hwnd = create_custom_parent_window();
1836
    ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_wnd_seq, "create parent windows", FALSE);
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848

    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);

1849
    if (!load_v6_module(&ctx_cookie, &hCtx))
1850 1851 1852 1853 1854 1855 1856
    {
        DestroyWindow(parent_hwnd);
        return;
    }

    /* comctl32 version 6 tests start here */
    test_hdf_fixedwidth(parent_hwnd);
1857
    test_hds_nosizing(parent_hwnd);
1858

1859
    unload_v6_module(ctx_cookie, hCtx);
1860 1861

    DestroyWindow(parent_hwnd);
1862
}