git.oblomov.eu Git - wine/blob - dlls/comctl32/tests/listview.c

   1 /*
   2  * ListView tests
   3  *
   4  * Copyright 2006 Mike McCormack for CodeWeavers
   5  * Copyright 2007 George Gov
   6  * Copyright 2009 Nikolay Sivov
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdio.h>
  24 #include <windows.h>
  25 #include <commctrl.h>
  26
  27 #include "wine/test.h"
  28 #include "v6util.h"
  29 #include "msg.h"
  30
  31 #define PARENT_SEQ_INDEX       0
  32 #define PARENT_FULL_SEQ_INDEX  1
  33 #define LISTVIEW_SEQ_INDEX     2
  34 #define EDITBOX_SEQ_INDEX      3
  35 #define COMBINED_SEQ_INDEX     4
  36 #define NUM_MSG_SEQUENCES      5
  37
  38 #define LISTVIEW_ID 0
  39 #define HEADER_ID   1
  40
  41 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  42 #define expect2(expected1, expected2, got1, got2) ok(expected1 == got1 && expected2 == got2, \
  43        "expected (%d,%d), got (%d,%d)\n", expected1, expected2, got1, got2)
  44
  45 static const WCHAR testparentclassW[] =
  46     {'L','i','s','t','v','i','e','w',' ','t','e','s','t',' ','p','a','r','e','n','t','W', 0};
  47
  48 static HWND hwndparent, hwndparentW;
  49 /* prevents edit box creation, LVN_BEGINLABELEDIT return value */
  50 static BOOL blockEdit;
  51 /* return nonzero on NM_HOVER */
  52 static BOOL g_block_hover;
  53 /* dumps LVN_ITEMCHANGED message data */
  54 static BOOL g_dump_itemchanged;
  55 /* format reported to control:
  56    -1 falls to defproc, anything else returned */
  57 static INT  notifyFormat;
  58 /* indicates we're running < 5.80 version */
  59 static BOOL g_is_below_5;
  60 /* item data passed to LVN_GETDISPINFOA */
  61 static LVITEMA g_itema;
  62
  63 static HWND subclass_editbox(HWND hwndListview);
  64
  65 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
  66
  67 static const struct message create_ownerdrawfixed_parent_seq[] = {
  68     { WM_NOTIFYFORMAT, sent },
  69     { WM_QUERYUISTATE, sent|optional }, /* Win2K and higher */
  70     { WM_MEASUREITEM, sent },
  71     { WM_PARENTNOTIFY, sent },
  72     { 0 }
  73 };
  74
  75 static const struct message redraw_listview_seq[] = {
  76     { WM_PAINT,      sent|id,            0, 0, LISTVIEW_ID },
  77     { WM_PAINT,      sent|id,            0, 0, HEADER_ID },
  78     { WM_NCPAINT,    sent|id|defwinproc, 0, 0, HEADER_ID },
  79     { WM_ERASEBKGND, sent|id|defwinproc|optional, 0, 0, HEADER_ID },
  80     { WM_NOTIFY,     sent|id|defwinproc, 0, 0, LISTVIEW_ID },
  81     { WM_NCPAINT,    sent|id|defwinproc, 0, 0, LISTVIEW_ID },
  82     { WM_ERASEBKGND, sent|id|defwinproc|optional, 0, 0, LISTVIEW_ID },
  83     { 0 }
  84 };
  85
  86 static const struct message listview_icon_spacing_seq[] = {
  87     { LVM_SETICONSPACING, sent|lparam, 0, MAKELPARAM(20, 30) },
  88     { LVM_SETICONSPACING, sent|lparam, 0, MAKELPARAM(25, 35) },
  89     { LVM_SETICONSPACING, sent|lparam, 0, MAKELPARAM(-1, -1) },
  90     { 0 }
  91 };
  92
  93 static const struct message listview_color_seq[] = {
  94     { LVM_SETBKCOLOR,     sent|lparam, 0, RGB(0,0,0) },
  95     { LVM_GETBKCOLOR,     sent },
  96     { LVM_SETTEXTCOLOR,   sent|lparam, 0, RGB(0,0,0) },
  97     { LVM_GETTEXTCOLOR,   sent },
  98     { LVM_SETTEXTBKCOLOR, sent|lparam, 0, RGB(0,0,0) },
  99     { LVM_GETTEXTBKCOLOR, sent },
 100
 101     { LVM_SETBKCOLOR,     sent|lparam, 0, RGB(100,50,200) },
 102     { LVM_GETBKCOLOR,     sent },
 103     { LVM_SETTEXTCOLOR,   sent|lparam, 0, RGB(100,50,200) },
 104     { LVM_GETTEXTCOLOR,   sent },
 105     { LVM_SETTEXTBKCOLOR, sent|lparam, 0, RGB(100,50,200) },
 106     { LVM_GETTEXTBKCOLOR, sent },
 107
 108     { LVM_SETBKCOLOR,     sent|lparam, 0, CLR_NONE },
 109     { LVM_GETBKCOLOR,     sent },
 110     { LVM_SETTEXTCOLOR,   sent|lparam, 0, CLR_NONE },
 111     { LVM_GETTEXTCOLOR,   sent },
 112     { LVM_SETTEXTBKCOLOR, sent|lparam, 0, CLR_NONE },
 113     { LVM_GETTEXTBKCOLOR, sent },
 114
 115     { LVM_SETBKCOLOR,     sent|lparam, 0, RGB(255,255,255) },
 116     { LVM_GETBKCOLOR,     sent },
 117     { LVM_SETTEXTCOLOR,   sent|lparam, 0, RGB(255,255,255) },
 118     { LVM_GETTEXTCOLOR,   sent },
 119     { LVM_SETTEXTBKCOLOR, sent|lparam, 0, RGB(255,255,255) },
 120     { LVM_GETTEXTBKCOLOR, sent },
 121     { 0 }
 122 };
 123
 124 static const struct message listview_item_count_seq[] = {
 125     { LVM_GETITEMCOUNT,   sent },
 126     { LVM_INSERTITEM,     sent },
 127     { LVM_INSERTITEM,     sent },
 128     { LVM_INSERTITEM,     sent },
 129     { LVM_GETITEMCOUNT,   sent },
 130     { LVM_DELETEITEM,     sent|wparam, 2 },
 131     { WM_NCPAINT,         sent|optional },
 132     { WM_ERASEBKGND,      sent|optional },
 133     { LVM_GETITEMCOUNT,   sent },
 134     { LVM_DELETEALLITEMS, sent },
 135     { LVM_GETITEMCOUNT,   sent },
 136     { LVM_INSERTITEM,     sent },
 137     { LVM_INSERTITEM,     sent },
 138     { LVM_GETITEMCOUNT,   sent },
 139     { LVM_INSERTITEM,     sent },
 140     { LVM_GETITEMCOUNT,   sent },
 141     { 0 }
 142 };
 143
 144 static const struct message listview_itempos_seq[] = {
 145     { LVM_INSERTITEM,      sent },
 146     { LVM_INSERTITEM,      sent },
 147     { LVM_INSERTITEM,      sent },
 148     { LVM_SETITEMPOSITION, sent|wparam|lparam, 1, MAKELPARAM(10,5) },
 149     { WM_NCPAINT,          sent|optional },
 150     { WM_ERASEBKGND,       sent|optional },
 151     { LVM_GETITEMPOSITION, sent|wparam,        1 },
 152     { LVM_SETITEMPOSITION, sent|wparam|lparam, 2, MAKELPARAM(0,0) },
 153     { LVM_GETITEMPOSITION, sent|wparam,        2 },
 154     { LVM_SETITEMPOSITION, sent|wparam|lparam, 0, MAKELPARAM(20,20) },
 155     { LVM_GETITEMPOSITION, sent|wparam,        0 },
 156     { 0 }
 157 };
 158
 159 static const struct message listview_ownerdata_switchto_seq[] = {
 160     { WM_STYLECHANGING,    sent },
 161     { WM_STYLECHANGED,     sent },
 162     { 0 }
 163 };
 164
 165 static const struct message listview_getorderarray_seq[] = {
 166     { LVM_GETCOLUMNORDERARRAY, sent|id|wparam, 2, 0, LISTVIEW_ID },
 167     { HDM_GETORDERARRAY,       sent|id|wparam, 2, 0, HEADER_ID },
 168     { 0 }
 169 };
 170
 171 static const struct message empty_seq[] = {
 172     { 0 }
 173 };
 174
 175 static const struct message forward_erasebkgnd_parent_seq[] = {
 176     { WM_ERASEBKGND, sent },
 177     { 0 }
 178 };
 179
 180 static const struct message ownderdata_select_focus_parent_seq[] = {
 181     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 182     { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
 183     { WM_NOTIFY, sent|id|optional, 0, 0, LVN_GETDISPINFOA }, /* version 4.7x */
 184     { 0 }
 185 };
 186
 187 static const struct message ownerdata_setstate_all_parent_seq[] = {
 188     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 189     { 0 }
 190 };
 191
 192 static const struct message ownerdata_defocus_all_parent_seq[] = {
 193     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 194     { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
 195     { WM_NOTIFY, sent|id|optional, 0, 0, LVN_GETDISPINFOA },
 196     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 197     { 0 }
 198 };
 199
 200 static const struct message ownerdata_deselect_all_parent_seq[] = {
 201     { WM_NOTIFY, sent|id, 0, 0, LVN_ODCACHEHINT },
 202     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 203     { 0 }
 204 };
 205
 206 static const struct message select_all_parent_seq[] = {
 207     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
 208     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 209
 210     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
 211     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 212
 213     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
 214     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 215
 216     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
 217     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 218
 219     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
 220     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
 221     { 0 }
 222 };
 223
 224 static const struct message textcallback_set_again_parent_seq[] = {
 225     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
 226     { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED  },
 227     { 0 }
 228 };
 229
 230 static const struct message single_getdispinfo_parent_seq[] = {
 231     { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
 232     { 0 }
 233 };
 234
 235 static const struct message getitemposition_seq1[] = {
 236     { LVM_GETITEMPOSITION, sent|id, 0, 0, LISTVIEW_ID },
 237     { 0 }
 238 };
 239
 240 static const struct message getitemposition_seq2[] = {
 241     { LVM_GETITEMPOSITION, sent|id, 0, 0, LISTVIEW_ID },
 242     { HDM_GETITEMRECT, sent|id, 0, 0, HEADER_ID },
 243     { 0 }
 244 };
 245
 246 static const struct message editbox_create_pos[] = {
 247     /* sequence sent after LVN_BEGINLABELEDIT */
 248     /* next two are 4.7x specific */
 249     { WM_WINDOWPOSCHANGING, sent },
 250     { WM_WINDOWPOSCHANGED, sent|optional },
 251
 252     { WM_WINDOWPOSCHANGING, sent|optional },
 253     { WM_NCCALCSIZE, sent },
 254     { WM_WINDOWPOSCHANGED, sent },
 255     { WM_MOVE, sent|defwinproc },
 256     { WM_SIZE, sent|defwinproc },
 257     /* the rest is todo, skipped in 4.7x */
 258     { WM_WINDOWPOSCHANGING, sent|optional },
 259     { WM_WINDOWPOSCHANGED, sent|optional },
 260     { 0 }
 261 };
 262
 263 static const struct message scroll_parent_seq[] = {
 264     { WM_NOTIFY, sent|id, 0, 0, LVN_BEGINSCROLL },
 265     { WM_NOTIFY, sent|id, 0, 0, LVN_ENDSCROLL },
 266     { 0 }
 267 };
 268
 269 static const struct message setredraw_seq[] = {
 270     { WM_SETREDRAW, sent|id|wparam, FALSE, 0, LISTVIEW_ID },
 271     { 0 }
 272 };
 273
 274 static const struct message lvs_ex_transparentbkgnd_seq[] = {
 275     { WM_PRINTCLIENT, sent|lparam, 0, PRF_ERASEBKGND },
 276     { 0 }
 277 };
 278
 279 static const struct message edit_end_nochange[] = {
 280     { WM_NOTIFY, sent|id, 0, 0, LVN_ENDLABELEDITA },
 281     { WM_NOTIFY, sent|id, 0, 0, NM_CUSTOMDRAW },     /* todo */
 282     { WM_NOTIFY, sent|id, 0, 0, NM_SETFOCUS },
 283     { 0 }
 284 };
 285
 286 static const struct message hover_parent[] = {
 287     { WM_GETDLGCODE, sent }, /* todo_wine */
 288     { WM_NOTIFY, sent|id, 0, 0, NM_HOVER },
 289     { 0 }
 290 };
 291
 292 static const struct message listview_destroy[] = {
 293     { 0x0090, sent|optional }, /* Vista */
 294     { WM_PARENTNOTIFY, sent },
 295     { WM_SHOWWINDOW, sent },
 296     { WM_WINDOWPOSCHANGING, sent },
 297     { WM_WINDOWPOSCHANGED, sent|optional },
 298     { WM_DESTROY, sent },
 299     { WM_NOTIFY, sent|id, 0, 0, LVN_DELETEALLITEMS },
 300     { WM_NCDESTROY, sent },
 301     { 0 }
 302 };
 303
 304 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 305 {
 306     static LONG defwndproc_counter = 0;
 307     LRESULT ret;
 308     struct message msg;
 309
 310     msg.message = message;
 311     msg.flags = sent|wparam|lparam;
 312     if (defwndproc_counter) msg.flags |= defwinproc;
 313     msg.wParam = wParam;
 314     msg.lParam = lParam;
 315     if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;
 316
 317     /* log system messages, except for painting */
 318     if (message < WM_USER &&
 319         message != WM_PAINT &&
 320         message != WM_ERASEBKGND &&
 321         message != WM_NCPAINT &&
 322         message != WM_NCHITTEST &&
 323         message != WM_GETTEXT &&
 324         message != WM_GETICON &&
 325         message != WM_DEVICECHANGE)
 326     {
 327         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 328
 329         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 330         add_message(sequences, COMBINED_SEQ_INDEX, &msg);
 331     }
 332     add_message(sequences, PARENT_FULL_SEQ_INDEX, &msg);
 333
 334     switch (message)
 335     {
 336       case WM_NOTIFY:
 337       {
 338           switch (((NMHDR*)lParam)->code)
 339           {
 340           case LVN_BEGINLABELEDIT:
 341               /* subclass edit box */
 342               if (!blockEdit)
 343                   subclass_editbox(((NMHDR*)lParam)->hwndFrom);
 344
 345               return blockEdit;
 346
 347           case LVN_ENDLABELEDIT:
 348               {
 349               /* always accept new item text */
 350               NMLVDISPINFO *di = (NMLVDISPINFO*)lParam;
 351               trace("LVN_ENDLABELEDIT: text=%s\n", di->item.pszText);
 352               return TRUE;
 353               }
 354           case LVN_BEGINSCROLL:
 355           case LVN_ENDSCROLL:
 356               {
 357               NMLVSCROLL *pScroll = (NMLVSCROLL*)lParam;
 358
 359               trace("LVN_%sSCROLL: (%d,%d)\n", pScroll->hdr.code == LVN_BEGINSCROLL ?
 360                                                "BEGIN" : "END", pScroll->dx, pScroll->dy);
 361               }
 362               break;
 363           case LVN_ITEMCHANGED:
 364               if (g_dump_itemchanged)
 365               {
 366                   NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam;
 367                   trace("LVN_ITEMCHANGED: item=%d,new=%x,old=%x,changed=%x\n",
 368                          nmlv->iItem, nmlv->uNewState, nmlv->uOldState, nmlv->uChanged);
 369               }
 370               break;
 371           case LVN_GETDISPINFOA:
 372               {
 373                   NMLVDISPINFOA *dispinfo = (NMLVDISPINFOA*)lParam;
 374                   g_itema = dispinfo->item;
 375               }
 376               break;
 377           case NM_HOVER:
 378               if (g_block_hover) return 1;
 379               break;
 380           }
 381           break;
 382       }
 383       case WM_NOTIFYFORMAT:
 384       {
 385           /* force to return format */
 386           if (lParam == NF_QUERY && notifyFormat != -1) return notifyFormat;
 387           break;
 388       }
 389     }
 390
 391     defwndproc_counter++;
 392     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 393     defwndproc_counter--;
 394
 395     return ret;
 396 }
 397
 398 static BOOL register_parent_wnd_class(BOOL Unicode)
 399 {
 400     WNDCLASSA clsA;
 401     WNDCLASSW clsW;
 402
 403     if (Unicode)
 404     {
 405         clsW.style = 0;
 406         clsW.lpfnWndProc = parent_wnd_proc;
 407         clsW.cbClsExtra = 0;
 408         clsW.cbWndExtra = 0;
 409         clsW.hInstance = GetModuleHandleW(NULL);
 410         clsW.hIcon = 0;
 411         clsW.hCursor = LoadCursorA(0, IDC_ARROW);
 412         clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
 413         clsW.lpszMenuName = NULL;
 414         clsW.lpszClassName = testparentclassW;
 415     }
 416     else
 417     {
 418         clsA.style = 0;
 419         clsA.lpfnWndProc = parent_wnd_proc;
 420         clsA.cbClsExtra = 0;
 421         clsA.cbWndExtra = 0;
 422         clsA.hInstance = GetModuleHandleA(NULL);
 423         clsA.hIcon = 0;
 424         clsA.hCursor = LoadCursorA(0, IDC_ARROW);
 425         clsA.hbrBackground = GetStockObject(WHITE_BRUSH);
 426         clsA.lpszMenuName = NULL;
 427         clsA.lpszClassName = "Listview test parent class";
 428     }
 429
 430     return Unicode ? RegisterClassW(&clsW) : RegisterClassA(&clsA);
 431 }
 432
 433 static HWND create_parent_window(BOOL Unicode)
 434 {
 435     static const WCHAR nameW[] = {'t','e','s','t','p','a','r','e','n','t','n','a','m','e','W',0};
 436     HWND hwnd;
 437
 438     if (!register_parent_wnd_class(Unicode))
 439         return NULL;
 440
 441     blockEdit = FALSE;
 442     notifyFormat = -1;
 443
 444     if (Unicode)
 445         hwnd = CreateWindowExW(0, testparentclassW, nameW,
 446                                WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 447                                WS_MAXIMIZEBOX | WS_VISIBLE,
 448                                0, 0, 100, 100,
 449                                GetDesktopWindow(), NULL, GetModuleHandleW(NULL), NULL);
 450     else
 451         hwnd = CreateWindowExA(0, "Listview test parent class",
 452                                "Listview test parent window",
 453                                WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 454                                WS_MAXIMIZEBOX | WS_VISIBLE,
 455                                0, 0, 100, 100,
 456                                GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 457     SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
 458     return hwnd;
 459 }
 460
 461 static LRESULT WINAPI listview_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 462 {
 463     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 464     static LONG defwndproc_counter = 0;
 465     LRESULT ret;
 466     struct message msg;
 467
 468     trace("listview: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 469
 470     /* some debug output for style changing */
 471     if ((message == WM_STYLECHANGING ||
 472          message == WM_STYLECHANGED) && lParam)
 473     {
 474         STYLESTRUCT *style = (STYLESTRUCT*)lParam;
 475         trace("\told style: 0x%08x, new style: 0x%08x\n", style->styleOld, style->styleNew);
 476     }
 477
 478     msg.message = message;
 479     msg.flags = sent|wparam|lparam;
 480     if (defwndproc_counter) msg.flags |= defwinproc;
 481     msg.wParam = wParam;
 482     msg.lParam = lParam;
 483     msg.id = LISTVIEW_ID;
 484     add_message(sequences, LISTVIEW_SEQ_INDEX, &msg);
 485     add_message(sequences, COMBINED_SEQ_INDEX, &msg);
 486
 487     defwndproc_counter++;
 488     ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 489     defwndproc_counter--;
 490     return ret;
 491 }
 492
 493 static HWND create_listview_control(DWORD style)
 494 {
 495     WNDPROC oldproc;
 496     HWND hwnd;
 497     RECT rect;
 498
 499     GetClientRect(hwndparent, &rect);
 500     hwnd = CreateWindowExA(0, WC_LISTVIEW, "foo",
 501                            WS_CHILD | WS_BORDER | WS_VISIBLE | style,
 502                            0, 0, rect.right, rect.bottom,
 503                            hwndparent, NULL, GetModuleHandleA(NULL), NULL);
 504     ok(hwnd != NULL, "gle=%d\n", GetLastError());
 505
 506     if (!hwnd) return NULL;
 507
 508     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
 509                                         (LONG_PTR)listview_subclass_proc);
 510     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 511
 512     return hwnd;
 513 }
 514
 515 /* unicode listview window with specified parent */
 516 static HWND create_listview_controlW(DWORD style, HWND parent)
 517 {
 518     WNDPROC oldproc;
 519     HWND hwnd;
 520     RECT rect;
 521     static const WCHAR nameW[] = {'f','o','o',0};
 522
 523     GetClientRect(parent, &rect);
 524     hwnd = CreateWindowExW(0, WC_LISTVIEWW, nameW,
 525                            WS_CHILD | WS_BORDER | WS_VISIBLE | style,
 526                            0, 0, rect.right, rect.bottom,
 527                            parent, NULL, GetModuleHandleW(NULL), NULL);
 528     ok(hwnd != NULL, "gle=%d\n", GetLastError());
 529
 530     if (!hwnd) return NULL;
 531
 532     oldproc = (WNDPROC)SetWindowLongPtrW(hwnd, GWLP_WNDPROC,
 533                                         (LONG_PTR)listview_subclass_proc);
 534     SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 535
 536     return hwnd;
 537 }
 538
 539 static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 540 {
 541     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 542     static LONG defwndproc_counter = 0;
 543     LRESULT ret;
 544     struct message msg;
 545
 546     trace("header: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 547
 548     msg.message = message;
 549     msg.flags = sent|wparam|lparam;
 550     if (defwndproc_counter) msg.flags |= defwinproc;
 551     msg.wParam = wParam;
 552     msg.lParam = lParam;
 553     msg.id = HEADER_ID;
 554     add_message(sequences, LISTVIEW_SEQ_INDEX, &msg);
 555
 556     defwndproc_counter++;
 557     ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 558     defwndproc_counter--;
 559     return ret;
 560 }
 561
 562 static HWND subclass_header(HWND hwndListview)
 563 {
 564     WNDPROC oldproc;
 565     HWND hwnd;
 566
 567     hwnd = ListView_GetHeader(hwndListview);
 568     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
 569                                          (LONG_PTR)header_subclass_proc);
 570     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 571
 572     return hwnd;
 573 }
 574
 575 static LRESULT WINAPI editbox_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 576 {
 577     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 578     static LONG defwndproc_counter = 0;
 579     LRESULT ret;
 580     struct message msg;
 581
 582     msg.message = message;
 583     msg.flags = sent|wparam|lparam;
 584     if (defwndproc_counter) msg.flags |= defwinproc;
 585     msg.wParam = wParam;
 586     msg.lParam = lParam;
 587
 588     /* all we need is sizing */
 589     if (message == WM_WINDOWPOSCHANGING ||
 590         message == WM_NCCALCSIZE ||
 591         message == WM_WINDOWPOSCHANGED ||
 592         message == WM_MOVE ||
 593         message == WM_SIZE)
 594     {
 595         add_message(sequences, EDITBOX_SEQ_INDEX, &msg);
 596     }
 597
 598     defwndproc_counter++;
 599     ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 600     defwndproc_counter--;
 601     return ret;
 602 }
 603
 604 static HWND subclass_editbox(HWND hwndListview)
 605 {
 606     WNDPROC oldproc;
 607     HWND hwnd;
 608
 609     hwnd = (HWND)SendMessage(hwndListview, LVM_GETEDITCONTROL, 0, 0);
 610     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
 611                                          (LONG_PTR)editbox_subclass_proc);
 612     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 613
 614     return hwnd;
 615 }
 616
 617 /* Performs a single LVM_HITTEST test */
 618 static void test_lvm_hittest_(HWND hwnd, INT x, INT y, INT item, UINT flags, UINT broken_flags,
 619                               BOOL todo_item, BOOL todo_flags, int line)
 620 {
 621     LVHITTESTINFO lpht;
 622     DWORD ret;
 623
 624     lpht.pt.x = x;
 625     lpht.pt.y = y;
 626     lpht.iSubItem = 10;
 627
 628     trace("hittesting pt=(%d,%d)\n", lpht.pt.x, lpht.pt.y);
 629     ret = SendMessage(hwnd, LVM_HITTEST, 0, (LPARAM)&lpht);
 630
 631     if (todo_item)
 632     {
 633         todo_wine
 634         {
 635             ok_(__FILE__, line)(ret == item, "Expected %d retval, got %d\n", item, ret);
 636             ok_(__FILE__, line)(lpht.iItem == item, "Expected %d item, got %d\n", item, lpht.iItem);
 637             ok_(__FILE__, line)(lpht.iSubItem == 10, "Expected subitem not overwrited\n");
 638         }
 639     }
 640     else
 641     {
 642         ok_(__FILE__, line)(ret == item, "Expected %d retval, got %d\n", item, ret);
 643         ok_(__FILE__, line)(lpht.iItem == item, "Expected %d item, got %d\n", item, lpht.iItem);
 644         ok_(__FILE__, line)(lpht.iSubItem == 10, "Expected subitem not overwrited\n");
 645     }
 646
 647     if (todo_flags)
 648     {
 649         todo_wine
 650             ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
 651     }
 652     else if (broken_flags)
 653         ok_(__FILE__, line)(lpht.flags == flags || broken(lpht.flags == broken_flags),
 654                             "Expected flags %x, got %x\n", flags, lpht.flags);
 655     else
 656         ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
 657 }
 658
 659 #define test_lvm_hittest(a,b,c,d,e,f,g,h) test_lvm_hittest_(a,b,c,d,e,f,g,h,__LINE__)
 660
 661 /* Performs a single LVM_SUBITEMHITTEST test */
 662 static void test_lvm_subitemhittest_(HWND hwnd, INT x, INT y, INT item, INT subitem, UINT flags,
 663                                      BOOL todo_item, BOOL todo_subitem, BOOL todo_flags, int line)
 664 {
 665     LVHITTESTINFO lpht;
 666     DWORD ret;
 667
 668     lpht.pt.x = x;
 669     lpht.pt.y = y;
 670
 671     trace("subhittesting pt=(%d,%d)\n", lpht.pt.x, lpht.pt.y);
 672     ret = SendMessage(hwnd, LVM_SUBITEMHITTEST, 0, (LPARAM)&lpht);
 673
 674     if (todo_item)
 675     {
 676         todo_wine
 677         {
 678             ok_(__FILE__, line)(ret == item, "Expected %d retval, got %d\n", item, ret);
 679             ok_(__FILE__, line)(lpht.iItem == item, "Expected %d item, got %d\n", item, lpht.iItem);
 680         }
 681     }
 682     else
 683     {
 684         ok_(__FILE__, line)(ret == item, "Expected %d retval, got %d\n", item, ret);
 685         ok_(__FILE__, line)(lpht.iItem == item, "Expected %d item, got %d\n", item, lpht.iItem);
 686     }
 687
 688     if (todo_subitem)
 689     {
 690         todo_wine
 691             ok_(__FILE__, line)(lpht.iSubItem == subitem, "Expected subitem %d, got %d\n", subitem, lpht.iSubItem);
 692     }
 693     else
 694         ok_(__FILE__, line)(lpht.iSubItem == subitem, "Expected subitem %d, got %d\n", subitem, lpht.iSubItem);
 695
 696     if (todo_flags)
 697     {
 698         todo_wine
 699             ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
 700     }
 701     else
 702         ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
 703 }
 704
 705 #define test_lvm_subitemhittest(a,b,c,d,e,f,g,h,i) test_lvm_subitemhittest_(a,b,c,d,e,f,g,h,i,__LINE__)
 706
 707 static void test_images(void)
 708 {
 709     HWND hwnd;
 710     DWORD r;
 711     LVITEM item;
 712     HIMAGELIST himl;
 713     HBITMAP hbmp;
 714     RECT r1, r2;
 715     static CHAR hello[] = "hello";
 716
 717     himl = ImageList_Create(40, 40, 0, 4, 4);
 718     ok(himl != NULL, "failed to create imagelist\n");
 719
 720     hbmp = CreateBitmap(40, 40, 1, 1, NULL);
 721     ok(hbmp != NULL, "failed to create bitmap\n");
 722
 723     r = ImageList_Add(himl, hbmp, 0);
 724     ok(r == 0, "should be zero\n");
 725
 726     hwnd = CreateWindowEx(0, "SysListView32", "foo", LVS_OWNERDRAWFIXED,
 727                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
 728     ok(hwnd != NULL, "failed to create listview window\n");
 729
 730     r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
 731                     LVS_EX_UNDERLINEHOT | LVS_EX_FLATSB | LVS_EX_ONECLICKACTIVATE);
 732
 733     ok(r == 0, "should return zero\n");
 734
 735     r = SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
 736     ok(r == 0, "should return zero\n");
 737
 738     r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELONG(100,50));
 739     /* returns dimensions */
 740
 741     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
 742     ok(r == 0, "should be zero items\n");
 743
 744     item.mask = LVIF_IMAGE | LVIF_TEXT;
 745     item.iItem = 0;
 746     item.iSubItem = 1;
 747     item.iImage = 0;
 748     item.pszText = 0;
 749     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
 750     ok(r == -1, "should fail\n");
 751
 752     item.iSubItem = 0;
 753     item.pszText = hello;
 754     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
 755     ok(r == 0, "should not fail\n");
 756
 757     memset(&r1, 0, sizeof r1);
 758     r1.left = LVIR_ICON;
 759     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r1);
 760
 761     r = SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0);
 762     ok(r == TRUE, "should not fail\n");
 763
 764     item.iSubItem = 0;
 765     item.pszText = hello;
 766     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
 767     ok(r == 0, "should not fail\n");
 768
 769     memset(&r2, 0, sizeof r2);
 770     r2.left = LVIR_ICON;
 771     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r2);
 772
 773     ok(!memcmp(&r1, &r2, sizeof r1), "rectangle should be the same\n");
 774
 775     DestroyWindow(hwnd);
 776 }
 777
 778 static void test_checkboxes(void)
 779 {
 780     HWND hwnd;
 781     LVITEMA item;
 782     DWORD r;
 783     static CHAR text[]  = "Text",
 784                 text2[] = "Text2",
 785                 text3[] = "Text3";
 786
 787     hwnd = CreateWindowEx(0, "SysListView32", "foo", LVS_REPORT,
 788                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
 789     ok(hwnd != NULL, "failed to create listview window\n");
 790
 791     /* first without LVS_EX_CHECKBOXES set and an item and check that state is preserved */
 792     item.mask = LVIF_TEXT | LVIF_STATE;
 793     item.stateMask = 0xffff;
 794     item.state = 0xfccc;
 795     item.iItem = 0;
 796     item.iSubItem = 0;
 797     item.pszText = text;
 798     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
 799     ok(r == 0, "ret %d\n", r);
 800
 801     item.iItem = 0;
 802     item.mask = LVIF_STATE;
 803     item.stateMask = 0xffff;
 804     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 805     ok(item.state == 0xfccc, "state %x\n", item.state);
 806
 807     /* Don't set LVIF_STATE */
 808     item.mask = LVIF_TEXT;
 809     item.stateMask = 0xffff;
 810     item.state = 0xfccc;
 811     item.iItem = 1;
 812     item.iSubItem = 0;
 813     item.pszText = text;
 814     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
 815     ok(r == 1, "ret %d\n", r);
 816
 817     item.iItem = 1;
 818     item.mask = LVIF_STATE;
 819     item.stateMask = 0xffff;
 820     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 821     ok(item.state == 0, "state %x\n", item.state);
 822
 823     r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
 824     ok(r == 0, "should return zero\n");
 825
 826     /* Having turned on checkboxes, check that all existing items are set to 0x1000 (unchecked) */
 827     item.iItem = 0;
 828     item.mask = LVIF_STATE;
 829     item.stateMask = 0xffff;
 830     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 831     if (item.state != 0x1ccc)
 832     {
 833         win_skip("LVS_EX_CHECKBOXES style is unavailable. Skipping.\n");
 834         DestroyWindow(hwnd);
 835         return;
 836     }
 837
 838     /* Now add an item without specifying a state and check that its state goes to 0x1000 */
 839     item.iItem = 2;
 840     item.mask = LVIF_TEXT;
 841     item.state = 0;
 842     item.pszText = text2;
 843     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
 844     ok(r == 2, "ret %d\n", r);
 845
 846     item.iItem = 2;
 847     item.mask = LVIF_STATE;
 848     item.stateMask = 0xffff;
 849     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 850     ok(item.state == 0x1000, "state %x\n", item.state);
 851
 852     /* Add a further item this time specifying a state and still its state goes to 0x1000 */
 853     item.iItem = 3;
 854     item.mask = LVIF_TEXT | LVIF_STATE;
 855     item.stateMask = 0xffff;
 856     item.state = 0x2aaa;
 857     item.pszText = text3;
 858     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
 859     ok(r == 3, "ret %d\n", r);
 860
 861     item.iItem = 3;
 862     item.mask = LVIF_STATE;
 863     item.stateMask = 0xffff;
 864     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 865     ok(item.state == 0x1aaa, "state %x\n", item.state);
 866
 867     /* Set an item's state to checked */
 868     item.iItem = 3;
 869     item.mask = LVIF_STATE;
 870     item.stateMask = 0xf000;
 871     item.state = 0x2000;
 872     r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
 873
 874     item.iItem = 3;
 875     item.mask = LVIF_STATE;
 876     item.stateMask = 0xffff;
 877     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 878     ok(item.state == 0x2aaa, "state %x\n", item.state);
 879
 880     /* Check that only the bits we asked for are returned,
 881      * and that all the others are set to zero
 882      */
 883     item.iItem = 3;
 884     item.mask = LVIF_STATE;
 885     item.stateMask = 0xf000;
 886     item.state = 0xffff;
 887     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 888     ok(item.state == 0x2000, "state %x\n", item.state);
 889
 890     /* Set the style again and check that doesn't change an item's state */
 891     r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
 892     ok(r == LVS_EX_CHECKBOXES, "ret %x\n", r);
 893
 894     item.iItem = 3;
 895     item.mask = LVIF_STATE;
 896     item.stateMask = 0xffff;
 897     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 898     ok(item.state == 0x2aaa, "state %x\n", item.state);
 899
 900     /* Unsetting the checkbox extended style doesn't change an item's state */
 901     r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, 0);
 902     ok(r == LVS_EX_CHECKBOXES, "ret %x\n", r);
 903
 904     item.iItem = 3;
 905     item.mask = LVIF_STATE;
 906     item.stateMask = 0xffff;
 907     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 908     ok(item.state == 0x2aaa, "state %x\n", item.state);
 909
 910     /* Now setting the style again will change an item's state */
 911     r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
 912     ok(r == 0, "ret %x\n", r);
 913
 914     item.iItem = 3;
 915     item.mask = LVIF_STATE;
 916     item.stateMask = 0xffff;
 917     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 918     ok(item.state == 0x1aaa, "state %x\n", item.state);
 919
 920     /* Toggle checkbox tests (bug 9934) */
 921     memset (&item, 0xcc, sizeof(item));
 922     item.mask = LVIF_STATE;
 923     item.iItem = 3;
 924     item.iSubItem = 0;
 925     item.state = LVIS_FOCUSED;
 926     item.stateMask = LVIS_FOCUSED;
 927     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM) &item);
 928     expect(1, r);
 929
 930     item.iItem = 3;
 931     item.mask = LVIF_STATE;
 932     item.stateMask = 0xffff;
 933     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 934     ok(item.state == 0x1aab, "state %x\n", item.state);
 935
 936     r = SendMessage(hwnd, WM_KEYDOWN, VK_SPACE, 0);
 937     expect(0, r);
 938     r = SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0);
 939     expect(0, r);
 940
 941     item.iItem = 3;
 942     item.mask = LVIF_STATE;
 943     item.stateMask = 0xffff;
 944     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 945     ok(item.state == 0x2aab, "state %x\n", item.state);
 946
 947     r = SendMessage(hwnd, WM_KEYDOWN, VK_SPACE, 0);
 948     expect(0, r);
 949     r = SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0);
 950     expect(0, r);
 951
 952     item.iItem = 3;
 953     item.mask = LVIF_STATE;
 954     item.stateMask = 0xffff;
 955     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
 956     ok(item.state == 0x1aab, "state %x\n", item.state);
 957
 958     DestroyWindow(hwnd);
 959 }
 960
 961 static void insert_column(HWND hwnd, int idx)
 962 {
 963     LVCOLUMN column;
 964     DWORD rc;
 965
 966     memset(&column, 0xcc, sizeof(column));
 967     column.mask = LVCF_SUBITEM;
 968     column.iSubItem = idx;
 969
 970     rc = ListView_InsertColumn(hwnd, idx, &column);
 971     expect(idx, rc);
 972 }
 973
 974 static void insert_item(HWND hwnd, int idx)
 975 {
 976     static CHAR text[] = "foo";
 977
 978     LVITEMA item;
 979     DWORD rc;
 980
 981     memset(&item, 0xcc, sizeof (item));
 982     item.mask = LVIF_TEXT;
 983     item.iItem = idx;
 984     item.iSubItem = 0;
 985     item.pszText = text;
 986
 987     rc = ListView_InsertItem(hwnd, &item);
 988     expect(idx, rc);
 989 }
 990
 991 static void test_items(void)
 992 {
 993     const LPARAM lparamTest = 0x42;
 994     HWND hwnd;
 995     LVITEMA item;
 996     DWORD r;
 997     static CHAR text[] = "Text";
 998
 999     hwnd = CreateWindowEx(0, "SysListView32", "foo", LVS_REPORT,
1000                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
1001     ok(hwnd != NULL, "failed to create listview window\n");
1002
1003     /*
1004      * Test setting/getting item params
1005      */
1006
1007     /* Set up two columns */
1008     insert_column(hwnd, 0);
1009     insert_column(hwnd, 1);
1010
1011     /* LVIS_SELECTED with zero stateMask */
1012     /* set */
1013     memset (&item, 0, sizeof (item));
1014     item.mask = LVIF_STATE;
1015     item.state = LVIS_SELECTED;
1016     item.stateMask = 0;
1017     item.iItem = 0;
1018     item.iSubItem = 0;
1019     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1020     ok(r == 0, "ret %d\n", r);
1021     /* get */
1022     memset (&item, 0xcc, sizeof (item));
1023     item.mask = LVIF_STATE;
1024     item.stateMask = LVIS_SELECTED;
1025     item.state = 0;
1026     item.iItem = 0;
1027     item.iSubItem = 0;
1028     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1029     ok(r != 0, "ret %d\n", r);
1030     ok(item.state & LVIS_SELECTED, "Expected LVIS_SELECTED\n");
1031     SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
1032
1033     /* LVIS_SELECTED with zero stateMask */
1034     /* set */
1035     memset (&item, 0, sizeof (item));
1036     item.mask = LVIF_STATE;
1037     item.state = LVIS_FOCUSED;
1038     item.stateMask = 0;
1039     item.iItem = 0;
1040     item.iSubItem = 0;
1041     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1042     ok(r == 0, "ret %d\n", r);
1043     /* get */
1044     memset (&item, 0xcc, sizeof (item));
1045     item.mask = LVIF_STATE;
1046     item.stateMask = LVIS_FOCUSED;
1047     item.state = 0;
1048     item.iItem = 0;
1049     item.iSubItem = 0;
1050     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1051     ok(r != 0, "ret %d\n", r);
1052     ok(item.state & LVIS_FOCUSED, "Expected LVIS_FOCUSED\n");
1053     SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
1054
1055     /* LVIS_CUT with LVIS_FOCUSED stateMask */
1056     /* set */
1057     memset (&item, 0, sizeof (item));
1058     item.mask = LVIF_STATE;
1059     item.state = LVIS_CUT;
1060     item.stateMask = LVIS_FOCUSED;
1061     item.iItem = 0;
1062     item.iSubItem = 0;
1063     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1064     ok(r == 0, "ret %d\n", r);
1065     /* get */
1066     memset (&item, 0xcc, sizeof (item));
1067     item.mask = LVIF_STATE;
1068     item.stateMask = LVIS_CUT;
1069     item.state = 0;
1070     item.iItem = 0;
1071     item.iSubItem = 0;
1072     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1073     ok(r != 0, "ret %d\n", r);
1074     ok(item.state & LVIS_CUT, "Expected LVIS_CUT\n");
1075     SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
1076
1077     /* Insert an item with just a param */
1078     memset (&item, 0xcc, sizeof (item));
1079     item.mask = LVIF_PARAM;
1080     item.iItem = 0;
1081     item.iSubItem = 0;
1082     item.lParam = lparamTest;
1083     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1084     ok(r == 0, "ret %d\n", r);
1085
1086     /* Test getting of the param */
1087     memset (&item, 0xcc, sizeof (item));
1088     item.mask = LVIF_PARAM;
1089     item.iItem = 0;
1090     item.iSubItem = 0;
1091     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1092     ok(r != 0, "ret %d\n", r);
1093     ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
1094
1095     /* Set up a subitem */
1096     memset (&item, 0xcc, sizeof (item));
1097     item.mask = LVIF_TEXT;
1098     item.iItem = 0;
1099     item.iSubItem = 1;
1100     item.pszText = text;
1101     r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1102     ok(r != 0, "ret %d\n", r);
1103
1104     /* Query param from subitem: returns main item param */
1105     memset (&item, 0xcc, sizeof (item));
1106     item.mask = LVIF_PARAM;
1107     item.iItem = 0;
1108     item.iSubItem = 1;
1109     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1110     ok(r != 0, "ret %d\n", r);
1111     ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
1112
1113     /* Set up param on first subitem: no effect */
1114     memset (&item, 0xcc, sizeof (item));
1115     item.mask = LVIF_PARAM;
1116     item.iItem = 0;
1117     item.iSubItem = 1;
1118     item.lParam = lparamTest+1;
1119     r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1120     ok(r == 0, "ret %d\n", r);
1121
1122     /* Query param from subitem again: should still return main item param */
1123     memset (&item, 0xcc, sizeof (item));
1124     item.mask = LVIF_PARAM;
1125     item.iItem = 0;
1126     item.iSubItem = 1;
1127     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1128     ok(r != 0, "ret %d\n", r);
1129     ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
1130
1131     /**** Some tests of state highlighting ****/
1132     memset (&item, 0xcc, sizeof (item));
1133     item.mask = LVIF_STATE;
1134     item.iItem = 0;
1135     item.iSubItem = 0;
1136     item.state = LVIS_SELECTED;
1137     item.stateMask = LVIS_SELECTED | LVIS_DROPHILITED;
1138     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM) &item);
1139     ok(r != 0, "ret %d\n", r);
1140     item.iSubItem = 1;
1141     item.state = LVIS_DROPHILITED;
1142     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM) &item);
1143     ok(r != 0, "ret %d\n", r);
1144
1145     memset (&item, 0xcc, sizeof (item));
1146     item.mask = LVIF_STATE;
1147     item.iItem = 0;
1148     item.iSubItem = 0;
1149     item.stateMask = -1;
1150     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
1151     ok(r != 0, "ret %d\n", r);
1152     ok(item.state == LVIS_SELECTED, "got state %x, expected %x\n", item.state, LVIS_SELECTED);
1153     item.iSubItem = 1;
1154     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
1155     ok(r != 0, "ret %d\n", r);
1156     todo_wine ok(item.state == LVIS_DROPHILITED, "got state %x, expected %x\n", item.state, LVIS_DROPHILITED);
1157
1158     /* some notnull but meaningless masks */
1159     memset (&item, 0, sizeof(item));
1160     item.mask = LVIF_NORECOMPUTE;
1161     item.iItem = 0;
1162     item.iSubItem = 0;
1163     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1164     ok(r != 0, "ret %d\n", r);
1165     memset (&item, 0, sizeof(item));
1166     item.mask = LVIF_DI_SETITEM;
1167     item.iItem = 0;
1168     item.iSubItem = 0;
1169     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1170     ok(r != 0, "ret %d\n", r);
1171
1172     /* set text to callback value already having it */
1173     r = SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0);
1174     expect(TRUE, r);
1175     memset (&item, 0, sizeof (item));
1176     item.mask  = LVIF_TEXT;
1177     item.pszText = LPSTR_TEXTCALLBACK;
1178     item.iItem = 0;
1179     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1180     ok(r == 0, "ret %d\n", r);
1181     memset (&item, 0, sizeof (item));
1182
1183     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1184
1185     item.pszText = LPSTR_TEXTCALLBACK;
1186     r = SendMessage(hwnd, LVM_SETITEMTEXT, 0 , (LPARAM) &item);
1187     expect(TRUE, r);
1188
1189     ok_sequence(sequences, PARENT_SEQ_INDEX, textcallback_set_again_parent_seq,
1190                 "check callback text comparison rule", FALSE);
1191
1192     DestroyWindow(hwnd);
1193 }
1194
1195 static void test_columns(void)
1196 {
1197     HWND hwnd;
1198     LVCOLUMNA column;
1199     LVITEMA item;
1200     INT order[2];
1201     CHAR buff[5];
1202     DWORD rc;
1203
1204     hwnd = CreateWindowExA(0, "SysListView32", "foo", LVS_REPORT,
1205                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
1206     ok(hwnd != NULL, "failed to create listview window\n");
1207
1208     /* Add a column with no mask */
1209     memset(&column, 0xcc, sizeof(column));
1210     column.mask = 0;
1211     rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&column);
1212     ok(rc == 0, "Inserting column with no mask failed with %d\n", rc);
1213
1214     /* Check its width */
1215     rc = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
1216     ok(rc == 10 || broken(rc == 0) /* win9x */,
1217        "Inserting column with no mask failed to set width to 10 with %d\n", rc);
1218
1219     DestroyWindow(hwnd);
1220
1221     /* LVM_GETCOLUMNORDERARRAY */
1222     hwnd = create_listview_control(LVS_REPORT);
1223     subclass_header(hwnd);
1224
1225     memset(&column, 0, sizeof(column));
1226     column.mask = LVCF_WIDTH;
1227     column.cx = 100;
1228     rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&column);
1229     ok(rc == 0, "Inserting column failed with %d\n", rc);
1230
1231     column.cx = 200;
1232     rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 1, (LPARAM)&column);
1233     ok(rc == 1, "Inserting column failed with %d\n", rc);
1234
1235     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1236
1237     rc = SendMessageA(hwnd, LVM_GETCOLUMNORDERARRAY, 2, (LPARAM)&order);
1238     ok(rc == 1, "Expected LVM_GETCOLUMNORDERARRAY to succeed\n");
1239     ok(order[0] == 0, "Expected order 0, got %d\n", order[0]);
1240     ok(order[1] == 1, "Expected order 1, got %d\n", order[1]);
1241
1242     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_getorderarray_seq, "get order array", FALSE);
1243
1244     /* after column added subitem is considered as present */
1245     insert_item(hwnd, 0);
1246
1247     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1248
1249     item.pszText = buff;
1250     item.cchTextMax = sizeof(buff);
1251     item.iItem = 0;
1252     item.iSubItem = 1;
1253     item.mask = LVIF_TEXT;
1254     memset(&g_itema, 0, sizeof(g_itema));
1255     rc = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
1256     ok(rc == 1, "got %d\n", rc);
1257     ok(g_itema.iSubItem == 1, "got %d\n", g_itema.iSubItem);
1258
1259     ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
1260         "get subitem text after column added", FALSE);
1261
1262     DestroyWindow(hwnd);
1263 }
1264
1265 /* test setting imagelist between WM_NCCREATE and WM_CREATE */
1266 static WNDPROC listviewWndProc;
1267 static HIMAGELIST test_create_imagelist;
1268
1269 static LRESULT CALLBACK create_test_wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1270 {
1271     LRESULT ret;
1272
1273     if (uMsg == WM_CREATE)
1274     {
1275         LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
1276         lpcs->style |= LVS_REPORT;
1277     }
1278     ret = CallWindowProc(listviewWndProc, hwnd, uMsg, wParam, lParam);
1279     if (uMsg == WM_CREATE) SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)test_create_imagelist);
1280     return ret;
1281 }
1282
1283 static void test_create(void)
1284 {
1285     HWND hList;
1286     HWND hHeader;
1287     LONG_PTR ret;
1288     LONG r;
1289     LVCOLUMNA col;
1290     RECT rect;
1291     WNDCLASSEX cls;
1292     DWORD style;
1293
1294     cls.cbSize = sizeof(WNDCLASSEX);
1295     ok(GetClassInfoEx(GetModuleHandle(NULL), "SysListView32", &cls), "GetClassInfoEx failed\n");
1296     listviewWndProc = cls.lpfnWndProc;
1297     cls.lpfnWndProc = create_test_wndproc;
1298     cls.lpszClassName = "MyListView32";
1299     ok(RegisterClassEx(&cls), "RegisterClassEx failed\n");
1300
1301     test_create_imagelist = ImageList_Create(16, 16, 0, 5, 10);
1302     hList = CreateWindow("MyListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL, GetModuleHandle(NULL), 0);
1303     ok((HIMAGELIST)SendMessage(hList, LVM_GETIMAGELIST, 0, 0) == test_create_imagelist, "Image list not obtained\n");
1304     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1305
1306     if (!IsWindow(hHeader))
1307     {
1308         /* version 4.0 */
1309         win_skip("LVM_GETHEADER not implemented. Skipping.\n");
1310         DestroyWindow(hList);
1311         return;
1312     }
1313
1314     ok(IsWindow(hHeader) && IsWindowVisible(hHeader), "Listview not in report mode\n");
1315     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1316     DestroyWindow(hList);
1317
1318     /* header isn't created on LVS_ICON and LVS_LIST styles */
1319     hList = CreateWindow("SysListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
1320                           GetModuleHandle(NULL), 0);
1321     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1322     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1323     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1324     /* insert column */
1325     memset(&col, 0, sizeof(LVCOLUMNA));
1326     col.mask = LVCF_WIDTH;
1327     col.cx = 100;
1328     r = SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
1329     ok(r == 0, "Expected 0 column's inserted\n");
1330     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1331     ok(IsWindow(hHeader), "Header should be created\n");
1332     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1333     style = GetWindowLong(hHeader, GWL_STYLE);
1334     ok(!(style & HDS_HIDDEN), "Not expected HDS_HIDDEN\n");
1335     DestroyWindow(hList);
1336
1337     hList = CreateWindow("SysListView32", "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
1338                           GetModuleHandle(NULL), 0);
1339     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1340     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1341     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1342     /* insert column */
1343     memset(&col, 0, sizeof(LVCOLUMNA));
1344     col.mask = LVCF_WIDTH;
1345     col.cx = 100;
1346     r = SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
1347     ok(r == 0, "Expected 0 column's inserted\n");
1348     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1349     ok(IsWindow(hHeader), "Header should be created\n");
1350     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1351     DestroyWindow(hList);
1352
1353     /* try to switch LVS_ICON -> LVS_REPORT and back LVS_ICON -> LVS_REPORT */
1354     hList = CreateWindow("SysListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
1355                           GetModuleHandle(NULL), 0);
1356     ret = SetWindowLongPtr(hList, GWL_STYLE, GetWindowLongPtr(hList, GWL_STYLE) | LVS_REPORT);
1357     ok(ret & WS_VISIBLE, "Style wrong, should have WS_VISIBLE\n");
1358     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1359     ok(IsWindow(hHeader), "Header should be created\n");
1360     ret = SetWindowLongPtr(hList, GWL_STYLE, GetWindowLong(hList, GWL_STYLE) & ~LVS_REPORT);
1361     ok((ret & WS_VISIBLE) && (ret & LVS_REPORT), "Style wrong, should have WS_VISIBLE|LVS_REPORT\n");
1362     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1363     ok(IsWindow(hHeader), "Header should be created\n");
1364     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1365     DestroyWindow(hList);
1366
1367     /* try to switch LVS_LIST -> LVS_REPORT and back LVS_LIST -> LVS_REPORT */
1368     hList = CreateWindow("SysListView32", "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
1369                           GetModuleHandle(NULL), 0);
1370     ret = SetWindowLongPtr(hList, GWL_STYLE,
1371                           (GetWindowLongPtr(hList, GWL_STYLE) & ~LVS_LIST) | LVS_REPORT);
1372     ok(((ret & WS_VISIBLE) && (ret & LVS_LIST)), "Style wrong, should have WS_VISIBLE|LVS_LIST\n");
1373     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1374     ok(IsWindow(hHeader), "Header should be created\n");
1375     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1376     ret = SetWindowLongPtr(hList, GWL_STYLE,
1377                           (GetWindowLongPtr(hList, GWL_STYLE) & ~LVS_REPORT) | LVS_LIST);
1378     ok(((ret & WS_VISIBLE) && (ret & LVS_REPORT)), "Style wrong, should have WS_VISIBLE|LVS_REPORT\n");
1379     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1380     ok(IsWindow(hHeader), "Header should be created\n");
1381     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1382     DestroyWindow(hList);
1383
1384     /* LVS_REPORT without WS_VISIBLE */
1385     hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1386                           GetModuleHandle(NULL), 0);
1387     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1388     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1389     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1390     /* insert column */
1391     memset(&col, 0, sizeof(LVCOLUMNA));
1392     col.mask = LVCF_WIDTH;
1393     col.cx = 100;
1394     r = SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
1395     ok(r == 0, "Expected 0 column's inserted\n");
1396     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1397     ok(IsWindow(hHeader), "Header should be created\n");
1398     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1399     DestroyWindow(hList);
1400
1401     /* LVS_REPORT without WS_VISIBLE, try to show it */
1402     hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1403                           GetModuleHandle(NULL), 0);
1404     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1405     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1406     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1407     ShowWindow(hList, SW_SHOW);
1408     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1409     ok(IsWindow(hHeader), "Header should be created\n");
1410     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1411     DestroyWindow(hList);
1412
1413     /* LVS_REPORT with LVS_NOCOLUMNHEADER */
1414     hList = CreateWindow("SysListView32", "Test", LVS_REPORT|LVS_NOCOLUMNHEADER|WS_VISIBLE,
1415                           0, 0, 100, 100, NULL, NULL, GetModuleHandle(NULL), 0);
1416     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1417     ok(IsWindow(hHeader), "Header should be created\n");
1418     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1419     /* HDS_DRAGDROP set by default */
1420     ok(GetWindowLongPtr(hHeader, GWL_STYLE) & HDS_DRAGDROP, "Expected header to have HDS_DRAGDROP\n");
1421     DestroyWindow(hList);
1422
1423     /* setting LVS_EX_HEADERDRAGDROP creates header */
1424     hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1425                           GetModuleHandle(NULL), 0);
1426     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1427     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1428     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1429     SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
1430     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1431     ok(IsWindow(hHeader) ||
1432        broken(!IsWindow(hHeader)), /* 4.7x common controls */
1433        "Header should be created\n");
1434     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1435     DestroyWindow(hList);
1436
1437     /* not report style accepts LVS_EX_HEADERDRAGDROP too */
1438     hList = create_listview_control(LVS_ICON);
1439     SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
1440     r = SendMessage(hList, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
1441     ok(r & LVS_EX_HEADERDRAGDROP, "Expected LVS_EX_HEADERDRAGDROP to be set\n");
1442     DestroyWindow(hList);
1443
1444     /* requesting header info with LVM_GETSUBITEMRECT doesn't create it */
1445     hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1446                           GetModuleHandle(NULL), 0);
1447     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1448     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1449
1450     rect.left = LVIR_BOUNDS;
1451     rect.top  = 1;
1452     rect.right = rect.bottom = -10;
1453     r = SendMessage(hList, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
1454     ok(r != 0, "Expected not-null LRESULT\n");
1455
1456     hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
1457     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
1458     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
1459
1460     DestroyWindow(hList);
1461
1462     /* WM_MEASUREITEM should be sent when created with LVS_OWNERDRAWFIXED */
1463     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1464     hList = create_listview_control(LVS_OWNERDRAWFIXED | LVS_REPORT);
1465     ok_sequence(sequences, PARENT_SEQ_INDEX, create_ownerdrawfixed_parent_seq,
1466                 "created with LVS_OWNERDRAWFIXED|LVS_REPORT - parent seq", FALSE);
1467     DestroyWindow(hList);
1468 }
1469
1470 static void test_redraw(void)
1471 {
1472     HWND hwnd;
1473     HDC hdc;
1474     BOOL res;
1475     DWORD r;
1476
1477     hwnd = create_listview_control(LVS_REPORT);
1478     subclass_header(hwnd);
1479
1480     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1481
1482     trace("invalidate & update\n");
1483     InvalidateRect(hwnd, NULL, TRUE);
1484     UpdateWindow(hwnd);
1485     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, redraw_listview_seq, "redraw listview", FALSE);
1486
1487     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1488
1489     /* forward WM_ERASEBKGND to parent on CLR_NONE background color */
1490     /* 1. Without backbuffer */
1491     res = ListView_SetBkColor(hwnd, CLR_NONE);
1492     expect(TRUE, res);
1493
1494     hdc = GetWindowDC(hwndparent);
1495
1496     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1497     r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1498     ok(r != 0, "Expected not zero result\n");
1499     ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, forward_erasebkgnd_parent_seq,
1500                 "forward WM_ERASEBKGND on CLR_NONE", FALSE);
1501
1502     res = ListView_SetBkColor(hwnd, CLR_DEFAULT);
1503     expect(TRUE, res);
1504
1505     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1506     r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1507     ok(r != 0, "Expected not zero result\n");
1508     ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, empty_seq,
1509                 "don't forward WM_ERASEBKGND on non-CLR_NONE", FALSE);
1510
1511     /* 2. With backbuffer */
1512     SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_DOUBLEBUFFER,
1513                                                      LVS_EX_DOUBLEBUFFER);
1514     res = ListView_SetBkColor(hwnd, CLR_NONE);
1515     expect(TRUE, res);
1516
1517     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1518     r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1519     ok(r != 0, "Expected not zero result\n");
1520     ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, forward_erasebkgnd_parent_seq,
1521                 "forward WM_ERASEBKGND on CLR_NONE", FALSE);
1522
1523     res = ListView_SetBkColor(hwnd, CLR_DEFAULT);
1524     expect(TRUE, res);
1525
1526     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1527     r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1528     todo_wine ok(r != 0, "Expected not zero result\n");
1529     ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, empty_seq,
1530                 "don't forward WM_ERASEBKGND on non-CLR_NONE", FALSE);
1531
1532     ReleaseDC(hwndparent, hdc);
1533
1534     DestroyWindow(hwnd);
1535 }
1536
1537 static LRESULT WINAPI cd_wndproc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
1538 {
1539     COLORREF clr, c0ffee = RGB(0xc0, 0xff, 0xee);
1540
1541     if(msg == WM_NOTIFY) {
1542         NMHDR *nmhdr = (PVOID)lp;
1543         if(nmhdr->code == NM_CUSTOMDRAW) {
1544             NMLVCUSTOMDRAW *nmlvcd = (PVOID)nmhdr;
1545             trace("NMCUSTOMDRAW (0x%.8x)\n", nmlvcd->nmcd.dwDrawStage);
1546             switch(nmlvcd->nmcd.dwDrawStage) {
1547             case CDDS_PREPAINT:
1548                 SetBkColor(nmlvcd->nmcd.hdc, c0ffee);
1549                 return CDRF_NOTIFYITEMDRAW;
1550             case CDDS_ITEMPREPAINT:
1551                 nmlvcd->clrTextBk = CLR_DEFAULT;
1552                 return CDRF_NOTIFYSUBITEMDRAW;
1553             case CDDS_ITEMPREPAINT | CDDS_SUBITEM:
1554                 clr = GetBkColor(nmlvcd->nmcd.hdc);
1555                 todo_wine ok(clr == c0ffee, "clr=%.8x\n", clr);
1556                 return CDRF_NOTIFYPOSTPAINT;
1557             case CDDS_ITEMPOSTPAINT | CDDS_SUBITEM:
1558                 clr = GetBkColor(nmlvcd->nmcd.hdc);
1559                 todo_wine ok(clr == c0ffee, "clr=%.8x\n", clr);
1560                 return CDRF_DODEFAULT;
1561             }
1562             return CDRF_DODEFAULT;
1563         }
1564     }
1565
1566     return DefWindowProcA(hwnd, msg, wp, lp);
1567 }
1568
1569 static void test_customdraw(void)
1570 {
1571     HWND hwnd;
1572     WNDPROC oldwndproc;
1573
1574     hwnd = create_listview_control(LVS_REPORT);
1575
1576     insert_column(hwnd, 0);
1577     insert_column(hwnd, 1);
1578     insert_item(hwnd, 0);
1579
1580     oldwndproc = (WNDPROC)SetWindowLongPtr(hwndparent, GWLP_WNDPROC,
1581                                            (LONG_PTR)cd_wndproc);
1582
1583     InvalidateRect(hwnd, NULL, TRUE);
1584     UpdateWindow(hwnd);
1585
1586     SetWindowLongPtr(hwndparent, GWLP_WNDPROC, (LONG_PTR)oldwndproc);
1587
1588     DestroyWindow(hwnd);
1589 }
1590
1591 static void test_icon_spacing(void)
1592 {
1593     /* LVM_SETICONSPACING */
1594     /* note: LVM_SETICONSPACING returns the previous icon spacing if successful */
1595
1596     HWND hwnd;
1597     WORD w, h;
1598     DWORD r;
1599
1600     hwnd = create_listview_control(LVS_ICON);
1601     ok(hwnd != NULL, "failed to create a listview window\n");
1602
1603     r = SendMessage(hwnd, WM_NOTIFYFORMAT, (WPARAM)hwndparent, NF_REQUERY);
1604     expect(NFR_ANSI, r);
1605
1606     /* reset the icon spacing to defaults */
1607     SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
1608
1609     /* now we can request what the defaults are */
1610     r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
1611     w = LOWORD(r);
1612     h = HIWORD(r);
1613
1614     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1615
1616     trace("test icon spacing\n");
1617
1618     r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(20, 30));
1619     ok(r == MAKELONG(w, h) ||
1620        broken(r == MAKELONG(w, w)), /* win98 */
1621        "Expected %d, got %d\n", MAKELONG(w, h), r);
1622
1623     r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(25, 35));
1624     if (r == 0)
1625     {
1626         /* version 4.0 */
1627         win_skip("LVM_SETICONSPACING unimplemented. Skipping.\n");
1628         DestroyWindow(hwnd);
1629         return;
1630     }
1631     expect(MAKELONG(20,30), r);
1632
1633     r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1,-1));
1634     expect(MAKELONG(25,35), r);
1635
1636     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_icon_spacing_seq, "test icon spacing seq", FALSE);
1637
1638     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1639     DestroyWindow(hwnd);
1640 }
1641
1642 static void test_color(void)
1643 {
1644     /* SETBKCOLOR/GETBKCOLOR, SETTEXTCOLOR/GETTEXTCOLOR, SETTEXTBKCOLOR/GETTEXTBKCOLOR */
1645
1646     HWND hwnd;
1647     DWORD r;
1648     int i;
1649
1650     COLORREF color;
1651     COLORREF colors[4] = {RGB(0,0,0), RGB(100,50,200), CLR_NONE, RGB(255,255,255)};
1652
1653     hwnd = create_listview_control(LVS_REPORT);
1654     ok(hwnd != NULL, "failed to create a listview window\n");
1655
1656     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1657
1658     trace("test color seq\n");
1659     for (i = 0; i < 4; i++)
1660     {
1661         color = colors[i];
1662
1663         r = SendMessage(hwnd, LVM_SETBKCOLOR, 0, color);
1664         expect(TRUE, r);
1665         r = SendMessage(hwnd, LVM_GETBKCOLOR, 0, color);
1666         expect(color, r);
1667
1668         r = SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, color);
1669         expect (TRUE, r);
1670         r = SendMessage(hwnd, LVM_GETTEXTCOLOR, 0, color);
1671         expect(color, r);
1672
1673         r = SendMessage(hwnd, LVM_SETTEXTBKCOLOR, 0, color);
1674         expect(TRUE, r);
1675         r = SendMessage(hwnd, LVM_GETTEXTBKCOLOR, 0, color);
1676         expect(color, r);
1677     }
1678
1679     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_color_seq, "test color seq", FALSE);
1680
1681     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1682     DestroyWindow(hwnd);
1683 }
1684
1685 static void test_item_count(void)
1686 {
1687     /* LVM_INSERTITEM, LVM_DELETEITEM, LVM_DELETEALLITEMS, LVM_GETITEMCOUNT */
1688
1689     HWND hwnd;
1690     DWORD r;
1691     HDC hdc;
1692     HFONT hOldFont;
1693     TEXTMETRICA tm;
1694     RECT rect;
1695     INT height;
1696
1697     LVITEM item0;
1698     LVITEM item1;
1699     LVITEM item2;
1700     static CHAR item0text[] = "item0";
1701     static CHAR item1text[] = "item1";
1702     static CHAR item2text[] = "item2";
1703
1704     hwnd = create_listview_control(LVS_REPORT);
1705     ok(hwnd != NULL, "failed to create a listview window\n");
1706
1707     /* resize in dpiaware manner to fit all 3 items added */
1708     hdc = GetDC(0);
1709     hOldFont = SelectObject(hdc, GetStockObject(SYSTEM_FONT));
1710     GetTextMetricsA(hdc, &tm);
1711     /* 2 extra pixels for bounds and header border */
1712     height = tm.tmHeight + 2;
1713     SelectObject(hdc, hOldFont);
1714     ReleaseDC(0, hdc);
1715
1716     GetWindowRect(hwnd, &rect);
1717     /* 3 items + 1 header + 1 to be sure */
1718     MoveWindow(hwnd, 0, 0, rect.right - rect.left, 5 * height, FALSE);
1719
1720     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1721
1722     trace("test item count\n");
1723
1724     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1725     expect(0, r);
1726
1727     /* [item0] */
1728     item0.mask = LVIF_TEXT;
1729     item0.iItem = 0;
1730     item0.iSubItem = 0;
1731     item0.pszText = item0text;
1732     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item0);
1733     expect(0, r);
1734
1735     /* [item0, item1] */
1736     item1.mask = LVIF_TEXT;
1737     item1.iItem = 1;
1738     item1.iSubItem = 0;
1739     item1.pszText = item1text;
1740     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
1741     expect(1, r);
1742
1743     /* [item0, item1, item2] */
1744     item2.mask = LVIF_TEXT;
1745     item2.iItem = 2;
1746     item2.iSubItem = 0;
1747     item2.pszText = item2text;
1748     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item2);
1749     expect(2, r);
1750
1751     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1752     expect(3, r);
1753
1754     /* [item0, item1] */
1755     r = SendMessage(hwnd, LVM_DELETEITEM, 2, 0);
1756     expect(TRUE, r);
1757
1758     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1759     expect(2, r);
1760
1761     /* [] */
1762     r = SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0);
1763     expect(TRUE, r);
1764
1765     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1766     expect(0, r);
1767
1768     /* [item0] */
1769     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
1770     expect(0, r);
1771
1772     /* [item0, item1] */
1773     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
1774     expect(1, r);
1775
1776     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1777     expect(2, r);
1778
1779     /* [item0, item1, item2] */
1780     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item2);
1781     expect(2, r);
1782
1783     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1784     expect(3, r);
1785
1786     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_item_count_seq, "test item count seq", FALSE);
1787
1788     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1789     DestroyWindow(hwnd);
1790 }
1791
1792 static void test_item_position(void)
1793 {
1794     /* LVM_SETITEMPOSITION/LVM_GETITEMPOSITION */
1795
1796     HWND hwnd;
1797     DWORD r;
1798     POINT position;
1799
1800     LVITEM item0;
1801     LVITEM item1;
1802     LVITEM item2;
1803     static CHAR item0text[] = "item0";
1804     static CHAR item1text[] = "item1";
1805     static CHAR item2text[] = "item2";
1806
1807     hwnd = create_listview_control(LVS_ICON);
1808     ok(hwnd != NULL, "failed to create a listview window\n");
1809
1810     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1811
1812     trace("test item position\n");
1813
1814     /* [item0] */
1815     item0.mask = LVIF_TEXT;
1816     item0.iItem = 0;
1817     item0.iSubItem = 0;
1818     item0.pszText = item0text;
1819     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item0);
1820     expect(0, r);
1821
1822     /* [item0, item1] */
1823     item1.mask = LVIF_TEXT;
1824     item1.iItem = 1;
1825     item1.iSubItem = 0;
1826     item1.pszText = item1text;
1827     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
1828     expect(1, r);
1829
1830     /* [item0, item1, item2] */
1831     item2.mask = LVIF_TEXT;
1832     item2.iItem = 2;
1833     item2.iSubItem = 0;
1834     item2.pszText = item2text;
1835     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item2);
1836     expect(2, r);
1837
1838     r = SendMessage(hwnd, LVM_SETITEMPOSITION, 1, MAKELPARAM(10,5));
1839     expect(TRUE, r);
1840     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 1, (LPARAM) &position);
1841     expect(TRUE, r);
1842     expect2(10, 5, position.x, position.y);
1843
1844     r = SendMessage(hwnd, LVM_SETITEMPOSITION, 2, MAKELPARAM(0,0));
1845     expect(TRUE, r);
1846     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 2, (LPARAM) &position);
1847     expect(TRUE, r);
1848     expect2(0, 0, position.x, position.y);
1849
1850     r = SendMessage(hwnd, LVM_SETITEMPOSITION, 0, MAKELPARAM(20,20));
1851     expect(TRUE, r);
1852     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM) &position);
1853     expect(TRUE, r);
1854     expect2(20, 20, position.x, position.y);
1855
1856     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_itempos_seq, "test item position seq", TRUE);
1857
1858     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1859     DestroyWindow(hwnd);
1860 }
1861
1862 static void test_getorigin(void)
1863 {
1864     /* LVM_GETORIGIN */
1865
1866     HWND hwnd;
1867     DWORD r;
1868     POINT position;
1869
1870     position.x = position.y = 0;
1871
1872     hwnd = create_listview_control(LVS_ICON);
1873     ok(hwnd != NULL, "failed to create a listview window\n");
1874     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1875     trace("test get origin results\n");
1876     r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
1877     expect(TRUE, r);
1878     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1879     DestroyWindow(hwnd);
1880
1881     hwnd = create_listview_control(LVS_SMALLICON);
1882     ok(hwnd != NULL, "failed to create a listview window\n");
1883     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1884     trace("test get origin results\n");
1885     r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
1886     expect(TRUE, r);
1887     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1888     DestroyWindow(hwnd);
1889
1890     hwnd = create_listview_control(LVS_LIST);
1891     ok(hwnd != NULL, "failed to create a listview window\n");
1892     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1893     trace("test get origin results\n");
1894     r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
1895     expect(FALSE, r);
1896     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1897     DestroyWindow(hwnd);
1898
1899     hwnd = create_listview_control(LVS_REPORT);
1900     ok(hwnd != NULL, "failed to create a listview window\n");
1901     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1902     trace("test get origin results\n");
1903     r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
1904     expect(FALSE, r);
1905     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1906     DestroyWindow(hwnd);
1907
1908 }
1909
1910 static void test_multiselect(void)
1911 {
1912     typedef struct t_select_task
1913     {
1914         const char *descr;
1915         int initPos;
1916         int loopVK;
1917         int count;
1918         int result;
1919     } select_task;
1920
1921     HWND hwnd;
1922     DWORD r;
1923     int i,j,item_count,selected_count;
1924     static const int items=5;
1925     BYTE kstate[256];
1926     select_task task;
1927     LONG_PTR style;
1928     LVITEMA item;
1929
1930     static struct t_select_task task_list[] = {
1931         { "using VK_DOWN", 0, VK_DOWN, -1, -1 },
1932         { "using VK_UP", -1, VK_UP, -1, -1 },
1933         { "using VK_END", 0, VK_END, 1, -1 },
1934         { "using VK_HOME", -1, VK_HOME, 1, -1 }
1935     };
1936
1937
1938     hwnd = create_listview_control(LVS_REPORT);
1939
1940     for (i=0;i<items;i++) {
1941             insert_item(hwnd, 0);
1942     }
1943
1944     item_count = (int)SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1945
1946     expect(items,item_count);
1947
1948     for (i=0;i<4;i++) {
1949         task = task_list[i];
1950
1951         /* deselect all items */
1952         ListView_SetItemState(hwnd, -1, 0, LVIS_SELECTED);
1953         SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
1954
1955         /* set initial position */
1956         SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, (task.initPos == -1 ? item_count -1 : task.initPos));
1957         ListView_SetItemState(hwnd,(task.initPos == -1 ? item_count -1 : task.initPos),LVIS_SELECTED ,LVIS_SELECTED);
1958
1959         selected_count = (int)SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
1960
1961         ok(selected_count == 1, "There should be only one selected item at the beginning (is %d)\n",selected_count);
1962
1963         /* Set SHIFT key pressed */
1964         GetKeyboardState(kstate);
1965         kstate[VK_SHIFT]=0x80;
1966         SetKeyboardState(kstate);
1967
1968         for (j=1;j<=(task.count == -1 ? item_count : task.count);j++) {
1969             r = SendMessage(hwnd, WM_KEYDOWN, task.loopVK, 0);
1970             expect(0,r);
1971             r = SendMessage(hwnd, WM_KEYUP, task.loopVK, 0);
1972             expect(0,r);
1973         }
1974
1975         selected_count = (int)SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
1976
1977         ok((task.result == -1 ? item_count : task.result) == selected_count, "Failed multiple selection %s. There should be %d selected items (is %d)\n", task.descr, item_count, selected_count);
1978
1979         /* Set SHIFT key released */
1980         GetKeyboardState(kstate);
1981         kstate[VK_SHIFT]=0x00;
1982         SetKeyboardState(kstate);
1983     }
1984     DestroyWindow(hwnd);
1985
1986     /* make multiple selection, then switch to LVS_SINGLESEL */
1987     hwnd = create_listview_control(LVS_REPORT);
1988     for (i=0;i<items;i++) {
1989             insert_item(hwnd, 0);
1990     }
1991     item_count = (int)SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
1992     expect(items,item_count);
1993
1994     /* try with NULL pointer */
1995     r = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, 0);
1996     expect(FALSE, r);
1997
1998     /* select all, check notifications */
1999     ListView_SetItemState(hwnd, -1, 0, LVIS_SELECTED);
2000
2001     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2002
2003     item.stateMask = LVIS_SELECTED;
2004     item.state     = LVIS_SELECTED;
2005     r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2006     expect(TRUE, r);
2007
2008     ok_sequence(sequences, PARENT_SEQ_INDEX, select_all_parent_seq,
2009                 "select all notification", FALSE);
2010
2011     /* deselect all items */
2012     ListView_SetItemState(hwnd, -1, 0, LVIS_SELECTED);
2013     SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2014     for (i=0;i<3;i++) {
2015         ListView_SetItemState(hwnd, i, LVIS_SELECTED, LVIS_SELECTED);
2016     }
2017
2018     r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2019     expect(3, r);
2020     r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2021     expect(-1, r);
2022
2023     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2024     ok(!(style & LVS_SINGLESEL), "LVS_SINGLESEL isn't expected\n");
2025     SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SINGLESEL);
2026     /* check that style is accepted */
2027     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2028     ok(style & LVS_SINGLESEL, "LVS_SINGLESEL expected\n");
2029
2030     for (i=0;i<3;i++) {
2031         r = ListView_GetItemState(hwnd, i, LVIS_SELECTED);
2032         ok(r & LVIS_SELECTED, "Expected item %d to be selected\n", i);
2033     }
2034     r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2035     expect(3, r);
2036     SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2037     expect(3, r);
2038
2039     /* select one more */
2040     ListView_SetItemState(hwnd, 3, LVIS_SELECTED, LVIS_SELECTED);
2041
2042     for (i=0;i<3;i++) {
2043         r = ListView_GetItemState(hwnd, i, LVIS_SELECTED);
2044         ok(!(r & LVIS_SELECTED), "Expected item %d to be unselected\n", i);
2045     }
2046     r = ListView_GetItemState(hwnd, 3, LVIS_SELECTED);
2047     ok(r & LVIS_SELECTED, "Expected item %d to be selected\n", i);
2048
2049     r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2050     expect(1, r);
2051     r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2052     expect(-1, r);
2053
2054     /* try to select all on LVS_SINGLESEL */
2055     memset(&item, 0, sizeof(item));
2056     item.stateMask = LVIS_SELECTED;
2057     r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2058     expect(TRUE, r);
2059     SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2060
2061     item.stateMask = LVIS_SELECTED;
2062     item.state     = LVIS_SELECTED;
2063     r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2064     expect(FALSE, r);
2065
2066     r = ListView_GetSelectedCount(hwnd);
2067     expect(0, r);
2068     r = ListView_GetSelectionMark(hwnd);
2069     expect(-1, r);
2070
2071     /* try to deselect all on LVS_SINGLESEL */
2072     item.stateMask = LVIS_SELECTED;
2073     item.state     = LVIS_SELECTED;
2074     r = SendMessage(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2075     expect(TRUE, r);
2076
2077     item.stateMask = LVIS_SELECTED;
2078     item.state     = 0;
2079     r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2080     expect(TRUE, r);
2081     r = ListView_GetSelectedCount(hwnd);
2082     expect(0, r);
2083
2084     DestroyWindow(hwnd);
2085 }
2086
2087 static void test_subitem_rect(void)
2088 {
2089     HWND hwnd;
2090     DWORD r;
2091     LVCOLUMN col;
2092     RECT rect, rect2;
2093     INT arr[3];
2094
2095     /* test LVM_GETSUBITEMRECT for header */
2096     hwnd = create_listview_control(LVS_REPORT);
2097     ok(hwnd != NULL, "failed to create a listview window\n");
2098     /* add some columns */
2099     memset(&col, 0, sizeof(LVCOLUMN));
2100     col.mask = LVCF_WIDTH;
2101     col.cx = 100;
2102     r = SendMessage(hwnd, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
2103     expect(0, r);
2104     col.cx = 150;
2105     r = SendMessage(hwnd, LVM_INSERTCOLUMN, 1, (LPARAM)&col);
2106     expect(1, r);
2107     col.cx = 200;
2108     r = SendMessage(hwnd, LVM_INSERTCOLUMN, 2, (LPARAM)&col);
2109     expect(2, r);
2110     /* item = -1 means header, subitem index is 1 based */
2111     rect.left = LVIR_BOUNDS;
2112     rect.top  = 0;
2113     rect.right = rect.bottom = 0;
2114     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2115     expect(0, r);
2116
2117     rect.left = LVIR_BOUNDS;
2118     rect.top  = 1;
2119     rect.right = rect.bottom = 0;
2120     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2121
2122     ok(r != 0, "Expected not-null LRESULT\n");
2123     expect(100, rect.left);
2124     expect(250, rect.right);
2125 todo_wine
2126     expect(3, rect.top);
2127
2128     rect.left = LVIR_BOUNDS;
2129     rect.top  = 2;
2130     rect.right = rect.bottom = 0;
2131     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2132
2133     ok(r != 0, "Expected not-null LRESULT\n");
2134     expect(250, rect.left);
2135     expect(450, rect.right);
2136 todo_wine
2137     expect(3, rect.top);
2138
2139     /* item LVS_REPORT padding isn't applied to subitems */
2140     insert_item(hwnd, 0);
2141
2142     rect.left = LVIR_BOUNDS;
2143     rect.top  = 1;
2144     rect.right = rect.bottom = 0;
2145     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2146     ok(r != 0, "Expected not-null LRESULT\n");
2147     expect(100, rect.left);
2148     expect(250, rect.right);
2149
2150     rect.left = LVIR_ICON;
2151     rect.top  = 1;
2152     rect.right = rect.bottom = 0;
2153     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2154     ok(r != 0, "Expected not-null LRESULT\n");
2155     /* no icon attached - zero width rectangle, with no left padding */
2156     expect(100, rect.left);
2157     expect(100, rect.right);
2158
2159     rect.left = LVIR_LABEL;
2160     rect.top  = 1;
2161     rect.right = rect.bottom = 0;
2162     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2163     ok(r != 0, "Expected not-null LRESULT\n");
2164     /* same as full LVIR_BOUNDS */
2165     expect(100, rect.left);
2166     expect(250, rect.right);
2167
2168     SendMessage(hwnd, LVM_SCROLL, 10, 0);
2169
2170     rect.left = LVIR_BOUNDS;
2171     rect.top  = 1;
2172     rect.right = rect.bottom = 0;
2173     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2174     ok(r != 0, "Expected not-null LRESULT\n");
2175     expect(90, rect.left);
2176     expect(240, rect.right);
2177
2178     SendMessage(hwnd, LVM_SCROLL, -10, 0);
2179
2180     DestroyWindow(hwnd);
2181
2182     /* test subitem rects after re-arranging columns */
2183     hwnd = create_listview_control(LVS_REPORT);
2184     ok(hwnd != NULL, "failed to create a listview window\n");
2185     memset(&col, 0, sizeof(LVCOLUMN));
2186     col.mask = LVCF_WIDTH;
2187
2188     col.cx = 100;
2189     r = SendMessage(hwnd, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
2190     expect(0, r);
2191
2192     col.cx = 200;
2193     r = SendMessage(hwnd, LVM_INSERTCOLUMN, 1, (LPARAM)&col);
2194     expect(1, r);
2195
2196     col.cx = 300;
2197     r = SendMessage(hwnd, LVM_INSERTCOLUMN, 2, (LPARAM)&col);
2198     expect(2, r);
2199
2200     insert_item(hwnd, 0);
2201     insert_item(hwnd, 1);
2202
2203     /* wrong item is refused for main item */
2204     rect.left = LVIR_BOUNDS;
2205     rect.top  = 0;
2206     rect.right = rect.bottom = -1;
2207     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect);
2208     ok(r == FALSE, "got %d\n", r);
2209
2210     /* for subitems rectangle is calculated even if there's no item added */
2211     rect.left = LVIR_BOUNDS;
2212     rect.top  = 1;
2213     rect.right = rect.bottom = -1;
2214     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect);
2215     ok(r == TRUE, "got %d\n", r);
2216
2217     rect2.left = LVIR_BOUNDS;
2218     rect2.top  = 1;
2219     rect2.right = rect2.bottom = -1;
2220     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect2);
2221 todo_wine {
2222     ok(r == TRUE, "got %d\n", r);
2223     expect(rect.right, rect2.right);
2224     expect(rect.left, rect2.left);
2225     expect(rect.bottom, rect2.top);
2226     ok(rect2.bottom > rect2.top, "expected not zero height\n");
2227 }
2228
2229     arr[0] = 1; arr[1] = 0; arr[2] = 2;
2230     r = SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, 3, (LPARAM)arr);
2231     expect(TRUE, r);
2232
2233     rect.left = LVIR_BOUNDS;
2234     rect.top  = 0;
2235     rect.right = rect.bottom = -1;
2236     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2237     ok(r == TRUE, "got %d\n", r);
2238     expect(0, rect.left);
2239     expect(600, rect.right);
2240
2241     rect.left = LVIR_BOUNDS;
2242     rect.top  = 1;
2243     rect.right = rect.bottom = -1;
2244     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2245     ok(r == TRUE, "got %d\n", r);
2246     expect(0, rect.left);
2247     expect(200, rect.right);
2248
2249     rect2.left = LVIR_BOUNDS;
2250     rect2.top  = 1;
2251     rect2.right = rect2.bottom = -1;
2252     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect2);
2253     ok(r == TRUE, "got %d\n", r);
2254     expect(0, rect2.left);
2255     expect(200, rect2.right);
2256     /* items are of the same height */
2257     ok(rect2.top > 0, "expected positive item height\n");
2258     expect(rect.bottom, rect2.top);
2259     expect(rect.bottom * 2 - rect.top, rect2.bottom);
2260
2261     rect.left = LVIR_BOUNDS;
2262     rect.top  = 2;
2263     rect.right = rect.bottom = -1;
2264     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2265     ok(r == TRUE, "got %d\n", r);
2266     expect(300, rect.left);
2267     expect(600, rect.right);
2268
2269     DestroyWindow(hwnd);
2270
2271     /* try it for non LVS_REPORT style */
2272     hwnd = CreateWindow("SysListView32", "Test", LVS_ICON, 0, 0, 100, 100, NULL, NULL,
2273                          GetModuleHandle(NULL), 0);
2274     rect.left = LVIR_BOUNDS;
2275     rect.top  = 1;
2276     rect.right = rect.bottom = -10;
2277     r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2278     ok(r == 0, "Expected not-null LRESULT\n");
2279     /* rect is unchanged */
2280     expect(0, rect.left);
2281     expect(-10, rect.right);
2282     expect(1, rect.top);
2283     expect(-10, rect.bottom);
2284     DestroyWindow(hwnd);
2285 }
2286
2287 /* comparison callback for test_sorting */
2288 static INT WINAPI test_CallBackCompare(LPARAM first, LPARAM second, LPARAM lParam)
2289 {
2290     if (first == second) return 0;
2291     return (first > second ? 1 : -1);
2292 }
2293
2294 static void test_sorting(void)
2295 {
2296     HWND hwnd;
2297     LVITEMA item = {0};
2298     DWORD r;
2299     LONG_PTR style;
2300     static CHAR names[][5] = {"A", "B", "C", "D", "0"};
2301     CHAR buff[10];
2302
2303     hwnd = create_listview_control(LVS_REPORT);
2304     ok(hwnd != NULL, "failed to create a listview window\n");
2305
2306     /* insert some items */
2307     item.mask = LVIF_PARAM | LVIF_STATE;
2308     item.state = LVIS_SELECTED;
2309     item.iItem = 0;
2310     item.iSubItem = 0;
2311     item.lParam = 3;
2312     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2313     expect(0, r);
2314
2315     item.mask = LVIF_PARAM;
2316     item.iItem = 1;
2317     item.iSubItem = 0;
2318     item.lParam = 2;
2319     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2320     expect(1, r);
2321
2322     item.mask = LVIF_STATE | LVIF_PARAM;
2323     item.state = LVIS_SELECTED;
2324     item.iItem = 2;
2325     item.iSubItem = 0;
2326     item.lParam = 4;
2327     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2328     expect(2, r);
2329
2330     r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2331     expect(-1, r);
2332
2333     r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2334     expect(2, r);
2335
2336     r = SendMessage(hwnd, LVM_SORTITEMS, 0, (LPARAM)test_CallBackCompare);
2337     expect(TRUE, r);
2338
2339     r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2340     expect(2, r);
2341     r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2342     expect(-1, r);
2343     r = SendMessage(hwnd, LVM_GETITEMSTATE, 0, LVIS_SELECTED);
2344     expect(0, r);
2345     r = SendMessage(hwnd, LVM_GETITEMSTATE, 1, LVIS_SELECTED);
2346     expect(LVIS_SELECTED, r);
2347     r = SendMessage(hwnd, LVM_GETITEMSTATE, 2, LVIS_SELECTED);
2348     expect(LVIS_SELECTED, r);
2349
2350     DestroyWindow(hwnd);
2351
2352     /* switch to LVS_SORTASCENDING when some items added */
2353     hwnd = create_listview_control(LVS_REPORT);
2354     ok(hwnd != NULL, "failed to create a listview window\n");
2355
2356     item.mask = LVIF_TEXT;
2357     item.iItem = 0;
2358     item.iSubItem = 0;
2359     item.pszText = names[1];
2360     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2361     expect(0, r);
2362
2363     item.mask = LVIF_TEXT;
2364     item.iItem = 1;
2365     item.iSubItem = 0;
2366     item.pszText = names[2];
2367     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2368     expect(1, r);
2369
2370     item.mask = LVIF_TEXT;
2371     item.iItem = 2;
2372     item.iSubItem = 0;
2373     item.pszText = names[0];
2374     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2375     expect(2, r);
2376
2377     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2378     SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SORTASCENDING);
2379     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2380     ok(style & LVS_SORTASCENDING, "Expected LVS_SORTASCENDING to be set\n");
2381
2382     /* no sorting performed when switched to LVS_SORTASCENDING */
2383     item.mask = LVIF_TEXT;
2384     item.iItem = 0;
2385     item.pszText = buff;
2386     item.cchTextMax = sizeof(buff);
2387     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2388     expect(TRUE, r);
2389     ok(lstrcmp(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
2390
2391     item.iItem = 1;
2392     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2393     expect(TRUE, r);
2394     ok(lstrcmp(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
2395
2396     item.iItem = 2;
2397     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2398     expect(TRUE, r);
2399     ok(lstrcmp(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
2400
2401     /* adding new item doesn't resort list */
2402     item.mask = LVIF_TEXT;
2403     item.iItem = 3;
2404     item.iSubItem = 0;
2405     item.pszText = names[3];
2406     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2407     expect(3, r);
2408
2409     item.mask = LVIF_TEXT;
2410     item.iItem = 0;
2411     item.pszText = buff;
2412     item.cchTextMax = sizeof(buff);
2413     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2414     expect(TRUE, r);
2415     ok(lstrcmp(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
2416
2417     item.iItem = 1;
2418     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2419     expect(TRUE, r);
2420     ok(lstrcmp(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
2421
2422     item.iItem = 2;
2423     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2424     expect(TRUE, r);
2425     ok(lstrcmp(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
2426
2427     item.iItem = 3;
2428     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2429     expect(TRUE, r);
2430     ok(lstrcmp(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
2431
2432     /* corner case - item should be placed at first position */
2433     item.mask = LVIF_TEXT;
2434     item.iItem = 4;
2435     item.iSubItem = 0;
2436     item.pszText = names[4];
2437     r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
2438     expect(0, r);
2439
2440     item.iItem = 0;
2441     item.pszText = buff;
2442     item.cchTextMax = sizeof(buff);
2443     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2444     expect(TRUE, r);
2445     ok(lstrcmp(buff, names[4]) == 0, "Expected '%s', got '%s'\n", names[4], buff);
2446
2447     item.iItem = 1;
2448     item.pszText = buff;
2449     item.cchTextMax = sizeof(buff);
2450     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2451     expect(TRUE, r);
2452     ok(lstrcmp(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
2453
2454     item.iItem = 2;
2455     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2456     expect(TRUE, r);
2457     ok(lstrcmp(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
2458
2459     item.iItem = 3;
2460     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2461     expect(TRUE, r);
2462     ok(lstrcmp(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
2463
2464     item.iItem = 4;
2465     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
2466     expect(TRUE, r);
2467     ok(lstrcmp(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
2468
2469     DestroyWindow(hwnd);
2470 }
2471
2472 static void test_ownerdata(void)
2473 {
2474     HWND hwnd;
2475     LONG_PTR style, ret;
2476     DWORD res;
2477     LVITEMA item;
2478
2479     /* it isn't possible to set LVS_OWNERDATA after creation */
2480     if (g_is_below_5)
2481     {
2482         win_skip("set LVS_OWNERDATA after creation leads to crash on < 5.80\n");
2483     }
2484     else
2485     {
2486         hwnd = create_listview_control(LVS_REPORT);
2487         ok(hwnd != NULL, "failed to create a listview window\n");
2488         style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2489         ok(!(style & LVS_OWNERDATA) && style, "LVS_OWNERDATA isn't expected\n");
2490
2491         flush_sequences(sequences, NUM_MSG_SEQUENCES);
2492
2493         ret = SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_OWNERDATA);
2494         ok(ret == style, "Expected set GWL_STYLE to succeed\n");
2495         ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_ownerdata_switchto_seq,
2496                 "try to switch to LVS_OWNERDATA seq", FALSE);
2497
2498         style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2499         ok(!(style & LVS_OWNERDATA), "LVS_OWNERDATA isn't expected\n");
2500         DestroyWindow(hwnd);
2501     }
2502
2503     /* try to set LVS_OWNERDATA after creation just having it */
2504     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2505     ok(hwnd != NULL, "failed to create a listview window\n");
2506     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2507     ok(style & LVS_OWNERDATA, "LVS_OWNERDATA is expected\n");
2508
2509     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2510
2511     ret = SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_OWNERDATA);
2512     ok(ret == style, "Expected set GWL_STYLE to succeed\n");
2513     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_ownerdata_switchto_seq,
2514                 "try to switch to LVS_OWNERDATA seq", FALSE);
2515     DestroyWindow(hwnd);
2516
2517     /* try to remove LVS_OWNERDATA after creation just having it */
2518     if (g_is_below_5)
2519     {
2520         win_skip("remove LVS_OWNERDATA after creation leads to crash on < 5.80\n");
2521     }
2522     else
2523     {
2524         hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2525         ok(hwnd != NULL, "failed to create a listview window\n");
2526         style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2527         ok(style & LVS_OWNERDATA, "LVS_OWNERDATA is expected\n");
2528
2529         flush_sequences(sequences, NUM_MSG_SEQUENCES);
2530
2531         ret = SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_OWNERDATA);
2532         ok(ret == style, "Expected set GWL_STYLE to succeed\n");
2533         ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_ownerdata_switchto_seq,
2534                 "try to switch to LVS_OWNERDATA seq", FALSE);
2535         style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2536         ok(style & LVS_OWNERDATA, "LVS_OWNERDATA is expected\n");
2537         DestroyWindow(hwnd);
2538     }
2539
2540     /* try select an item */
2541     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2542     ok(hwnd != NULL, "failed to create a listview window\n");
2543     res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
2544     ok(res != 0, "Expected LVM_SETITEMCOUNT to succeed\n");
2545     res = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2546     expect(0, res);
2547     memset(&item, 0, sizeof(item));
2548     item.stateMask = LVIS_SELECTED;
2549     item.state     = LVIS_SELECTED;
2550     res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2551     expect(TRUE, res);
2552     res = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2553     expect(1, res);
2554     res = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2555     expect(1, res);
2556     DestroyWindow(hwnd);
2557
2558     /* LVM_SETITEM is unsupported on LVS_OWNERDATA */
2559     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2560     ok(hwnd != NULL, "failed to create a listview window\n");
2561     res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
2562     ok(res != 0, "Expected LVM_SETITEMCOUNT to succeed\n");
2563     res = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2564     expect(1, res);
2565     memset(&item, 0, sizeof(item));
2566     item.mask = LVIF_STATE;
2567     item.iItem = 0;
2568     item.stateMask = LVIS_SELECTED;
2569     item.state     = LVIS_SELECTED;
2570     res = SendMessageA(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
2571     expect(FALSE, res);
2572     DestroyWindow(hwnd);
2573
2574     /* check notifications after focused/selected changed */
2575     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2576     ok(hwnd != NULL, "failed to create a listview window\n");
2577     res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 20, 0);
2578     ok(res != 0, "Expected LVM_SETITEMCOUNT to succeed\n");
2579
2580     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2581
2582     memset(&item, 0, sizeof(item));
2583     item.stateMask = LVIS_SELECTED;
2584     item.state     = LVIS_SELECTED;
2585     res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2586     expect(TRUE, res);
2587
2588     ok_sequence(sequences, PARENT_SEQ_INDEX, ownderdata_select_focus_parent_seq,
2589                 "ownerdata select notification", TRUE);
2590
2591     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2592
2593     memset(&item, 0, sizeof(item));
2594     item.stateMask = LVIS_FOCUSED;
2595     item.state     = LVIS_FOCUSED;
2596     res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2597     expect(TRUE, res);
2598
2599     ok_sequence(sequences, PARENT_SEQ_INDEX, ownderdata_select_focus_parent_seq,
2600                 "ownerdata focus notification", TRUE);
2601
2602     /* select all, check notifications */
2603     item.stateMask = LVIS_SELECTED;
2604     item.state     = 0;
2605     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2606     expect(TRUE, res);
2607
2608     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2609
2610     item.stateMask = LVIS_SELECTED;
2611     item.state     = LVIS_SELECTED;
2612
2613     g_dump_itemchanged = TRUE;
2614     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2615     expect(TRUE, res);
2616     g_dump_itemchanged = FALSE;
2617
2618     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
2619                 "ownerdata select all notification", TRUE);
2620
2621     /* select all again, note that all items are selected already */
2622     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2623     item.stateMask = LVIS_SELECTED;
2624     item.state     = LVIS_SELECTED;
2625     g_dump_itemchanged = TRUE;
2626     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2627     expect(TRUE, res);
2628     g_dump_itemchanged = FALSE;
2629     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
2630                 "ownerdata select all notification", TRUE);
2631     /* deselect all */
2632     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2633     item.stateMask = LVIS_SELECTED;
2634     item.state     = 0;
2635     g_dump_itemchanged = TRUE;
2636     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2637     expect(TRUE, res);
2638     g_dump_itemchanged = FALSE;
2639     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_deselect_all_parent_seq,
2640                 "ownerdata deselect all notification", TRUE);
2641
2642     /* select one, then deselect all */
2643     item.stateMask = LVIS_SELECTED;
2644     item.state     = LVIS_SELECTED;
2645     res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2646     expect(TRUE, res);
2647     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2648     item.stateMask = LVIS_SELECTED;
2649     item.state     = 0;
2650     g_dump_itemchanged = TRUE;
2651     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2652     expect(TRUE, res);
2653     g_dump_itemchanged = FALSE;
2654     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_deselect_all_parent_seq,
2655                 "ownerdata select all notification", TRUE);
2656
2657     /* remove focused, try to focus all */
2658     item.stateMask = LVIS_FOCUSED;
2659     item.state     = LVIS_FOCUSED;
2660     res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2661     expect(TRUE, res);
2662     item.stateMask = LVIS_FOCUSED;
2663     item.state     = 0;
2664     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2665     expect(TRUE, res);
2666     item.stateMask = LVIS_FOCUSED;
2667     res = SendMessageA(hwnd, LVM_GETITEMSTATE, 0, LVIS_FOCUSED);
2668     expect(0, res);
2669     /* setting all to focused returns failure value */
2670     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2671     item.stateMask = LVIS_FOCUSED;
2672     item.state     = LVIS_FOCUSED;
2673     g_dump_itemchanged = TRUE;
2674     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2675     expect(FALSE, res);
2676     g_dump_itemchanged = FALSE;
2677     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
2678                 "ownerdata focus all notification", FALSE);
2679     /* focus single item, remove all */
2680     item.stateMask = LVIS_FOCUSED;
2681     item.state     = LVIS_FOCUSED;
2682     res = SendMessage(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2683     expect(TRUE, res);
2684     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2685     item.stateMask = LVIS_FOCUSED;
2686     item.state     = 0;
2687     g_dump_itemchanged = TRUE;
2688     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2689     expect(TRUE, res);
2690     g_dump_itemchanged = FALSE;
2691     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_defocus_all_parent_seq,
2692                 "ownerdata remove focus all notification", TRUE);
2693     /* set all cut */
2694     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2695     item.stateMask = LVIS_CUT;
2696     item.state     = LVIS_CUT;
2697     g_dump_itemchanged = TRUE;
2698     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2699     expect(TRUE, res);
2700     g_dump_itemchanged = FALSE;
2701     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
2702                 "ownerdata cut all notification", TRUE);
2703     /* all marked cut, try again */
2704     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2705     item.stateMask = LVIS_CUT;
2706     item.state     = LVIS_CUT;
2707     g_dump_itemchanged = TRUE;
2708     res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2709     expect(TRUE, res);
2710     g_dump_itemchanged = FALSE;
2711     ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
2712                 "ownerdata cut all notification #2", TRUE);
2713
2714     DestroyWindow(hwnd);
2715
2716     /* check notifications on LVM_GETITEM */
2717     /* zero callback mask */
2718     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2719     ok(hwnd != NULL, "failed to create a listview window\n");
2720     res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
2721     ok(res != 0, "Expected LVM_SETITEMCOUNT to succeed\n");
2722
2723     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2724
2725     memset(&item, 0, sizeof(item));
2726     item.stateMask = LVIS_SELECTED;
2727     item.mask      = LVIF_STATE;
2728     res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
2729     expect(TRUE, res);
2730
2731     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
2732                 "ownerdata getitem selected state 1", FALSE);
2733
2734     /* non zero callback mask but not we asking for */
2735     res = SendMessageA(hwnd, LVM_SETCALLBACKMASK, LVIS_OVERLAYMASK, 0);
2736     expect(TRUE, res);
2737
2738     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2739
2740     memset(&item, 0, sizeof(item));
2741     item.stateMask = LVIS_SELECTED;
2742     item.mask      = LVIF_STATE;
2743     res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
2744     expect(TRUE, res);
2745
2746     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
2747                 "ownerdata getitem selected state 2", FALSE);
2748
2749     /* LVIS_OVERLAYMASK callback mask, asking for index */
2750     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2751
2752     memset(&item, 0, sizeof(item));
2753     item.stateMask = LVIS_OVERLAYMASK;
2754     item.mask      = LVIF_STATE;
2755     res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
2756     expect(TRUE, res);
2757
2758     ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
2759                 "ownerdata getitem selected state 2", FALSE);
2760
2761     DestroyWindow(hwnd);
2762
2763     /* LVS_SORTASCENDING/LVS_SORTDESCENDING aren't compatible with LVS_OWNERDATA */
2764     hwnd = create_listview_control(LVS_OWNERDATA | LVS_SORTASCENDING | LVS_REPORT);
2765     ok(hwnd != NULL, "failed to create a listview window\n");
2766     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2767     ok(style & LVS_OWNERDATA, "Expected LVS_OWNERDATA\n");
2768     ok(style & LVS_SORTASCENDING, "Expected LVS_SORTASCENDING to be set\n");
2769     SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_SORTASCENDING);
2770     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2771     ok(!(style & LVS_SORTASCENDING), "Expected LVS_SORTASCENDING not set\n");
2772     DestroyWindow(hwnd);
2773     /* apparently it's allowed to switch these style on after creation */
2774     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2775     ok(hwnd != NULL, "failed to create a listview window\n");
2776     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2777     ok(style & LVS_OWNERDATA, "Expected LVS_OWNERDATA\n");
2778     SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SORTASCENDING);
2779     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2780     ok(style & LVS_SORTASCENDING, "Expected LVS_SORTASCENDING to be set\n");
2781     DestroyWindow(hwnd);
2782
2783     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2784     ok(hwnd != NULL, "failed to create a listview window\n");
2785     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2786     ok(style & LVS_OWNERDATA, "Expected LVS_OWNERDATA\n");
2787     SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SORTDESCENDING);
2788     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2789     ok(style & LVS_SORTDESCENDING, "Expected LVS_SORTDESCENDING to be set\n");
2790     DestroyWindow(hwnd);
2791 }
2792
2793 static void test_norecompute(void)
2794 {
2795     static CHAR testA[] = "test";
2796     CHAR buff[10];
2797     LVITEMA item;
2798     HWND hwnd;
2799     DWORD res;
2800
2801     /* self containing control */
2802     hwnd = create_listview_control(LVS_REPORT);
2803     ok(hwnd != NULL, "failed to create a listview window\n");
2804     memset(&item, 0, sizeof(item));
2805     item.mask = LVIF_TEXT | LVIF_STATE;
2806     item.iItem = 0;
2807     item.stateMask = LVIS_SELECTED;
2808     item.state     = LVIS_SELECTED;
2809     item.pszText   = testA;
2810     res = SendMessageA(hwnd, LVM_INSERTITEM, 0, (LPARAM)&item);
2811     expect(0, res);
2812     /* retrieve with LVIF_NORECOMPUTE */
2813     item.mask  = LVIF_TEXT | LVIF_NORECOMPUTE;
2814     item.iItem = 0;
2815     item.pszText    = buff;
2816     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
2817     res = SendMessageA(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
2818     expect(TRUE, res);
2819     ok(lstrcmp(buff, testA) == 0, "Expected (%s), got (%s)\n", testA, buff);
2820
2821     item.mask = LVIF_TEXT;
2822     item.iItem = 1;
2823     item.pszText = LPSTR_TEXTCALLBACK;
2824     res = SendMessageA(hwnd, LVM_INSERTITEM, 0, (LPARAM)&item);
2825     expect(1, res);
2826
2827     item.mask  = LVIF_TEXT | LVIF_NORECOMPUTE;
2828     item.iItem = 1;
2829     item.pszText    = buff;
2830     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
2831
2832     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2833     res = SendMessageA(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
2834     expect(TRUE, res);
2835     ok(item.pszText == LPSTR_TEXTCALLBACK, "Expected (%p), got (%p)\n",
2836        LPSTR_TEXTCALLBACK, (VOID*)item.pszText);
2837     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "retrieve with LVIF_NORECOMPUTE seq", FALSE);
2838
2839     DestroyWindow(hwnd);
2840
2841     /* LVS_OWNERDATA */
2842     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2843     ok(hwnd != NULL, "failed to create a listview window\n");
2844
2845     item.mask = LVIF_STATE;
2846     item.stateMask = LVIS_SELECTED;
2847     item.state     = LVIS_SELECTED;
2848     item.iItem = 0;
2849     res = SendMessageA(hwnd, LVM_INSERTITEM, 0, (LPARAM)&item);
2850     expect(0, res);
2851
2852     item.mask  = LVIF_TEXT | LVIF_NORECOMPUTE;
2853     item.iItem = 0;
2854     item.pszText    = buff;
2855     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
2856     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2857     res = SendMessageA(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
2858     expect(TRUE, res);
2859     ok(item.pszText == LPSTR_TEXTCALLBACK, "Expected (%p), got (%p)\n",
2860        LPSTR_TEXTCALLBACK, (VOID*)item.pszText);
2861     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "retrieve with LVIF_NORECOMPUTE seq 2", FALSE);
2862
2863     DestroyWindow(hwnd);
2864 }
2865
2866 static void test_nosortheader(void)
2867 {
2868     HWND hwnd, header;
2869     LONG_PTR style;
2870
2871     hwnd = create_listview_control(LVS_REPORT);
2872     ok(hwnd != NULL, "failed to create a listview window\n");
2873
2874     header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
2875     ok(IsWindow(header), "header expected\n");
2876
2877     style = GetWindowLongPtr(header, GWL_STYLE);
2878     ok(style & HDS_BUTTONS, "expected header to have HDS_BUTTONS\n");
2879
2880     style = GetWindowLongPtr(hwnd, GWL_STYLE);
2881     SetWindowLongPtr(hwnd, GWL_STYLE, style | LVS_NOSORTHEADER);
2882     /* HDS_BUTTONS retained */
2883     style = GetWindowLongPtr(header, GWL_STYLE);
2884     ok(style & HDS_BUTTONS, "expected header to retain HDS_BUTTONS\n");
2885
2886     DestroyWindow(hwnd);
2887
2888     /* create with LVS_NOSORTHEADER */
2889     hwnd = create_listview_control(LVS_NOSORTHEADER | LVS_REPORT);
2890     ok(hwnd != NULL, "failed to create a listview window\n");
2891
2892     header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
2893     ok(IsWindow(header), "header expected\n");
2894
2895     style = GetWindowLongPtr(header, GWL_STYLE);
2896     ok(!(style & HDS_BUTTONS), "expected header to have no HDS_BUTTONS\n");
2897
2898     style = GetWindowLongPtr(hwnd, GWL_STYLE);
2899     SetWindowLongPtr(hwnd, GWL_STYLE, style & ~LVS_NOSORTHEADER);
2900     /* not changed here */
2901     style = GetWindowLongPtr(header, GWL_STYLE);
2902     ok(!(style & HDS_BUTTONS), "expected header to have no HDS_BUTTONS\n");
2903
2904     DestroyWindow(hwnd);
2905 }
2906
2907 static void test_setredraw(void)
2908 {
2909     HWND hwnd;
2910     DWORD_PTR style;
2911     DWORD ret;
2912     HDC hdc;
2913     RECT rect;
2914
2915     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
2916     ok(hwnd != NULL, "failed to create a listview window\n");
2917
2918     /* Passing WM_SETREDRAW to DefWinProc removes WS_VISIBLE.
2919        ListView seems to handle it internally without DefWinProc */
2920
2921     /* default value first */
2922     ret = SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
2923     expect(0, ret);
2924     /* disable */
2925     style = GetWindowLongPtr(hwnd, GWL_STYLE);
2926     ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
2927     ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
2928     expect(0, ret);
2929     style = GetWindowLongPtr(hwnd, GWL_STYLE);
2930     ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
2931     ret = SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
2932     expect(0, ret);
2933
2934     /* check update rect after redrawing */
2935     ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
2936     expect(0, ret);
2937     InvalidateRect(hwnd, NULL, FALSE);
2938     RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
2939     rect.right = rect.bottom = 1;
2940     GetUpdateRect(hwnd, &rect, FALSE);
2941     expect(0, rect.right);
2942     expect(0, rect.bottom);
2943
2944     /* WM_ERASEBKGND */
2945     hdc = GetWindowDC(hwndparent);
2946     ret = SendMessage(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
2947     expect(TRUE, ret);
2948     ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
2949     expect(0, ret);
2950     ret = SendMessage(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
2951     expect(TRUE, ret);
2952     ret = SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
2953     expect(0, ret);
2954     ReleaseDC(hwndparent, hdc);
2955
2956     /* check notification messages to show that repainting is disabled */
2957     ret = SendMessage(hwnd, LVM_SETITEMCOUNT, 1, 0);
2958     expect(TRUE, ret);
2959     ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
2960     expect(0, ret);
2961     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2962
2963     InvalidateRect(hwnd, NULL, TRUE);
2964     UpdateWindow(hwnd);
2965     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
2966                 "redraw after WM_SETREDRAW (FALSE)", FALSE);
2967
2968     ret = SendMessage(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
2969     expect(TRUE, ret);
2970     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2971     InvalidateRect(hwnd, NULL, TRUE);
2972     UpdateWindow(hwnd);
2973     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
2974                 "redraw after WM_SETREDRAW (FALSE) with CLR_NONE bkgnd", FALSE);
2975
2976     /* message isn't forwarded to header */
2977     subclass_header(hwnd);
2978     flush_sequences(sequences, NUM_MSG_SEQUENCES);
2979     ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
2980     expect(0, ret);
2981     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, setredraw_seq,
2982                 "WM_SETREDRAW: not forwarded to header", FALSE);
2983
2984     DestroyWindow(hwnd);
2985 }
2986
2987 static void test_hittest(void)
2988 {
2989     HWND hwnd;
2990     DWORD r;
2991     RECT bounds;
2992     LVITEMA item;
2993     static CHAR text[] = "1234567890ABCDEFGHIJKLMNOPQRST";
2994     POINT pos;
2995     INT x, y, i;
2996     WORD horiz, vert;
2997     HIMAGELIST himl, himl2;
2998     HBITMAP hbmp;
2999
3000     hwnd = create_listview_control(LVS_REPORT);
3001     ok(hwnd != NULL, "failed to create a listview window\n");
3002
3003     /* LVS_REPORT with a single subitem (2 columns) */
3004     insert_column(hwnd, 0);
3005     insert_column(hwnd, 1);
3006     insert_item(hwnd, 0);
3007
3008     item.iSubItem = 0;
3009     /* the only purpose of that line is to be as long as a half item rect */
3010     item.pszText  = text;
3011     r = SendMessage(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&item);
3012     expect(TRUE, r);
3013
3014     r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
3015     expect(TRUE, r);
3016     r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
3017     expect(TRUE, r);
3018
3019     memset(&bounds, 0, sizeof(bounds));
3020     bounds.left = LVIR_BOUNDS;
3021     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&bounds);
3022     ok(bounds.bottom - bounds.top > 0, "Expected non zero item height\n");
3023     ok(bounds.right - bounds.left > 0, "Expected non zero item width\n");
3024     r = SendMessage(hwnd, LVM_GETITEMSPACING, TRUE, 0);
3025     horiz = LOWORD(r);
3026     vert = HIWORD(r);
3027     ok(bounds.bottom - bounds.top == vert,
3028         "Vertical spacing inconsistent (%d != %d)\n", bounds.bottom - bounds.top, vert);
3029     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pos);
3030     expect(TRUE, r);
3031
3032     /* LVS_EX_FULLROWSELECT not set, no icons attached */
3033
3034     /* outside columns by x position - valid is [0, 199] */
3035     x = -1;
3036     y = pos.y + (bounds.bottom - bounds.top) / 2;
3037     test_lvm_hittest(hwnd, x, y, -1, LVHT_TOLEFT, 0, FALSE, FALSE);
3038     test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3039
3040     x = pos.x + 50; /* column half width */
3041     y = pos.y + (bounds.bottom - bounds.top) / 2;
3042     test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMLABEL, 0, FALSE, FALSE);
3043     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3044     x = pos.x + 150; /* outside column */
3045     y = pos.y + (bounds.bottom - bounds.top) / 2;
3046     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3047     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3048     y = (bounds.bottom - bounds.top) / 2;
3049     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3050     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3051     /* outside possible client rectangle (to right) */
3052     x = pos.x + 500;
3053     y = pos.y + (bounds.bottom - bounds.top) / 2;
3054     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3055     test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3056     y = (bounds.bottom - bounds.top) / 2;
3057     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3058     test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3059     /* subitem returned with -1 item too */
3060     x = pos.x + 150;
3061     y = bounds.top - vert;
3062     test_lvm_subitemhittest(hwnd, x, y, -1, 1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3063     test_lvm_subitemhittest(hwnd, x, y - vert + 1, -1, 1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3064     /* return values appear to underflow with negative indices */
3065     i = -2;
3066     y = y - vert;
3067     while (i > -10) {
3068         test_lvm_subitemhittest(hwnd, x, y, i, 1, LVHT_ONITEMLABEL, TRUE, FALSE, TRUE);
3069         test_lvm_subitemhittest(hwnd, x, y - vert + 1, i, 1, LVHT_ONITEMLABEL, TRUE, FALSE, TRUE);
3070         y = y - vert;
3071         i--;
3072     }
3073     /* parent client area is 100x100 by default */
3074     MoveWindow(hwnd, 0, 0, 300, 100, FALSE);
3075     x = pos.x + 150; /* outside column */
3076     y = pos.y + (bounds.bottom - bounds.top) / 2;
3077     test_lvm_hittest(hwnd, x, y, -1, LVHT_NOWHERE, 0, FALSE, FALSE);
3078     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3079     y = (bounds.bottom - bounds.top) / 2;
3080     test_lvm_hittest(hwnd, x, y, -1, LVHT_NOWHERE, 0, FALSE, TRUE);
3081     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3082     /* the same with LVS_EX_FULLROWSELECT */
3083     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
3084     x = pos.x + 150; /* outside column */
3085     y = pos.y + (bounds.bottom - bounds.top) / 2;
3086     test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEM, LVHT_ONITEMLABEL, FALSE, FALSE);
3087     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3088     y = (bounds.bottom - bounds.top) / 2;
3089     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3090     MoveWindow(hwnd, 0, 0, 100, 100, FALSE);
3091     x = pos.x + 150; /* outside column */
3092     y = pos.y + (bounds.bottom - bounds.top) / 2;
3093     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3094     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3095     y = (bounds.bottom - bounds.top) / 2;
3096     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3097     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3098     /* outside possible client rectangle (to right) */
3099     x = pos.x + 500;
3100     y = pos.y + (bounds.bottom - bounds.top) / 2;
3101     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3102     test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3103     y = (bounds.bottom - bounds.top) / 2;
3104     test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3105     test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3106     /* try with icons, state icons index is 1 based so at least 2 bitmaps needed */
3107     himl = ImageList_Create(16, 16, 0, 4, 4);
3108     ok(himl != NULL, "failed to create imagelist\n");
3109     hbmp = CreateBitmap(16, 16, 1, 1, NULL);
3110     ok(hbmp != NULL, "failed to create bitmap\n");
3111     r = ImageList_Add(himl, hbmp, 0);
3112     ok(r == 0, "should be zero\n");
3113     hbmp = CreateBitmap(16, 16, 1, 1, NULL);
3114     ok(hbmp != NULL, "failed to create bitmap\n");
3115     r = ImageList_Add(himl, hbmp, 0);
3116     ok(r == 1, "should be one\n");
3117
3118     r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
3119     ok(r == 0, "should return zero\n");
3120
3121     item.mask = LVIF_IMAGE;
3122     item.iImage = 0;
3123     item.iItem = 0;
3124     item.iSubItem = 0;
3125     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
3126     expect(TRUE, r);
3127     /* on state icon */
3128     x = pos.x + 8;
3129     y = pos.y + (bounds.bottom - bounds.top) / 2;
3130     test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMSTATEICON, 0, FALSE, FALSE);
3131     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3132     y = (bounds.bottom - bounds.top) / 2;
3133     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3134
3135     /* state icons indices are 1 based, check with valid index */
3136     item.mask = LVIF_STATE;
3137     item.state = INDEXTOSTATEIMAGEMASK(1);
3138     item.stateMask = LVIS_STATEIMAGEMASK;
3139     item.iItem = 0;
3140     item.iSubItem = 0;
3141     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
3142     expect(TRUE, r);
3143     /* on state icon */
3144     x = pos.x + 8;
3145     y = pos.y + (bounds.bottom - bounds.top) / 2;
3146     test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMSTATEICON, 0, FALSE, FALSE);
3147     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3148     y = (bounds.bottom - bounds.top) / 2;
3149     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3150
3151     himl2 = (HIMAGELIST)SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
3152     ok(himl2 == himl, "should return handle\n");
3153
3154     r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
3155     ok(r == 0, "should return zero\n");
3156     /* on item icon */
3157     x = pos.x + 8;
3158     y = pos.y + (bounds.bottom - bounds.top) / 2;
3159     test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMICON, 0, FALSE, FALSE);
3160     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMICON, FALSE, FALSE, FALSE);
3161     y = (bounds.bottom - bounds.top) / 2;
3162     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMICON, FALSE, FALSE, FALSE);
3163
3164     DestroyWindow(hwnd);
3165 }
3166
3167 static void test_getviewrect(void)
3168 {
3169     HWND hwnd;
3170     DWORD r;
3171     RECT rect;
3172     LVITEMA item;
3173
3174     hwnd = create_listview_control(LVS_REPORT);
3175     ok(hwnd != NULL, "failed to create a listview window\n");
3176
3177     /* empty */
3178     r = SendMessage(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
3179     expect(TRUE, r);
3180
3181     insert_column(hwnd, 0);
3182     insert_column(hwnd, 1);
3183
3184     memset(&item, 0, sizeof(item));
3185     item.iItem = 0;
3186     item.iSubItem = 0;
3187     SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3188
3189     r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
3190     expect(TRUE, r);
3191     r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(120, 0));
3192     expect(TRUE, r);
3193
3194     rect.left = rect.right = rect.top = rect.bottom = -1;
3195     r = SendMessage(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
3196     expect(TRUE, r);
3197     /* left is set to (2e31-1) - XP SP2 */
3198     expect(0, rect.right);
3199     expect(0, rect.top);
3200     expect(0, rect.bottom);
3201
3202     /* switch to LVS_ICON */
3203     SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~LVS_REPORT);
3204
3205     rect.left = rect.right = rect.top = rect.bottom = -1;
3206     r = SendMessage(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
3207     expect(TRUE, r);
3208     expect(0, rect.left);
3209     expect(0, rect.top);
3210     /* precise value differs for 2k, XP and Vista */
3211     ok(rect.bottom > 0, "Expected positive bottom value, got %d\n", rect.bottom);
3212     ok(rect.right  > 0, "Expected positive right value, got %d\n", rect.right);
3213
3214     DestroyWindow(hwnd);
3215 }
3216
3217 static void test_getitemposition(void)
3218 {
3219     HWND hwnd, header;
3220     DWORD r;
3221     POINT pt;
3222     RECT rect;
3223
3224     hwnd = create_listview_control(LVS_REPORT);
3225     ok(hwnd != NULL, "failed to create a listview window\n");
3226     header = subclass_header(hwnd);
3227
3228     /* LVS_REPORT, single item, no columns added */
3229     insert_item(hwnd, 0);
3230
3231     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3232
3233     pt.x = pt.y = -1;
3234     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
3235     expect(TRUE, r);
3236     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getitemposition_seq1, "get item position 1", FALSE);
3237
3238     /* LVS_REPORT, single item, single column */
3239     insert_column(hwnd, 0);
3240
3241     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3242
3243     pt.x = pt.y = -1;
3244     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
3245     expect(TRUE, r);
3246     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getitemposition_seq2, "get item position 2", TRUE);
3247
3248     memset(&rect, 0, sizeof(rect));
3249     SendMessage(header, HDM_GETITEMRECT, 0, (LPARAM)&rect);
3250     /* some padding? */
3251     expect(2, pt.x);
3252     /* offset by header height */
3253     expect(rect.bottom - rect.top, pt.y);
3254
3255     DestroyWindow(hwnd);
3256 }
3257
3258 static void test_columnscreation(void)
3259 {
3260     HWND hwnd, header;
3261     DWORD r;
3262
3263     hwnd = create_listview_control(LVS_REPORT);
3264     ok(hwnd != NULL, "failed to create a listview window\n");
3265
3266     insert_item(hwnd, 0);
3267
3268     /* headers columns aren't created automatically */
3269     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3270     ok(IsWindow(header), "Expected header handle\n");
3271     r = SendMessage(header, HDM_GETITEMCOUNT, 0, 0);
3272     expect(0, r);
3273
3274     DestroyWindow(hwnd);
3275 }
3276
3277 static void test_getitemrect(void)
3278 {
3279     HWND hwnd;
3280     HIMAGELIST himl;
3281     HBITMAP hbm;
3282     RECT rect;
3283     DWORD r;
3284     LVITEMA item;
3285     LVCOLUMNA col;
3286     INT order[2];
3287     POINT pt;
3288     HDC hdc;
3289
3290     /* rectangle isn't empty for empty text items */
3291     hwnd = create_listview_control(LVS_LIST);
3292     memset(&item, 0, sizeof(item));
3293     item.mask = 0;
3294     item.iItem = 0;
3295     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3296     expect(0, r);
3297     rect.left = LVIR_LABEL;
3298     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3299     expect(TRUE, r);
3300     expect(0, rect.left);
3301     expect(0, rect.top);
3302     hdc = GetDC(hwnd);
3303     todo_wine expect(GetDeviceCaps(hdc, LOGPIXELSX), rect.right);
3304     ReleaseDC(hwnd, hdc);
3305     DestroyWindow(hwnd);
3306
3307     hwnd = create_listview_control(LVS_REPORT);
3308     ok(hwnd != NULL, "failed to create a listview window\n");
3309
3310     /* empty item */
3311     memset(&item, 0, sizeof(item));
3312     item.iItem = 0;
3313     item.iSubItem = 0;
3314     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3315     expect(0, r);
3316
3317     rect.left = LVIR_BOUNDS;
3318     rect.right = rect.top = rect.bottom = -1;
3319     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3320     expect(TRUE, r);
3321
3322     /* zero width rectangle with no padding */
3323     expect(0, rect.left);
3324     expect(0, rect.right);
3325
3326     insert_column(hwnd, 0);
3327     insert_column(hwnd, 1);
3328
3329     col.mask = LVCF_WIDTH;
3330     col.cx   = 50;
3331     r = SendMessage(hwnd, LVM_SETCOLUMN, 0, (LPARAM)&col);
3332     expect(TRUE, r);
3333
3334     col.mask = LVCF_WIDTH;
3335     col.cx   = 100;
3336     r = SendMessage(hwnd, LVM_SETCOLUMN, 1, (LPARAM)&col);
3337     expect(TRUE, r);
3338
3339     rect.left = LVIR_BOUNDS;
3340     rect.right = rect.top = rect.bottom = -1;
3341     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3342     expect(TRUE, r);
3343
3344     /* still no left padding */
3345     expect(0, rect.left);
3346     expect(150, rect.right);
3347
3348     rect.left = LVIR_SELECTBOUNDS;
3349     rect.right = rect.top = rect.bottom = -1;
3350     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3351     expect(TRUE, r);
3352     /* padding */
3353     expect(2, rect.left);
3354
3355     rect.left = LVIR_LABEL;
3356     rect.right = rect.top = rect.bottom = -1;
3357     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3358     expect(TRUE, r);
3359     /* padding, column width */
3360     expect(2, rect.left);
3361     expect(50, rect.right);
3362
3363     /* no icons attached */
3364     rect.left = LVIR_ICON;
3365     rect.right = rect.top = rect.bottom = -1;
3366     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3367     expect(TRUE, r);
3368     /* padding */
3369     expect(2, rect.left);
3370     expect(2, rect.right);
3371
3372     /* change order */
3373     order[0] = 1; order[1] = 0;
3374     r = SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
3375     expect(TRUE, r);
3376     pt.x = -1;
3377     r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
3378     expect(TRUE, r);
3379     /* 1 indexed column width + padding */
3380     expect(102, pt.x);
3381     /* rect is at zero too */
3382     rect.left = LVIR_BOUNDS;
3383     rect.right = rect.top = rect.bottom = -1;
3384     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3385     expect(TRUE, r);
3386     expect(0, rect.left);
3387     /* just width sum */
3388     expect(150, rect.right);
3389
3390     rect.left = LVIR_SELECTBOUNDS;
3391     rect.right = rect.top = rect.bottom = -1;
3392     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3393     expect(TRUE, r);
3394     /* column width + padding */
3395     expect(102, rect.left);
3396
3397     /* back to initial order */
3398     order[0] = 0; order[1] = 1;
3399     r = SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
3400     expect(TRUE, r);
3401
3402     /* state icons */
3403     himl = ImageList_Create(16, 16, 0, 2, 2);
3404     ok(himl != NULL, "failed to create imagelist\n");
3405     hbm = CreateBitmap(16, 16, 1, 1, NULL);
3406     ok(hbm != NULL, "failed to create bitmap\n");
3407     r = ImageList_Add(himl, hbm, 0);
3408     ok(r == 0, "should be zero\n");
3409     hbm = CreateBitmap(16, 16, 1, 1, NULL);
3410     ok(hbm != NULL, "failed to create bitmap\n");
3411     r = ImageList_Add(himl, hbm, 0);
3412     ok(r == 1, "should be one\n");
3413
3414     r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
3415     ok(r == 0, "should return zero\n");
3416
3417     item.mask = LVIF_STATE;
3418     item.state = INDEXTOSTATEIMAGEMASK(1);
3419     item.stateMask = LVIS_STATEIMAGEMASK;
3420     item.iItem = 0;
3421     item.iSubItem = 0;
3422     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
3423     expect(TRUE, r);
3424
3425     /* icon bounds */
3426     rect.left = LVIR_ICON;
3427     rect.right = rect.top = rect.bottom = -1;
3428     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3429     expect(TRUE, r);
3430     /* padding + stateicon width */
3431     expect(18, rect.left);
3432     expect(18, rect.right);
3433     /* label bounds */
3434     rect.left = LVIR_LABEL;
3435     rect.right = rect.top = rect.bottom = -1;
3436     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3437     expect(TRUE, r);
3438     /* padding + stateicon width -> column width */
3439     expect(18, rect.left);
3440     expect(50, rect.right);
3441
3442     r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
3443     ok(r != 0, "should return current list handle\n");
3444
3445     r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
3446     ok(r == 0, "should return zero\n");
3447
3448     item.mask = LVIF_STATE | LVIF_IMAGE;
3449     item.iImage = 1;
3450     item.state = 0;
3451     item.stateMask = ~0;
3452     item.iItem = 0;
3453     item.iSubItem = 0;
3454     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
3455     expect(TRUE, r);
3456
3457     /* icon bounds */
3458     rect.left = LVIR_ICON;
3459     rect.right = rect.top = rect.bottom = -1;
3460     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3461     expect(TRUE, r);
3462     /* padding, icon width */
3463     expect(2, rect.left);
3464     expect(18, rect.right);
3465     /* label bounds */
3466     rect.left = LVIR_LABEL;
3467     rect.right = rect.top = rect.bottom = -1;
3468     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3469     expect(TRUE, r);
3470     /* padding + icon width -> column width */
3471     expect(18, rect.left);
3472     expect(50, rect.right);
3473
3474     /* select bounds */
3475     rect.left = LVIR_SELECTBOUNDS;
3476     rect.right = rect.top = rect.bottom = -1;
3477     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3478     expect(TRUE, r);
3479     /* padding, column width */
3480     expect(2, rect.left);
3481     expect(50, rect.right);
3482
3483     /* try with indentation */
3484     item.mask = LVIF_INDENT;
3485     item.iIndent = 1;
3486     item.iItem = 0;
3487     item.iSubItem = 0;
3488     r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
3489     expect(TRUE, r);
3490
3491     /* bounds */
3492     rect.left = LVIR_BOUNDS;
3493     rect.right = rect.top = rect.bottom = -1;
3494     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3495     expect(TRUE, r);
3496     /* padding + 1 icon width, column width */
3497     expect(0, rect.left);
3498     expect(150, rect.right);
3499
3500     /* select bounds */
3501     rect.left = LVIR_SELECTBOUNDS;
3502     rect.right = rect.top = rect.bottom = -1;
3503     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3504     expect(TRUE, r);
3505     /* padding + 1 icon width, column width */
3506     expect(2 + 16, rect.left);
3507     expect(50, rect.right);
3508
3509     /* label bounds */
3510     rect.left = LVIR_LABEL;
3511     rect.right = rect.top = rect.bottom = -1;
3512     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3513     expect(TRUE, r);
3514     /* padding + 2 icon widths, column width */
3515     expect(2 + 16*2, rect.left);
3516     expect(50, rect.right);
3517
3518     /* icon bounds */
3519     rect.left = LVIR_ICON;
3520     rect.right = rect.top = rect.bottom = -1;
3521     r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3522     expect(TRUE, r);
3523     /* padding + 1 icon width indentation, icon width */
3524     expect(2 + 16, rect.left);
3525     expect(34, rect.right);
3526
3527     DestroyWindow(hwnd);
3528 }
3529
3530 static void test_editbox(void)
3531 {
3532     static CHAR testitemA[]  = "testitem";
3533     static CHAR testitem1A[] = "testitem_quitelongname";
3534     static CHAR buffer[25];
3535     HWND hwnd, hwndedit, hwndedit2, header;
3536     LVITEMA item;
3537     DWORD r;
3538
3539     hwnd = create_listview_control(LVS_EDITLABELS | LVS_REPORT);
3540     ok(hwnd != NULL, "failed to create a listview window\n");
3541
3542     insert_column(hwnd, 0);
3543
3544     memset(&item, 0, sizeof(item));
3545     item.mask = LVIF_TEXT;
3546     item.pszText = testitemA;
3547     item.iItem = 0;
3548     item.iSubItem = 0;
3549     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3550     expect(0, r);
3551
3552     /* test notifications without edit created */
3553     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3554     r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)0xdeadbeef);
3555     expect(0, r);
3556     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3557                 "edit box WM_COMMAND (EN_SETFOCUS), no edit created", FALSE);
3558     /* same thing but with valid window */
3559     hwndedit = CreateWindowA("Edit", "Test edit", WS_VISIBLE | WS_CHILD, 0, 0, 20,
3560                 10, hwnd, (HMENU)1, (HINSTANCE)GetWindowLongPtrA(hwnd, GWLP_HINSTANCE), 0);
3561     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3562     r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)hwndedit);
3563     expect(0, r);
3564     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3565                 "edit box WM_COMMAND (EN_SETFOCUS), no edit created #2", FALSE);
3566     DestroyWindow(hwndedit);
3567
3568     /* setting focus is necessary */
3569     SetFocus(hwnd);
3570     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3571     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3572
3573     /* test children Z-order after Edit box created */
3574     header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
3575     ok(IsWindow(header), "Expected header to be created\n");
3576     ok(GetTopWindow(hwnd) == header, "Expected header to be on top\n");
3577     ok(GetNextWindow(header, GW_HWNDNEXT) == hwndedit, "got %p\n", GetNextWindow(header, GW_HWNDNEXT));
3578
3579     /* modify initial string */
3580     r = SendMessage(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
3581     expect(TRUE, r);
3582
3583     /* edit window is resized and repositioned,
3584        check again for Z-order - it should be preserved */
3585     ok(GetTopWindow(hwnd) == header, "Expected header to be on top\n");
3586     ok(GetNextWindow(header, GW_HWNDNEXT) == hwndedit, "got %p\n", GetNextWindow(header, GW_HWNDNEXT));
3587
3588     /* return focus to listview */
3589     SetFocus(hwnd);
3590
3591     memset(&item, 0, sizeof(item));
3592     item.mask = LVIF_TEXT;
3593     item.pszText = buffer;
3594     item.cchTextMax = sizeof(buffer);
3595     item.iItem = 0;
3596     item.iSubItem = 0;
3597     r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3598     expect(TRUE, r);
3599
3600     ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
3601
3602     /* send LVM_EDITLABEL on already created edit */
3603     SetFocus(hwnd);
3604     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3605     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3606     /* focus will be set to edit */
3607     ok(GetFocus() == hwndedit, "Expected Edit window to be focused\n");
3608     hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3609     ok(IsWindow(hwndedit2), "Expected Edit window to be created\n");
3610
3611     /* creating label disabled when control isn't focused */
3612     SetFocus(0);
3613     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3614     todo_wine ok(hwndedit == NULL, "Expected Edit window not to be created\n");
3615
3616     /* check EN_KILLFOCUS handling */
3617     memset(&item, 0, sizeof(item));
3618     item.pszText = testitemA;
3619     item.iItem = 0;
3620     item.iSubItem = 0;
3621     r = SendMessage(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
3622     expect(TRUE, r);
3623
3624     SetFocus(hwnd);
3625     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3626     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3627     /* modify edit and notify control that it lost focus */
3628     r = SendMessage(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
3629     expect(TRUE, r);
3630     r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
3631     expect(0, r);
3632     memset(&item, 0, sizeof(item));
3633     item.pszText = buffer;
3634     item.cchTextMax = sizeof(buffer);
3635     item.iItem = 0;
3636     item.iSubItem = 0;
3637     r = SendMessage(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
3638     expect(lstrlen(item.pszText), r);
3639     ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
3640     ok(!IsWindow(hwndedit), "Expected Edit window to be freed\n");
3641     /* end edit without saving */
3642     SetFocus(hwnd);
3643     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3644     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3645     r = SendMessage(hwndedit, WM_KEYDOWN, VK_ESCAPE, 0);
3646     expect(0, r);
3647     ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
3648                 "edit box - end edit, no change, escape", TRUE);
3649     /* end edit with saving */
3650     SetFocus(hwnd);
3651     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3652     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3653     r = SendMessage(hwndedit, WM_KEYDOWN, VK_RETURN, 0);
3654     expect(0, r);
3655     ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
3656                 "edit box - end edit, no change, return", TRUE);
3657
3658     memset(&item, 0, sizeof(item));
3659     item.pszText = buffer;
3660     item.cchTextMax = sizeof(buffer);
3661     item.iItem = 0;
3662     item.iSubItem = 0;
3663     r = SendMessage(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
3664     expect(lstrlen(item.pszText), r);
3665     ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
3666
3667     /* LVM_EDITLABEL with -1 destroys current edit */
3668     hwndedit = (HWND)SendMessage(hwnd, LVM_GETEDITCONTROL, 0, 0);
3669     ok(hwndedit == NULL, "Expected Edit window not to be created\n");
3670     /* no edit present */
3671     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, -1, 0);
3672     ok(hwndedit == NULL, "Expected Edit window not to be created\n");
3673     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3674     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3675     /* edit present */
3676     ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
3677     hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, -1, 0);
3678     ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
3679     ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
3680     ok(GetFocus() == hwnd, "Expected List to be focused\n");
3681     /* check another negative value */
3682     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3683     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3684     ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
3685     hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, -2, 0);
3686     ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
3687     ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
3688     ok(GetFocus() == hwnd, "Expected List to be focused\n");
3689     /* and value greater than max item index */
3690     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3691     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3692     ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
3693     r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
3694     hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, r, 0);
3695     ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
3696     ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
3697     ok(GetFocus() == hwnd, "Expected List to be focused\n");
3698
3699     /* messaging tests */
3700     SetFocus(hwnd);
3701     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3702     blockEdit = FALSE;
3703     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3704     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3705     /* testing only sizing messages */
3706     ok_sequence(sequences, EDITBOX_SEQ_INDEX, editbox_create_pos,
3707                 "edit box create - sizing", FALSE);
3708
3709     /* WM_COMMAND with EN_KILLFOCUS isn't forwared to parent */
3710     SetFocus(hwnd);
3711     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3712     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
3713     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3714     r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
3715     expect(0, r);
3716     ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
3717                 "edit box WM_COMMAND (EN_KILLFOCUS)", TRUE);
3718
3719     DestroyWindow(hwnd);
3720 }
3721
3722 static void test_notifyformat(void)
3723 {
3724     HWND hwnd, header;
3725     DWORD r;
3726
3727     hwnd = create_listview_control(LVS_REPORT);
3728     ok(hwnd != NULL, "failed to create a listview window\n");
3729
3730     /* CCM_GETUNICODEFORMAT == LVM_GETUNICODEFORMAT,
3731        CCM_SETUNICODEFORMAT == LVM_SETUNICODEFORMAT */
3732     r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3733     expect(0, r);
3734     r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
3735     /* set */
3736     r = SendMessage(hwnd, LVM_SETUNICODEFORMAT, 1, 0);
3737     expect(0, r);
3738     r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3739     if (r == 1)
3740     {
3741         r = SendMessage(hwnd, LVM_SETUNICODEFORMAT, 0, 0);
3742         expect(1, r);
3743         r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3744         expect(0, r);
3745     }
3746     else
3747     {
3748         win_skip("LVM_GETUNICODEFORMAT is unsupported\n");
3749         DestroyWindow(hwnd);
3750         return;
3751     }
3752
3753     DestroyWindow(hwnd);
3754
3755     /* test failure in parent WM_NOTIFYFORMAT  */
3756     notifyFormat = 0;
3757     hwnd = create_listview_control(LVS_REPORT);
3758     ok(hwnd != NULL, "failed to create a listview window\n");
3759     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3760     ok(IsWindow(header), "expected header to be created\n");
3761     r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3762     expect(0, r);
3763     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3764     ok( r == 1 || broken(r == 0), /* win9x */ "Expected 1, got %d\n", r );
3765     r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
3766     ok(r != 0, "Expected valid format\n");
3767
3768     notifyFormat = NFR_UNICODE;
3769     r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
3770     expect(NFR_UNICODE, r);
3771     r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3772     expect(1, r);
3773     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3774     ok( r == 1 || broken(r == 0), /* win9x */ "Expected 1, got %d\n", r );
3775
3776     notifyFormat = NFR_ANSI;
3777     r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
3778     expect(NFR_ANSI, r);
3779     r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3780     expect(0, r);
3781     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3782     ok( r == 1 || broken(r == 0), /* win9x */ "Expected 1, got %d\n", r );
3783
3784     DestroyWindow(hwnd);
3785
3786     /* try different unicode window combination and defaults */
3787     if (!GetModuleHandleW(NULL))
3788     {
3789         win_skip("Additional notify format tests are incompatible with Win9x\n");
3790         return;
3791     }
3792
3793     hwndparentW = create_parent_window(TRUE);
3794     ok(IsWindow(hwndparentW), "Unicode parent creation failed\n");
3795     if (!IsWindow(hwndparentW))  return;
3796
3797     notifyFormat = -1;
3798     hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
3799     ok(hwnd != NULL, "failed to create a listview window\n");
3800     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3801     ok(IsWindow(header), "expected header to be created\n");
3802     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3803     expect(1, r);
3804     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3805     expect(1, r);
3806     DestroyWindow(hwnd);
3807     /* receiving error code defaulting to ansi */
3808     notifyFormat = 0;
3809     hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
3810     ok(hwnd != NULL, "failed to create a listview window\n");
3811     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3812     ok(IsWindow(header), "expected header to be created\n");
3813     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3814     expect(0, r);
3815     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3816     expect(1, r);
3817     DestroyWindow(hwnd);
3818     /* receiving ansi code from unicode window, use it */
3819     notifyFormat = NFR_ANSI;
3820     hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
3821     ok(hwnd != NULL, "failed to create a listview window\n");
3822     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3823     ok(IsWindow(header), "expected header to be created\n");
3824     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3825     expect(0, r);
3826     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3827     expect(1, r);
3828     DestroyWindow(hwnd);
3829     /* unicode listview with ansi parent window */
3830     notifyFormat = -1;
3831     hwnd = create_listview_controlW(LVS_REPORT, hwndparent);
3832     ok(hwnd != NULL, "failed to create a listview window\n");
3833     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3834     ok(IsWindow(header), "expected header to be created\n");
3835     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3836     expect(0, r);
3837     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3838     expect(1, r);
3839     DestroyWindow(hwnd);
3840     /* unicode listview with ansi parent window, return error code */
3841     notifyFormat = 0;
3842     hwnd = create_listview_controlW(LVS_REPORT, hwndparent);
3843     ok(hwnd != NULL, "failed to create a listview window\n");
3844     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
3845     ok(IsWindow(header), "expected header to be created\n");
3846     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
3847     expect(0, r);
3848     r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
3849     expect(1, r);
3850     DestroyWindow(hwnd);
3851
3852     DestroyWindow(hwndparentW);
3853 }
3854
3855 static void test_indentation(void)
3856 {
3857     HWND hwnd;
3858     LVITEMA item;
3859     DWORD r;
3860
3861     hwnd = create_listview_control(LVS_REPORT);
3862     ok(hwnd != NULL, "failed to create a listview window\n");
3863
3864     memset(&item, 0, sizeof(item));
3865     item.mask = LVIF_INDENT;
3866     item.iItem = 0;
3867     item.iIndent = I_INDENTCALLBACK;
3868     r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3869     expect(0, r);
3870
3871     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3872
3873     item.iItem = 0;
3874     item.mask = LVIF_INDENT;
3875     r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
3876     expect(TRUE, r);
3877
3878     ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
3879                 "get indent dispinfo", FALSE);
3880
3881     DestroyWindow(hwnd);
3882 }
3883
3884 static INT CALLBACK DummyCompareEx(LPARAM first, LPARAM second, LPARAM param)
3885 {
3886     return 0;
3887 }
3888
3889 static BOOL is_below_comctl_5(void)
3890 {
3891     HWND hwnd;
3892     BOOL ret;
3893
3894     hwnd = create_listview_control(LVS_REPORT);
3895     ok(hwnd != NULL, "failed to create a listview window\n");
3896     insert_item(hwnd, 0);
3897
3898     ret = SendMessage(hwnd, LVM_SORTITEMSEX, 0, (LPARAM)&DummyCompareEx);
3899
3900     DestroyWindow(hwnd);
3901
3902     return !ret;
3903 }
3904
3905 static void test_get_set_view(void)
3906 {
3907     HWND hwnd;
3908     DWORD ret;
3909     DWORD_PTR style;
3910
3911     /* test style->view mapping */
3912     hwnd = create_listview_control(LVS_REPORT);
3913     ok(hwnd != NULL, "failed to create a listview window\n");
3914
3915     ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
3916     expect(LV_VIEW_DETAILS, ret);
3917
3918     style = GetWindowLongPtr(hwnd, GWL_STYLE);
3919     /* LVS_ICON == 0 */
3920     SetWindowLongPtr(hwnd, GWL_STYLE, style & ~LVS_REPORT);
3921     ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
3922     expect(LV_VIEW_ICON, ret);
3923
3924     style = GetWindowLongPtr(hwnd, GWL_STYLE);
3925     SetWindowLongPtr(hwnd, GWL_STYLE, style | LVS_SMALLICON);
3926     ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
3927     expect(LV_VIEW_SMALLICON, ret);
3928
3929     style = GetWindowLongPtr(hwnd, GWL_STYLE);
3930     SetWindowLongPtr(hwnd, GWL_STYLE, (style & ~LVS_SMALLICON) | LVS_LIST);
3931     ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
3932     expect(LV_VIEW_LIST, ret);
3933
3934     /* switching view doesn't touch window style */
3935     ret = SendMessage(hwnd, LVM_SETVIEW, LV_VIEW_DETAILS, 0);
3936     expect(1, ret);
3937     style = GetWindowLongPtr(hwnd, GWL_STYLE);
3938     ok(style & LVS_LIST, "Expected style to be preserved\n");
3939     ret = SendMessage(hwnd, LVM_SETVIEW, LV_VIEW_ICON, 0);
3940     expect(1, ret);
3941     style = GetWindowLongPtr(hwnd, GWL_STYLE);
3942     ok(style & LVS_LIST, "Expected style to be preserved\n");
3943     ret = SendMessage(hwnd, LVM_SETVIEW, LV_VIEW_SMALLICON, 0);
3944     expect(1, ret);
3945     style = GetWindowLongPtr(hwnd, GWL_STYLE);
3946     ok(style & LVS_LIST, "Expected style to be preserved\n");
3947
3948     DestroyWindow(hwnd);
3949 }
3950
3951 static void test_canceleditlabel(void)
3952 {
3953     HWND hwnd, hwndedit;
3954     DWORD ret;
3955     CHAR buff[10];
3956     LVITEMA itema;
3957     static CHAR test[] = "test";
3958     static const CHAR test1[] = "test1";
3959
3960     hwnd = create_listview_control(LVS_EDITLABELS | LVS_REPORT);
3961     ok(hwnd != NULL, "failed to create a listview window\n");
3962
3963     insert_item(hwnd, 0);
3964
3965     /* try without edit created */
3966     flush_sequences(sequences, NUM_MSG_SEQUENCES);
3967     ret = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0);
3968     expect(TRUE, ret);
3969     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3970                 "cancel edit label without edit", FALSE);
3971
3972     /* cancel without data change */
3973     SetFocus(hwnd);
3974     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3975     ok(IsWindow(hwndedit), "Expected edit control to be created\n");
3976     ret = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0);
3977     expect(TRUE, ret);
3978     ok(!IsWindow(hwndedit), "Expected edit control to be destroyed\n");
3979
3980     /* cancel after data change */
3981     memset(&itema, 0, sizeof(itema));
3982     itema.pszText = test;
3983     ret = SendMessage(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&itema);
3984     expect(TRUE, ret);
3985     SetFocus(hwnd);
3986     hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
3987     ok(IsWindow(hwndedit), "Expected edit control to be created\n");
3988     ret = SetWindowText(hwndedit, test1);
3989     ok(ret != 0, "Expected edit text to change\n");
3990     ret = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0);
3991     expect(TRUE, ret);
3992     ok(!IsWindow(hwndedit), "Expected edit control to be destroyed\n");
3993     memset(&itema, 0, sizeof(itema));
3994     itema.pszText = buff;
3995     itema.cchTextMax = sizeof(buff)/sizeof(CHAR);
3996     ret = SendMessage(hwnd, LVM_GETITEMTEXT, 0, (LPARAM)&itema);
3997     expect(5, ret);
3998     ok(strcmp(buff, test1) == 0, "Expected label text not to change\n");
3999
4000     DestroyWindow(hwnd);
4001 }
4002
4003 static void test_mapidindex(void)
4004 {
4005     HWND hwnd;
4006     DWORD ret;
4007
4008     /* LVM_MAPINDEXTOID unsupported with LVS_OWNERDATA */
4009     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
4010     ok(hwnd != NULL, "failed to create a listview window\n");
4011     insert_item(hwnd, 0);
4012     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
4013     expect(-1, ret);
4014     DestroyWindow(hwnd);
4015
4016     hwnd = create_listview_control(LVS_REPORT);
4017     ok(hwnd != NULL, "failed to create a listview window\n");
4018
4019     /* LVM_MAPINDEXTOID with invalid index */
4020     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
4021     expect(-1, ret);
4022
4023     insert_item(hwnd, 0);
4024     insert_item(hwnd, 1);
4025
4026     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, -1, 0);
4027     expect(-1, ret);
4028     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 2, 0);
4029     expect(-1, ret);
4030
4031     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
4032     expect(0, ret);
4033     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 1, 0);
4034     expect(1, ret);
4035     /* remove 0 indexed item, id retained */
4036     SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
4037     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
4038     expect(1, ret);
4039     /* new id starts from previous value */
4040     insert_item(hwnd, 1);
4041     ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 1, 0);
4042     expect(2, ret);
4043
4044     /* get index by id */
4045     ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, -1, 0);
4046     expect(-1, ret);
4047     ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, 0, 0);
4048     expect(-1, ret);
4049     ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, 1, 0);
4050     expect(0, ret);
4051     ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, 2, 0);
4052     expect(1, ret);
4053
4054     DestroyWindow(hwnd);
4055 }
4056
4057 static void test_getitemspacing(void)
4058 {
4059     HWND hwnd;
4060     DWORD ret;
4061     INT cx, cy;
4062     HIMAGELIST himl;
4063     HBITMAP hbmp;
4064     LVITEMA itema;
4065
4066     cx = GetSystemMetrics(SM_CXICONSPACING) - GetSystemMetrics(SM_CXICON);
4067     cy = GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
4068
4069     /* LVS_ICON */
4070     hwnd = create_listview_control(LVS_ICON);
4071     ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4072 todo_wine {
4073     expect(cx, LOWORD(ret));
4074     expect(cy, HIWORD(ret));
4075 }
4076     /* now try with icons */
4077     himl = ImageList_Create(40, 40, 0, 4, 4);
4078     ok(himl != NULL, "failed to create imagelist\n");
4079     hbmp = CreateBitmap(40, 40, 1, 1, NULL);
4080     ok(hbmp != NULL, "failed to create bitmap\n");
4081     ret = ImageList_Add(himl, hbmp, 0);
4082     expect(0, ret);
4083     ret = SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
4084     expect(0, ret);
4085
4086     itema.mask = LVIF_IMAGE;
4087     itema.iImage = 0;
4088     itema.iItem = 0;
4089     itema.iSubItem = 0;
4090     ret = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM)&itema);
4091     expect(0, ret);
4092     ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4093 todo_wine {
4094     /* spacing + icon size returned */
4095     expect(cx + 40, LOWORD(ret));
4096     expect(cy + 40, HIWORD(ret));
4097 }
4098     DestroyWindow(hwnd);
4099     /* LVS_SMALLICON */
4100     hwnd = create_listview_control(LVS_SMALLICON);
4101     ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4102 todo_wine {
4103     expect(cx, LOWORD(ret));
4104     expect(cy, HIWORD(ret));
4105 }
4106     DestroyWindow(hwnd);
4107     /* LVS_REPORT */
4108     hwnd = create_listview_control(LVS_REPORT);
4109     ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4110 todo_wine {
4111     expect(cx, LOWORD(ret));
4112     expect(cy, HIWORD(ret));
4113 }
4114     DestroyWindow(hwnd);
4115     /* LVS_LIST */
4116     hwnd = create_listview_control(LVS_LIST);
4117     ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4118 todo_wine {
4119     expect(cx, LOWORD(ret));
4120     expect(cy, HIWORD(ret));
4121 }
4122     DestroyWindow(hwnd);
4123 }
4124
4125 static void test_getcolumnwidth(void)
4126 {
4127     HWND hwnd;
4128     DWORD ret;
4129     DWORD_PTR style;
4130     LVCOLUMNA col;
4131     LVITEMA itema;
4132     HDC hdc;
4133
4134     /* default column width */
4135     hwnd = create_listview_control(LVS_ICON);
4136     ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4137     expect(0, ret);
4138     style = GetWindowLong(hwnd, GWL_STYLE);
4139     SetWindowLong(hwnd, GWL_STYLE, style | LVS_LIST);
4140     ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4141     todo_wine expect(8, ret);
4142     style = GetWindowLong(hwnd, GWL_STYLE) & ~LVS_LIST;
4143     SetWindowLong(hwnd, GWL_STYLE, style | LVS_REPORT);
4144     col.mask = 0;
4145     ret = SendMessage(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
4146     expect(0, ret);
4147     ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4148     expect(10, ret);
4149     DestroyWindow(hwnd);
4150
4151     /* default column width with item added */
4152     hwnd = create_listview_control(LVS_LIST);
4153     memset(&itema, 0, sizeof(itema));
4154     SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
4155     ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4156     hdc = GetDC(hwnd);
4157     todo_wine expect(GetDeviceCaps(hdc, LOGPIXELSX), ret);
4158     ReleaseDC(hwnd, hdc);
4159     DestroyWindow(hwnd);
4160 }
4161
4162 static void test_scrollnotify(void)
4163 {
4164     HWND hwnd;
4165     DWORD ret;
4166
4167     hwnd = create_listview_control(LVS_REPORT);
4168
4169     insert_column(hwnd, 0);
4170     insert_column(hwnd, 1);
4171     insert_item(hwnd, 0);
4172
4173     /* make it scrollable - resize */
4174     ret = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
4175     expect(TRUE, ret);
4176     ret = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
4177     expect(TRUE, ret);
4178
4179     /* try with dummy call */
4180     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4181     ret = SendMessage(hwnd, LVM_SCROLL, 0, 0);
4182     expect(TRUE, ret);
4183     ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
4184                 "scroll notify 1", TRUE);
4185
4186     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4187     ret = SendMessage(hwnd, LVM_SCROLL, 1, 0);
4188     expect(TRUE, ret);
4189     ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
4190                 "scroll notify 2", TRUE);
4191
4192     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4193     ret = SendMessage(hwnd, LVM_SCROLL, 1, 1);
4194     expect(TRUE, ret);
4195     ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
4196                 "scroll notify 3", TRUE);
4197
4198     DestroyWindow(hwnd);
4199 }
4200
4201 static void test_LVS_EX_TRANSPARENTBKGND(void)
4202 {
4203     HWND hwnd;
4204     DWORD ret;
4205     HDC hdc;
4206
4207     hwnd = create_listview_control(LVS_REPORT);
4208
4209     ret = SendMessage(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
4210     expect(TRUE, ret);
4211
4212     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
4213                                                     LVS_EX_TRANSPARENTBKGND);
4214
4215     ret = SendMessage(hwnd, LVM_GETBKCOLOR, 0, 0);
4216     if (ret != CLR_NONE)
4217     {
4218         win_skip("LVS_EX_TRANSPARENTBKGND unsupported\n");
4219         DestroyWindow(hwnd);
4220         return;
4221     }
4222
4223     /* try to set some back color and check this style bit */
4224     ret = SendMessage(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
4225     expect(TRUE, ret);
4226     ret = SendMessage(hwnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
4227     ok(!(ret & LVS_EX_TRANSPARENTBKGND), "Expected LVS_EX_TRANSPARENTBKGND to unset\n");
4228
4229     /* now test what this style actually does */
4230     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
4231                                                     LVS_EX_TRANSPARENTBKGND);
4232
4233     hdc = GetWindowDC(hwndparent);
4234
4235     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4236     SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
4237     ok_sequence(sequences, PARENT_SEQ_INDEX, lvs_ex_transparentbkgnd_seq,
4238                 "LVS_EX_TRANSPARENTBKGND parent", FALSE);
4239
4240     ReleaseDC(hwndparent, hdc);
4241
4242     DestroyWindow(hwnd);
4243 }
4244
4245 static void test_approximate_viewrect(void)
4246 {
4247     HWND hwnd;
4248     DWORD ret;
4249     HIMAGELIST himl;
4250     HBITMAP hbmp;
4251     LVITEMA itema;
4252     static CHAR test[] = "abracadabra, a very long item label";
4253
4254     hwnd = create_listview_control(LVS_ICON);
4255     himl = ImageList_Create(40, 40, 0, 4, 4);
4256     ok(himl != NULL, "failed to create imagelist\n");
4257     hbmp = CreateBitmap(40, 40, 1, 1, NULL);
4258     ok(hbmp != NULL, "failed to create bitmap\n");
4259     ret = ImageList_Add(himl, hbmp, 0);
4260     expect(0, ret);
4261     ret = SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
4262     expect(0, ret);
4263
4264     itema.mask = LVIF_IMAGE;
4265     itema.iImage = 0;
4266     itema.iItem = 0;
4267     itema.iSubItem = 0;
4268     ret = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM)&itema);
4269     expect(0, ret);
4270
4271     ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(75, 75));
4272     if (ret == 0)
4273     {
4274         /* version 4.0 */
4275         win_skip("LVM_SETICONSPACING unimplemented. Skipping.\n");
4276         return;
4277     }
4278
4279     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
4280     ok(MAKELONG(77,827)==ret,"Incorrect Approximate rect\n");
4281
4282     ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(50, 50));
4283     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
4284     ok(MAKELONG(102,302)==ret,"Incorrect Approximate rect\n");
4285
4286     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
4287     ok(MAKELONG(52,52)==ret,"Incorrect Approximate rect\n");
4288
4289     itema.pszText = test;
4290     ret = SendMessage(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&itema);
4291     expect(TRUE, ret);
4292     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
4293     ok(MAKELONG(52,52)==ret,"Incorrect Approximate rect\n");
4294
4295     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 0, MAKELPARAM(100,100));
4296     ok(MAKELONG(52,2)==ret,"Incorrect Approximate rect\n");
4297     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 1, MAKELPARAM(100,100));
4298     ok(MAKELONG(52,52)==ret,"Incorrect Approximate rect\n");
4299     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 2, MAKELPARAM(100,100));
4300     ok(MAKELONG(102,52)==ret,"Incorrect Approximate rect\n");
4301     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 3, MAKELPARAM(100,100));
4302     ok(MAKELONG(102,102)==ret,"Incorrect Approximate rect\n");
4303     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 4, MAKELPARAM(100,100));
4304     ok(MAKELONG(102,102)==ret,"Incorrect Approximate rect\n");
4305     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 5, MAKELPARAM(100,100));
4306     ok(MAKELONG(102,152)==ret,"Incorrect Approximate rect\n");
4307     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 6, MAKELPARAM(100,100));
4308     ok(MAKELONG(102,152)==ret,"Incorrect Approximate rect\n");
4309     ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 7, MAKELPARAM(160,100));
4310     ok(MAKELONG(152,152)==ret,"Incorrect Approximate rect\n");
4311
4312     DestroyWindow(hwnd);
4313 }
4314
4315 static void test_finditem(void)
4316 {
4317     LVFINDINFOA fi;
4318     static char f[5];
4319     HWND hwnd;
4320     DWORD r;
4321
4322     hwnd = create_listview_control(LVS_REPORT);
4323     insert_item(hwnd, 0);
4324
4325     memset(&fi, 0, sizeof(fi));
4326
4327     /* full string search, inserted text was "foo" */
4328     strcpy(f, "foo");
4329     fi.flags = LVFI_STRING;
4330     fi.psz = f;
4331     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4332     expect(0, r);
4333     /* partial string search, inserted text was "foo" */
4334     strcpy(f, "fo");
4335     fi.flags = LVFI_STRING | LVFI_PARTIAL;
4336     fi.psz = f;
4337     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4338     expect(0, r);
4339     /* partial string search, part after start char */
4340     strcpy(f, "oo");
4341     fi.flags = LVFI_STRING | LVFI_PARTIAL;
4342     fi.psz = f;
4343     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4344     expect(-1, r);
4345
4346     /* try with LVFI_SUBSTRING */
4347     strcpy(f, "fo");
4348     fi.flags = LVFI_SUBSTRING;
4349     fi.psz = f;
4350     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4351     if (r == -1)
4352     {
4353         win_skip("LVFI_SUBSTRING not supported\n");
4354         DestroyWindow(hwnd);
4355         return;
4356     }
4357     expect(0, r);
4358     strcpy(f, "f");
4359     fi.flags = LVFI_SUBSTRING;
4360     fi.psz = f;
4361     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4362     expect(0, r);
4363     strcpy(f, "o");
4364     fi.flags = LVFI_SUBSTRING;
4365     fi.psz = f;
4366     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4367     expect(-1, r);
4368
4369     strcpy(f, "f");
4370     fi.flags = LVFI_SUBSTRING | LVFI_STRING;
4371     fi.psz = f;
4372     r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
4373     expect(0, r);
4374
4375     DestroyWindow(hwnd);
4376 }
4377
4378 static void test_LVS_EX_HEADERINALLVIEWS(void)
4379 {
4380     HWND hwnd, header;
4381     DWORD style;
4382
4383     hwnd = create_listview_control(LVS_ICON);
4384
4385     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
4386                                                     LVS_EX_HEADERINALLVIEWS);
4387
4388     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
4389     if (!IsWindow(header))
4390     {
4391         win_skip("LVS_EX_HEADERINALLVIEWS unsupported\n");
4392         DestroyWindow(hwnd);
4393         return;
4394     }
4395
4396     /* LVS_NOCOLUMNHEADER works as before */
4397     style = GetWindowLongA(hwnd, GWL_STYLE);
4398     SetWindowLongW(hwnd, GWL_STYLE, style | LVS_NOCOLUMNHEADER);
4399     style = GetWindowLongA(header, GWL_STYLE);
4400     ok(style & HDS_HIDDEN, "Expected HDS_HIDDEN\n");
4401     style = GetWindowLongA(hwnd, GWL_STYLE);
4402     SetWindowLongW(hwnd, GWL_STYLE, style & ~LVS_NOCOLUMNHEADER);
4403     style = GetWindowLongA(header, GWL_STYLE);
4404     ok(!(style & HDS_HIDDEN), "Expected HDS_HIDDEN to be unset\n");
4405
4406     /* try to remove style */
4407     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS, 0);
4408     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
4409     ok(IsWindow(header), "Expected header to be created\n");
4410     style = GetWindowLongA(header, GWL_STYLE);
4411     ok(!(style & HDS_HIDDEN), "HDS_HIDDEN not expected\n");
4412
4413     DestroyWindow(hwnd);
4414
4415     /* check other styles */
4416     hwnd = create_listview_control(LVS_LIST);
4417     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
4418                                                     LVS_EX_HEADERINALLVIEWS);
4419     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
4420     ok(IsWindow(header), "Expected header to be created\n");
4421     DestroyWindow(hwnd);
4422
4423     hwnd = create_listview_control(LVS_SMALLICON);
4424     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
4425                                                     LVS_EX_HEADERINALLVIEWS);
4426     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
4427     ok(IsWindow(header), "Expected header to be created\n");
4428     DestroyWindow(hwnd);
4429
4430     hwnd = create_listview_control(LVS_REPORT);
4431     SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
4432                                                     LVS_EX_HEADERINALLVIEWS);
4433     header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
4434     ok(IsWindow(header), "Expected header to be created\n");
4435     DestroyWindow(hwnd);
4436 }
4437
4438 static void test_hover(void)
4439 {
4440     HWND hwnd;
4441     DWORD r;
4442
4443     hwnd = create_listview_control(LVS_ICON);
4444
4445     /* test WM_MOUSEHOVER forwarding */
4446     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4447     r = SendMessage(hwnd, WM_MOUSEHOVER, 0, 0);
4448     expect(0, r);
4449     ok_sequence(sequences, PARENT_SEQ_INDEX, hover_parent, "NM_HOVER allow test", TRUE);
4450     g_block_hover = TRUE;
4451     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4452     r = SendMessage(hwnd, WM_MOUSEHOVER, 0, 0);
4453     expect(0, r);
4454     ok_sequence(sequences, PARENT_SEQ_INDEX, hover_parent, "NM_HOVER block test", TRUE);
4455     g_block_hover = FALSE;
4456
4457     r = SendMessage(hwnd, LVM_SETHOVERTIME, 0, 500);
4458     expect(HOVER_DEFAULT, r);
4459     r = SendMessage(hwnd, LVM_GETHOVERTIME, 0, 0);
4460     expect(500, r);
4461
4462     DestroyWindow(hwnd);
4463 }
4464
4465 static void test_destroynotify(void)
4466 {
4467     HWND hwnd;
4468
4469     hwnd = create_listview_control(LVS_REPORT);
4470     ok(hwnd != NULL, "failed to create listview window\n");
4471
4472     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4473     DestroyWindow(hwnd);
4474     ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_destroy, "check destroy order", FALSE);
4475 }
4476
4477 static void test_header_notification(void)
4478 {
4479     HWND list, header;
4480     HDITEMA item;
4481     NMHEADER nmh;
4482     LVCOLUMNA col;
4483     LRESULT ret;
4484
4485     list = create_listview_control(LVS_REPORT);
4486     ok(list != 0, "failed to create listview window\n");
4487
4488     memset(&col, 0, sizeof(col));
4489     col.mask = LVCF_WIDTH;
4490     col.cx = 100;
4491     ret = SendMessage(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
4492     ok(!ret, "expected 0, got %ld\n", ret);
4493
4494     header = subclass_header(list);
4495
4496     ret = SendMessage(header, HDM_GETITEMCOUNT, 0, 0);
4497     ok(ret == 1, "expected header item count 1, got %ld\n", ret);
4498
4499     memset(&item, 0, sizeof(item));
4500     item.mask = HDI_WIDTH;
4501     ret = SendMessage(header, HDM_GETITEMA, 0, (LPARAM)&item);
4502     ok(ret, "HDM_GETITEM failed\n");
4503     ok(item.cxy == 100, "expected 100, got %d\n", item.cxy);
4504
4505     nmh.hdr.hwndFrom = header;
4506     nmh.hdr.idFrom = GetWindowLongPtr(header, GWLP_ID);
4507     nmh.hdr.code = HDN_ITEMCHANGEDA;
4508     nmh.iItem = 0;
4509     nmh.iButton = 0;
4510     item.mask = HDI_WIDTH;
4511     item.cxy = 50;
4512     nmh.pitem = &item;
4513     ret = SendMessage(list, WM_NOTIFY, 0, (LPARAM)&nmh);
4514     ok(!ret, "WM_NOTIFY/HDN_ITEMCHANGED failed\n");
4515
4516     DestroyWindow(list);
4517 }
4518
4519 static void test_createdragimage(void)
4520 {
4521     HIMAGELIST himl;
4522     POINT pt;
4523     HWND list;
4524
4525     list = create_listview_control(LVS_ICON);
4526     ok(list != 0, "failed to create listview window\n");
4527
4528     insert_item(list, 0);
4529
4530     /* NULL point */
4531     himl = (HIMAGELIST)SendMessageA(list, LVM_CREATEDRAGIMAGE, 0, 0);
4532     ok(himl == NULL, "got %p\n", himl);
4533
4534     himl = (HIMAGELIST)SendMessageA(list, LVM_CREATEDRAGIMAGE, 0, (LPARAM)&pt);
4535     ok(himl != NULL, "got %p\n", himl);
4536     ImageList_Destroy(himl);
4537
4538     DestroyWindow(list);
4539 }
4540
4541 START_TEST(listview)
4542 {
4543     HMODULE hComctl32;
4544     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
4545
4546     ULONG_PTR ctx_cookie;
4547     HANDLE hCtx;
4548     HWND hwnd;
4549
4550     hComctl32 = GetModuleHandleA("comctl32.dll");
4551     pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
4552     if (pInitCommonControlsEx)
4553     {
4554         INITCOMMONCONTROLSEX iccex;
4555         iccex.dwSize = sizeof(iccex);
4556         iccex.dwICC  = ICC_LISTVIEW_CLASSES;
4557         pInitCommonControlsEx(&iccex);
4558     }
4559     else
4560         InitCommonControls();
4561
4562     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
4563
4564     hwndparent = create_parent_window(FALSE);
4565     flush_sequences(sequences, NUM_MSG_SEQUENCES);
4566
4567     g_is_below_5 = is_below_comctl_5();
4568
4569     test_header_notification();
4570     test_images();
4571     test_checkboxes();
4572     test_items();
4573     test_create();
4574     test_redraw();
4575     test_customdraw();
4576     test_icon_spacing();
4577     test_color();
4578     test_item_count();
4579     test_item_position();
4580     test_columns();
4581     test_getorigin();
4582     test_multiselect();
4583     test_getitemrect();
4584     test_subitem_rect();
4585     test_sorting();
4586     test_ownerdata();
4587     test_norecompute();
4588     test_nosortheader();
4589     test_setredraw();
4590     test_hittest();
4591     test_getviewrect();
4592     test_getitemposition();
4593     test_columnscreation();
4594     test_editbox();
4595     test_notifyformat();
4596     test_indentation();
4597     test_getitemspacing();
4598     test_getcolumnwidth();
4599     test_approximate_viewrect();
4600     test_finditem();
4601     test_hover();
4602     test_destroynotify();
4603     test_createdragimage();
4604
4605     if (!load_v6_module(&ctx_cookie, &hCtx))
4606     {
4607         DestroyWindow(hwndparent);
4608         return;
4609     }
4610
4611     /* this is a XP SP3 failure workaround */
4612     hwnd = CreateWindowExA(0, WC_LISTVIEW, "foo",
4613                            WS_CHILD | WS_BORDER | WS_VISIBLE | LVS_REPORT,
4614                            0, 0, 100, 100,
4615                            hwndparent, NULL, GetModuleHandleA(NULL), NULL);
4616     if (!IsWindow(hwnd))
4617     {
4618         win_skip("FIXME: failed to create ListView window.\n");
4619         unload_v6_module(ctx_cookie, hCtx);
4620         DestroyWindow(hwndparent);
4621         return;
4622     }
4623     else
4624         DestroyWindow(hwnd);
4625
4626     /* comctl32 version 6 tests start here */
4627     test_get_set_view();
4628     test_canceleditlabel();
4629     test_mapidindex();
4630     test_scrollnotify();
4631     test_LVS_EX_TRANSPARENTBKGND();
4632     test_LVS_EX_HEADERINALLVIEWS();
4633
4634     unload_v6_module(ctx_cookie, hCtx);
4635
4636     DestroyWindow(hwndparent);
4637 }