projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[COMCTL32_WINETEST] Sync with Wine Staging 4.0. CORE-15682
[reactos.git] / modules / rostests / winetests / comctl32 / listview.c
1 /*
2 * ListView tests
3 *
4 * Copyright 2006 Mike McCormack for CodeWeavers
5 * Copyright 2007 George Gov
6 * Copyright 2009-2014 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 static HIMAGELIST (WINAPI *pImageList_Create)(int, int, UINT, int, int);
32 static BOOL (WINAPI *pImageList_Destroy)(HIMAGELIST);
33 static int (WINAPI *pImageList_Add)(HIMAGELIST, HBITMAP, HBITMAP);
34 static BOOL (WINAPI *p_TrackMouseEvent)(TRACKMOUSEEVENT *);
35
36 enum seq_index {
37 PARENT_SEQ_INDEX,
38 PARENT_FULL_SEQ_INDEX,
39 PARENT_CD_SEQ_INDEX,
40 LISTVIEW_SEQ_INDEX,
41 EDITBOX_SEQ_INDEX,
42 COMBINED_SEQ_INDEX,
43 NUM_MSG_SEQUENCES
44 };
45
46 #define LISTVIEW_ID 0
47 #define HEADER_ID 1
48
49 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
50 #define expect2(expected1, expected2, got1, got2) ok(expected1 == got1 && expected2 == got2, \
51 "expected (%d,%d), got (%d,%d)\n", expected1, expected2, got1, got2)
52
53 static const WCHAR testparentclassW[] =
54 {'L','i','s','t','v','i','e','w',' ','t','e','s','t',' ','p','a','r','e','n','t','W', 0};
55
56 static HWND hwndparent, hwndparentW;
57 /* prevents edit box creation, LVN_BEGINLABELEDIT return value */
58 static BOOL blockEdit;
59 /* return nonzero on NM_HOVER */
60 static BOOL g_block_hover;
61 /* notification data for LVN_ITEMCHANGED */
62 static NMLISTVIEW g_nmlistview;
63 /* notification data for LVN_ITEMCHANGING */
64 static NMLISTVIEW g_nmlistview_changing;
65 /* format reported to control:
66 -1 falls to defproc, anything else returned */
67 static INT notifyFormat;
68 /* indicates we're running < 5.80 version */
69 static BOOL g_is_below_5;
70 /* item data passed to LVN_GETDISPINFOA */
71 static LVITEMA g_itema;
72 /* alter notification code A->W */
73 static BOOL g_disp_A_to_W;
74 /* dispinfo data sent with LVN_LVN_ENDLABELEDIT */
75 static NMLVDISPINFOA g_editbox_disp_info;
76 /* when this is set focus will be tested on LVN_DELETEITEM */
77 static BOOL g_focus_test_LVN_DELETEITEM;
78 /* Whether to send WM_KILLFOCUS to the edit control during LVN_ENDLABELEDIT */
79 static BOOL g_WM_KILLFOCUS_on_LVN_ENDLABELEDIT;
80
81 static HWND subclass_editbox(HWND hwndListview);
82
83 static void init_functions(void)
84 {
85 HMODULE hComCtl32 = LoadLibraryA("comctl32.dll");
86
87 #define X(f) p##f = (void*)GetProcAddress(hComCtl32, #f);
88 X(ImageList_Create);
89 X(ImageList_Destroy);
90 X(ImageList_Add);
91 X(_TrackMouseEvent);
92 #undef X
93 }
94
95 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
96
97 static const struct message create_ownerdrawfixed_parent_seq[] = {
98 { WM_NOTIFYFORMAT, sent },
99 { WM_QUERYUISTATE, sent|optional }, /* Win2K and higher */
100 { WM_MEASUREITEM, sent },
101 { WM_PARENTNOTIFY, sent },
102 { 0 }
103 };
104
105 static const struct message redraw_listview_seq[] = {
106 { WM_PAINT, sent|id, 0, 0, LISTVIEW_ID },
107 { WM_PAINT, sent|id, 0, 0, HEADER_ID },
108 { WM_NCPAINT, sent|id|defwinproc, 0, 0, HEADER_ID },
109 { WM_ERASEBKGND, sent|id|defwinproc|optional, 0, 0, HEADER_ID },
110 { WM_NOTIFY, sent|id|defwinproc, 0, 0, LISTVIEW_ID },
111 { WM_NCPAINT, sent|id|defwinproc, 0, 0, LISTVIEW_ID },
112 { WM_ERASEBKGND, sent|id|defwinproc|optional, 0, 0, LISTVIEW_ID },
113 { 0 }
114 };
115
116 static const struct message listview_icon_spacing_seq[] = {
117 { LVM_SETICONSPACING, sent|lparam, 0, MAKELPARAM(20, 30) },
118 { LVM_SETICONSPACING, sent|lparam, 0, MAKELPARAM(25, 35) },
119 { LVM_SETICONSPACING, sent|lparam, 0, MAKELPARAM(-1, -1) },
120 { 0 }
121 };
122
123 static const struct message listview_color_seq[] = {
124 { LVM_SETBKCOLOR, sent|lparam, 0, RGB(0,0,0) },
125 { LVM_GETBKCOLOR, sent },
126 { LVM_SETTEXTCOLOR, sent|lparam, 0, RGB(0,0,0) },
127 { LVM_GETTEXTCOLOR, sent },
128 { LVM_SETTEXTBKCOLOR, sent|lparam, 0, RGB(0,0,0) },
129 { LVM_GETTEXTBKCOLOR, sent },
130
131 { LVM_SETBKCOLOR, sent|lparam, 0, RGB(100,50,200) },
132 { LVM_GETBKCOLOR, sent },
133 { LVM_SETTEXTCOLOR, sent|lparam, 0, RGB(100,50,200) },
134 { LVM_GETTEXTCOLOR, sent },
135 { LVM_SETTEXTBKCOLOR, sent|lparam, 0, RGB(100,50,200) },
136 { LVM_GETTEXTBKCOLOR, sent },
137
138 { LVM_SETBKCOLOR, sent|lparam, 0, CLR_NONE },
139 { LVM_GETBKCOLOR, sent },
140 { LVM_SETTEXTCOLOR, sent|lparam, 0, CLR_NONE },
141 { LVM_GETTEXTCOLOR, sent },
142 { LVM_SETTEXTBKCOLOR, sent|lparam, 0, CLR_NONE },
143 { LVM_GETTEXTBKCOLOR, sent },
144
145 { LVM_SETBKCOLOR, sent|lparam, 0, RGB(255,255,255) },
146 { LVM_GETBKCOLOR, sent },
147 { LVM_SETTEXTCOLOR, sent|lparam, 0, RGB(255,255,255) },
148 { LVM_GETTEXTCOLOR, sent },
149 { LVM_SETTEXTBKCOLOR, sent|lparam, 0, RGB(255,255,255) },
150 { LVM_GETTEXTBKCOLOR, sent },
151 { 0 }
152 };
153
154 static const struct message listview_item_count_seq[] = {
155 { LVM_GETITEMCOUNT, sent },
156 { LVM_INSERTITEMA, sent },
157 { LVM_INSERTITEMA, sent },
158 { LVM_INSERTITEMA, sent },
159 { LVM_GETITEMCOUNT, sent },
160 { LVM_DELETEITEM, sent|wparam, 2 },
161 { WM_NCPAINT, sent|optional },
162 { WM_ERASEBKGND, sent|optional },
163 { LVM_GETITEMCOUNT, sent },
164 { LVM_DELETEALLITEMS, sent },
165 { LVM_GETITEMCOUNT, sent },
166 { LVM_INSERTITEMA, sent },
167 { LVM_INSERTITEMA, sent },
168 { LVM_GETITEMCOUNT, sent },
169 { LVM_INSERTITEMA, sent },
170 { LVM_GETITEMCOUNT, sent },
171 { 0 }
172 };
173
174 static const struct message listview_itempos_seq[] = {
175 { LVM_INSERTITEMA, sent },
176 { LVM_INSERTITEMA, sent },
177 { LVM_INSERTITEMA, sent },
178 { LVM_SETITEMPOSITION, sent|wparam|lparam, 1, MAKELPARAM(10,5) },
179 { WM_NCPAINT, sent|optional },
180 { WM_ERASEBKGND, sent|optional },
181 { LVM_GETITEMPOSITION, sent|wparam, 1 },
182 { LVM_SETITEMPOSITION, sent|wparam|lparam, 2, MAKELPARAM(0,0) },
183 { LVM_GETITEMPOSITION, sent|wparam, 2 },
184 { LVM_SETITEMPOSITION, sent|wparam|lparam, 0, MAKELPARAM(20,20) },
185 { LVM_GETITEMPOSITION, sent|wparam, 0 },
186 { 0 }
187 };
188
189 static const struct message listview_ownerdata_switchto_seq[] = {
190 { WM_STYLECHANGING, sent },
191 { WM_STYLECHANGED, sent },
192 { 0 }
193 };
194
195 static const struct message listview_getorderarray_seq[] = {
196 { LVM_GETCOLUMNORDERARRAY, sent|id|wparam, 2, 0, LISTVIEW_ID },
197 { HDM_GETORDERARRAY, sent|id|wparam, 2, 0, HEADER_ID },
198 { LVM_GETCOLUMNORDERARRAY, sent|id|wparam, 0, 0, LISTVIEW_ID },
199 { HDM_GETORDERARRAY, sent|id|wparam, 0, 0, HEADER_ID },
200 { 0 }
201 };
202
203 static const struct message listview_setorderarray_seq[] = {
204 { LVM_SETCOLUMNORDERARRAY, sent|id|wparam, 2, 0, LISTVIEW_ID },
205 { HDM_SETORDERARRAY, sent|id|wparam, 2, 0, HEADER_ID },
206 { LVM_SETCOLUMNORDERARRAY, sent|id|wparam, 0, 0, LISTVIEW_ID },
207 { HDM_SETORDERARRAY, sent|id|wparam, 0, 0, HEADER_ID },
208 { 0 }
209 };
210
211 static const struct message empty_seq[] = {
212 { 0 }
213 };
214
215 static const struct message parent_focus_change_ownerdata_seq[] = {
216 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
217 { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
218 { 0 }
219 };
220
221 static const struct message forward_erasebkgnd_parent_seq[] = {
222 { WM_ERASEBKGND, sent },
223 { 0 }
224 };
225
226 static const struct message ownerdata_select_focus_parent_seq[] = {
227 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
228 { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
229 { WM_NOTIFY, sent|id|optional, 0, 0, LVN_GETDISPINFOA }, /* version 4.7x */
230 { 0 }
231 };
232
233 static const struct message ownerdata_setstate_all_parent_seq[] = {
234 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
235 { 0 }
236 };
237
238 static const struct message ownerdata_defocus_all_parent_seq[] = {
239 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
240 { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
241 { WM_NOTIFY, sent|id|optional, 0, 0, LVN_GETDISPINFOA },
242 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
243 { 0 }
244 };
245
246 static const struct message ownerdata_deselect_all_parent_seq[] = {
247 { WM_NOTIFY, sent|id, 0, 0, LVN_ODCACHEHINT },
248 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
249 { 0 }
250 };
251
252 static const struct message change_all_parent_seq[] = {
253 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
254 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
255
256 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
257 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
258
259 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
260 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
261
262 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
263 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
264
265 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
266 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
267 { 0 }
268 };
269
270 static const struct message changing_all_parent_seq[] = {
271 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
272 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
273 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
274 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
275 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
276 { 0 }
277 };
278
279 static const struct message textcallback_set_again_parent_seq[] = {
280 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
281 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
282 { 0 }
283 };
284
285 static const struct message single_getdispinfo_parent_seq[] = {
286 { WM_NOTIFY, sent|id, 0, 0, LVN_GETDISPINFOA },
287 { 0 }
288 };
289
290 static const struct message getitemposition_seq1[] = {
291 { LVM_GETITEMPOSITION, sent|id, 0, 0, LISTVIEW_ID },
292 { 0 }
293 };
294
295 static const struct message getitemposition_seq2[] = {
296 { LVM_GETITEMPOSITION, sent|id, 0, 0, LISTVIEW_ID },
297 { HDM_GETITEMRECT, sent|id, 0, 0, HEADER_ID },
298 { 0 }
299 };
300
301 static const struct message getsubitemrect_seq[] = {
302 { LVM_GETSUBITEMRECT, sent|id|wparam, -1, 0, LISTVIEW_ID },
303 { HDM_GETITEMRECT, sent|id, 0, 0, HEADER_ID },
304 { LVM_GETSUBITEMRECT, sent|id|wparam, 0, 0, LISTVIEW_ID },
305 { HDM_GETITEMRECT, sent|id, 0, 0, HEADER_ID },
306 { LVM_GETSUBITEMRECT, sent|id|wparam, -10, 0, LISTVIEW_ID },
307 { HDM_GETITEMRECT, sent|id, 0, 0, HEADER_ID },
308 { LVM_GETSUBITEMRECT, sent|id|wparam, 20, 0, LISTVIEW_ID },
309 { HDM_GETITEMRECT, sent|id, 0, 0, HEADER_ID },
310 { 0 }
311 };
312
313 static const struct message editbox_create_pos[] = {
314 /* sequence sent after LVN_BEGINLABELEDIT */
315 /* next two are 4.7x specific */
316 { WM_WINDOWPOSCHANGING, sent },
317 { WM_WINDOWPOSCHANGED, sent|optional },
318
319 { WM_WINDOWPOSCHANGING, sent|optional },
320 { WM_NCCALCSIZE, sent },
321 { WM_WINDOWPOSCHANGED, sent },
322 { WM_MOVE, sent|defwinproc },
323 { WM_SIZE, sent|defwinproc },
324 /* the rest is todo, skipped in 4.7x */
325 { WM_WINDOWPOSCHANGING, sent|optional },
326 { WM_WINDOWPOSCHANGED, sent|optional },
327 { 0 }
328 };
329
330 static const struct message scroll_parent_seq[] = {
331 { WM_NOTIFY, sent|id, 0, 0, LVN_BEGINSCROLL },
332 { WM_NOTIFY, sent|id, 0, 0, LVN_ENDSCROLL },
333 { 0 }
334 };
335
336 static const struct message setredraw_seq[] = {
337 { WM_SETREDRAW, sent|id|wparam, FALSE, 0, LISTVIEW_ID },
338 { 0 }
339 };
340
341 static const struct message lvs_ex_transparentbkgnd_seq[] = {
342 { WM_PRINTCLIENT, sent|lparam, 0, PRF_ERASEBKGND },
343 { 0 }
344 };
345
346 static const struct message edit_end_nochange[] = {
347 { WM_NOTIFY, sent|id, 0, 0, LVN_ENDLABELEDITA },
348 { WM_NOTIFY, sent|id, 0, 0, NM_CUSTOMDRAW }, /* todo */
349 { WM_NOTIFY, sent|id, 0, 0, NM_SETFOCUS },
350 { 0 }
351 };
352
353 static const struct message hover_parent[] = {
354 { WM_GETDLGCODE, sent }, /* todo_wine */
355 { WM_NOTIFY, sent|id, 0, 0, NM_HOVER },
356 { 0 }
357 };
358
359 static const struct message listview_destroy[] = {
360 { 0x0090, sent|optional }, /* Vista */
361 { WM_PARENTNOTIFY, sent },
362 { WM_SHOWWINDOW, sent },
363 { WM_WINDOWPOSCHANGING, sent },
364 { WM_WINDOWPOSCHANGED, sent|optional },
365 { WM_DESTROY, sent },
366 { WM_NOTIFY, sent|id, 0, 0, LVN_DELETEALLITEMS },
367 { WM_NCDESTROY, sent },
368 { 0 }
369 };
370
371 static const struct message listview_ownerdata_destroy[] = {
372 { 0x0090, sent|optional }, /* Vista */
373 { WM_PARENTNOTIFY, sent },
374 { WM_SHOWWINDOW, sent },
375 { WM_WINDOWPOSCHANGING, sent },
376 { WM_WINDOWPOSCHANGED, sent|optional },
377 { WM_DESTROY, sent },
378 { WM_NCDESTROY, sent },
379 { 0 }
380 };
381
382 static const struct message listview_ownerdata_deleteall[] = {
383 { LVM_DELETEALLITEMS, sent },
384 { WM_NOTIFY, sent|id, 0, 0, LVN_DELETEALLITEMS },
385 { 0 }
386 };
387
388 static const struct message listview_header_changed_seq[] = {
389 { LVM_SETCOLUMNA, sent },
390 { WM_NOTIFY, sent|id|defwinproc, 0, 0, LISTVIEW_ID },
391 { WM_NOTIFY, sent|id|defwinproc, 0, 0, LISTVIEW_ID },
392 { 0 }
393 };
394
395 static const struct message parent_header_click_seq[] = {
396 { WM_NOTIFY, sent|id, 0, 0, LVN_COLUMNCLICK },
397 { WM_NOTIFY, sent|id, 0, 0, HDN_ITEMCLICKA },
398 { 0 }
399 };
400
401 static const struct message parent_header_divider_dclick_seq[] = {
402 { WM_NOTIFY, sent|id, 0, 0, HDN_ITEMCHANGINGA },
403 { WM_NOTIFY, sent|id, 0, 0, NM_CUSTOMDRAW },
404 { WM_NOTIFY, sent|id, 0, 0, NM_CUSTOMDRAW },
405 { WM_NOTIFY, sent|id, 0, 0, HDN_ITEMCHANGEDA },
406 { WM_NOTIFY, sent|id, 0, 0, HDN_DIVIDERDBLCLICKA },
407 { 0 }
408 };
409
410 static const struct message listview_set_imagelist[] = {
411 { LVM_SETIMAGELIST, sent|id, 0, 0, LISTVIEW_ID },
412 { 0 }
413 };
414
415 static const struct message listview_header_set_imagelist[] = {
416 { LVM_SETIMAGELIST, sent|id, 0, 0, LISTVIEW_ID },
417 { HDM_SETIMAGELIST, sent|id, 0, 0, HEADER_ID },
418 { 0 }
419 };
420
421 static const struct message parent_insert_focused_seq[] = {
422 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
423 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
424 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
425 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
426 { WM_NOTIFY, sent|id, 0, 0, LVN_INSERTITEM },
427 { 0 }
428 };
429
430 static const struct message parent_report_cd_seq[] = {
431 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_PREPAINT },
432 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPREPAINT },
433 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPREPAINT|CDDS_SUBITEM },
434 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPOSTPAINT|CDDS_SUBITEM },
435 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPREPAINT|CDDS_SUBITEM },
436 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPOSTPAINT|CDDS_SUBITEM },
437 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPOSTPAINT },
438 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_POSTPAINT },
439 { 0 }
440 };
441
442 static const struct message parent_list_cd_seq[] = {
443 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_PREPAINT },
444 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPREPAINT },
445 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_ITEMPOSTPAINT },
446 { WM_NOTIFY, sent|id|custdraw, 0, 0, NM_CUSTOMDRAW, CDDS_POSTPAINT },
447 { 0 }
448 };
449
450 static const struct message listview_end_label_edit[] = {
451 { WM_NOTIFY, sent|id, 0, 0, LVN_ENDLABELEDITA },
452 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING},
453 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
454 { WM_NOTIFY, sent|id|optional, 0, 0, NM_CUSTOMDRAW }, /* XP */
455 { WM_NOTIFY, sent|id, 0, 0, NM_SETFOCUS },
456 { 0 }
457 };
458
459 static const struct message listview_end_label_edit_kill_focus[] = {
460 { WM_NOTIFY, sent|id, 0, 0, LVN_ENDLABELEDITA },
461 { WM_COMMAND, sent|id|optional, 0, 0, EN_KILLFOCUS }, /* todo: not sent by wine yet */
462 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGING },
463 { WM_NOTIFY, sent|id, 0, 0, LVN_ITEMCHANGED },
464 { WM_NOTIFY, sent|id|optional, 0, 0, NM_CUSTOMDRAW }, /* XP */
465 { WM_NOTIFY, sent|id, 0, 0, NM_SETFOCUS },
466 { 0 }
467 };
468
469 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
470 {
471 static LONG defwndproc_counter = 0;
472 LRESULT ret;
473 struct message msg;
474
475 msg.message = message;
476 msg.flags = sent|wparam|lparam;
477 if (defwndproc_counter) msg.flags |= defwinproc;
478 msg.wParam = wParam;
479 msg.lParam = lParam;
480 if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;
481 if (message == WM_COMMAND) msg.id = HIWORD(wParam);
482
483 /* log system messages, except for painting */
484 if (message < WM_USER &&
485 message != WM_PAINT &&
486 message != WM_ERASEBKGND &&
487 message != WM_NCPAINT &&
488 message != WM_NCHITTEST &&
489 message != WM_GETTEXT &&
490 message != WM_GETICON &&
491 message != WM_DEVICECHANGE)
492 {
493 add_message(sequences, PARENT_SEQ_INDEX, &msg);
494 add_message(sequences, COMBINED_SEQ_INDEX, &msg);
495 }
496 add_message(sequences, PARENT_FULL_SEQ_INDEX, &msg);
497
498 switch (message)
499 {
500 case WM_NOTIFY:
501 {
502 switch (((NMHDR*)lParam)->code)
503 {
504 case LVN_BEGINLABELEDITA:
505 {
506 HWND edit = NULL;
507
508 /* subclass edit box */
509 if (!blockEdit)
510 edit = subclass_editbox(((NMHDR*)lParam)->hwndFrom);
511
512 if (edit)
513 {
514 INT len = SendMessageA(edit, EM_GETLIMITTEXT, 0, 0);
515 ok(len == 259 || broken(len == 260) /* includes NULL in NT4 */,
516 "text limit %d, expected 259\n", len);
517 }
518
519 return blockEdit;
520 }
521 case LVN_ENDLABELEDITA:
522 {
523 HWND edit;
524
525 /* always accept new item text */
526 NMLVDISPINFOA *di = (NMLVDISPINFOA*)lParam;
527 g_editbox_disp_info = *di;
528
529 /* edit control still available from this notification */
530 edit = (HWND)SendMessageA(((NMHDR*)lParam)->hwndFrom, LVM_GETEDITCONTROL, 0, 0);
531 ok(IsWindow(edit), "expected valid edit control handle\n");
532 ok((GetWindowLongA(edit, GWL_STYLE) & ES_MULTILINE) == 0, "edit is multiline\n");
533
534 if (g_WM_KILLFOCUS_on_LVN_ENDLABELEDIT)
535 SendMessageA(edit, WM_KILLFOCUS, 0, 0);
536
537 return TRUE;
538 }
539 case LVN_ITEMCHANGING:
540 {
541 NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam;
542 g_nmlistview_changing = *nmlv;
543 }
544 break;
545 case LVN_ITEMCHANGED:
546 {
547 NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam;
548 g_nmlistview = *nmlv;
549 }
550 break;
551 case LVN_GETDISPINFOA:
552 {
553 NMLVDISPINFOA *dispinfo = (NMLVDISPINFOA*)lParam;
554 g_itema = dispinfo->item;
555
556 if (g_disp_A_to_W && (dispinfo->item.mask & LVIF_TEXT))
557 {
558 static const WCHAR testW[] = {'T','E','S','T',0};
559 dispinfo->hdr.code = LVN_GETDISPINFOW;
560 memcpy(dispinfo->item.pszText, testW, sizeof(testW));
561 }
562
563 /* test control buffer size for text, 10 used to mask cases when control
564 is using caller buffer to process LVM_GETITEM for example */
565 if (dispinfo->item.mask & LVIF_TEXT && dispinfo->item.cchTextMax > 10)
566 ok(dispinfo->item.cchTextMax == 260 ||
567 broken(dispinfo->item.cchTextMax == 264) /* NT4 reports aligned size */,
568 "buffer size %d\n", dispinfo->item.cchTextMax);
569 }
570 break;
571 case LVN_DELETEITEM:
572 if (g_focus_test_LVN_DELETEITEM)
573 {
574 NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam;
575 UINT state;
576
577 state = SendMessageA(((NMHDR*)lParam)->hwndFrom, LVM_GETITEMSTATE, nmlv->iItem, LVIS_FOCUSED);
578 ok(state == 0, "got state %x\n", state);
579 }
580 break;
581 case NM_HOVER:
582 if (g_block_hover) return 1;
583 break;
584 }
585 break;
586 }
587 case WM_NOTIFYFORMAT:
588 {
589 /* force to return format */
590 if (lParam == NF_QUERY && notifyFormat != -1) return notifyFormat;
591 break;
592 }
593 }
594
595 defwndproc_counter++;
596 if (IsWindowUnicode(hwnd))
597 ret = DefWindowProcW(hwnd, message, wParam, lParam);
598 else
599 ret = DefWindowProcA(hwnd, message, wParam, lParam);
600 defwndproc_counter--;
601
602 return ret;
603 }
604
605 static BOOL register_parent_wnd_class(BOOL Unicode)
606 {
607 WNDCLASSA clsA;
608 WNDCLASSW clsW;
609
610 if (Unicode)
611 {
612 clsW.style = 0;
613 clsW.lpfnWndProc = parent_wnd_proc;
614 clsW.cbClsExtra = 0;
615 clsW.cbWndExtra = 0;
616 clsW.hInstance = GetModuleHandleW(NULL);
617 clsW.hIcon = 0;
618 clsW.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
619 clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
620 clsW.lpszMenuName = NULL;
621 clsW.lpszClassName = testparentclassW;
622 }
623 else
624 {
625 clsA.style = 0;
626 clsA.lpfnWndProc = parent_wnd_proc;
627 clsA.cbClsExtra = 0;
628 clsA.cbWndExtra = 0;
629 clsA.hInstance = GetModuleHandleA(NULL);
630 clsA.hIcon = 0;
631 clsA.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
632 clsA.hbrBackground = GetStockObject(WHITE_BRUSH);
633 clsA.lpszMenuName = NULL;
634 clsA.lpszClassName = "Listview test parent class";
635 }
636
637 return Unicode ? RegisterClassW(&clsW) : RegisterClassA(&clsA);
638 }
639
640 static HWND create_parent_window(BOOL Unicode)
641 {
642 static const WCHAR nameW[] = {'t','e','s','t','p','a','r','e','n','t','n','a','m','e','W',0};
643 HWND hwnd;
644
645 if (!register_parent_wnd_class(Unicode))
646 return NULL;
647
648 blockEdit = FALSE;
649 notifyFormat = -1;
650
651 if (Unicode)
652 hwnd = CreateWindowExW(0, testparentclassW, nameW,
653 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
654 WS_MAXIMIZEBOX | WS_VISIBLE,
655 0, 0, 100, 100,
656 GetDesktopWindow(), NULL, GetModuleHandleW(NULL), NULL);
657 else
658 hwnd = CreateWindowExA(0, "Listview test parent class",
659 "Listview test parent window",
660 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
661 WS_MAXIMIZEBOX | WS_VISIBLE,
662 0, 0, 100, 100,
663 GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
664 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
665 return hwnd;
666 }
667
668 static LRESULT WINAPI listview_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
669 {
670 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
671 static LONG defwndproc_counter = 0;
672 LRESULT ret;
673 struct message msg;
674
675 msg.message = message;
676 msg.flags = sent|wparam|lparam;
677 if (defwndproc_counter) msg.flags |= defwinproc;
678 msg.wParam = wParam;
679 msg.lParam = lParam;
680 msg.id = LISTVIEW_ID;
681 add_message(sequences, LISTVIEW_SEQ_INDEX, &msg);
682 add_message(sequences, COMBINED_SEQ_INDEX, &msg);
683
684 defwndproc_counter++;
685 ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
686 defwndproc_counter--;
687 return ret;
688 }
689
690 static HWND create_listview_control(DWORD style)
691 {
692 WNDPROC oldproc;
693 HWND hwnd;
694 RECT rect;
695
696 GetClientRect(hwndparent, &rect);
697 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo",
698 WS_CHILD | WS_BORDER | WS_VISIBLE | style,
699 0, 0, rect.right, rect.bottom,
700 hwndparent, NULL, GetModuleHandleA(NULL), NULL);
701 ok(hwnd != NULL, "gle=%d\n", GetLastError());
702
703 if (!hwnd) return NULL;
704
705 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
706 (LONG_PTR)listview_subclass_proc);
707 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
708
709 return hwnd;
710 }
711
712 /* unicode listview window with specified parent */
713 static HWND create_listview_controlW(DWORD style, HWND parent)
714 {
715 WNDPROC oldproc;
716 HWND hwnd;
717 RECT rect;
718 static const WCHAR nameW[] = {'f','o','o',0};
719
720 GetClientRect(parent, &rect);
721 hwnd = CreateWindowExW(0, WC_LISTVIEWW, nameW,
722 WS_CHILD | WS_BORDER | WS_VISIBLE | style,
723 0, 0, rect.right, rect.bottom,
724 parent, NULL, GetModuleHandleW(NULL), NULL);
725 ok(hwnd != NULL, "gle=%d\n", GetLastError());
726
727 if (!hwnd) return NULL;
728
729 oldproc = (WNDPROC)SetWindowLongPtrW(hwnd, GWLP_WNDPROC,
730 (LONG_PTR)listview_subclass_proc);
731 SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
732
733 return hwnd;
734 }
735
736 static BOOL is_win_xp(void)
737 {
738 HWND hwnd, header;
739 BOOL ret;
740
741 hwnd = create_listview_control(LVS_ICON);
742 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS, LVS_EX_HEADERINALLVIEWS);
743 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
744 ret = !IsWindow(header);
745
746 DestroyWindow(hwnd);
747
748 return ret;
749 }
750
751 static LRESULT WINAPI header_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
752 {
753 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
754 static LONG defwndproc_counter = 0;
755 struct message msg = { 0 };
756 LRESULT ret;
757
758 msg.message = message;
759 msg.flags = sent|wparam|lparam;
760 if (defwndproc_counter) msg.flags |= defwinproc;
761 msg.wParam = wParam;
762 msg.lParam = lParam;
763 msg.id = HEADER_ID;
764 add_message(sequences, LISTVIEW_SEQ_INDEX, &msg);
765
766 defwndproc_counter++;
767 ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
768 defwndproc_counter--;
769 return ret;
770 }
771
772 static HWND subclass_header(HWND hwndListview)
773 {
774 WNDPROC oldproc;
775 HWND hwnd;
776
777 hwnd = (HWND)SendMessageA(hwndListview, LVM_GETHEADER, 0, 0);
778 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
779 (LONG_PTR)header_subclass_proc);
780 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
781
782 return hwnd;
783 }
784
785 static LRESULT WINAPI editbox_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
786 {
787 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
788 static LONG defwndproc_counter = 0;
789 struct message msg = { 0 };
790 LRESULT ret;
791
792 msg.message = message;
793 msg.flags = sent|wparam|lparam;
794 if (defwndproc_counter) msg.flags |= defwinproc;
795 msg.wParam = wParam;
796 msg.lParam = lParam;
797
798 /* all we need is sizing */
799 if (message == WM_WINDOWPOSCHANGING ||
800 message == WM_NCCALCSIZE ||
801 message == WM_WINDOWPOSCHANGED ||
802 message == WM_MOVE ||
803 message == WM_SIZE)
804 {
805 add_message(sequences, EDITBOX_SEQ_INDEX, &msg);
806 }
807
808 defwndproc_counter++;
809 ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
810 defwndproc_counter--;
811 return ret;
812 }
813
814 static HWND subclass_editbox(HWND hwndListview)
815 {
816 WNDPROC oldproc;
817 HWND hwnd;
818
819 hwnd = (HWND)SendMessageA(hwndListview, LVM_GETEDITCONTROL, 0, 0);
820 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
821 (LONG_PTR)editbox_subclass_proc);
822 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
823
824 return hwnd;
825 }
826
827 /* Performs a single LVM_HITTEST test */
828 static void test_lvm_hittest_(HWND hwnd, INT x, INT y, INT item, UINT flags, UINT broken_flags,
829 BOOL todo_item, BOOL todo_flags, int line)
830 {
831 LVHITTESTINFO lpht;
832 INT ret;
833
834 lpht.pt.x = x;
835 lpht.pt.y = y;
836 lpht.iSubItem = 10;
837
838 ret = SendMessageA(hwnd, LVM_HITTEST, 0, (LPARAM)&lpht);
839
840 todo_wine_if(todo_item)
841 {
842 ok_(__FILE__, line)(ret == item, "Expected %d retval, got %d\n", item, ret);
843 ok_(__FILE__, line)(lpht.iItem == item, "Expected %d item, got %d\n", item, lpht.iItem);
844 ok_(__FILE__, line)(lpht.iSubItem == 10, "Expected subitem not overwrited\n");
845 }
846
847 if (todo_flags)
848 {
849 todo_wine
850 ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
851 }
852 else if (broken_flags)
853 ok_(__FILE__, line)(lpht.flags == flags || broken(lpht.flags == broken_flags),
854 "Expected flags %x, got %x\n", flags, lpht.flags);
855 else
856 ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
857 }
858
859 #define test_lvm_hittest(a,b,c,d,e,f,g,h) test_lvm_hittest_(a,b,c,d,e,f,g,h,__LINE__)
860
861 /* Performs a single LVM_SUBITEMHITTEST test */
862 static void test_lvm_subitemhittest_(HWND hwnd, INT x, INT y, INT item, INT subitem, UINT flags,
863 BOOL todo_item, BOOL todo_subitem, BOOL todo_flags, int line)
864 {
865 LVHITTESTINFO lpht;
866 INT ret;
867
868 lpht.pt.x = x;
869 lpht.pt.y = y;
870
871 ret = SendMessageA(hwnd, LVM_SUBITEMHITTEST, 0, (LPARAM)&lpht);
872
873 todo_wine_if(todo_item)
874 {
875 ok_(__FILE__, line)(ret == item, "Expected %d retval, got %d\n", item, ret);
876 ok_(__FILE__, line)(lpht.iItem == item, "Expected %d item, got %d\n", item, lpht.iItem);
877 }
878
879 todo_wine_if(todo_subitem)
880 ok_(__FILE__, line)(lpht.iSubItem == subitem, "Expected subitem %d, got %d\n", subitem, lpht.iSubItem);
881
882 todo_wine_if(todo_flags)
883 ok_(__FILE__, line)(lpht.flags == flags, "Expected flags 0x%x, got 0x%x\n", flags, lpht.flags);
884 }
885
886 #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__)
887
888 static void test_images(void)
889 {
890 HWND hwnd;
891 INT r;
892 LVITEMA item;
893 HIMAGELIST himl;
894 HBITMAP hbmp;
895 RECT r1, r2;
896 static CHAR hello[] = "hello";
897
898 himl = pImageList_Create(40, 40, 0, 4, 4);
899 ok(himl != NULL, "failed to create imagelist\n");
900
901 hbmp = CreateBitmap(40, 40, 1, 1, NULL);
902 ok(hbmp != NULL, "failed to create bitmap\n");
903
904 r = pImageList_Add(himl, hbmp, 0);
905 ok(r == 0, "should be zero\n");
906
907 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo", LVS_OWNERDRAWFIXED,
908 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
909 ok(hwnd != NULL, "failed to create listview window\n");
910
911 r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
912 LVS_EX_UNDERLINEHOT | LVS_EX_FLATSB | LVS_EX_ONECLICKACTIVATE);
913
914 ok(r == 0, "should return zero\n");
915
916 r = SendMessageA(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
917 ok(r == 0, "should return zero\n");
918
919 r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELONG(100,50));
920 ok(r != 0, "got 0\n");
921
922 /* returns dimensions */
923
924 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
925 ok(r == 0, "should be zero items\n");
926
927 item.mask = LVIF_IMAGE | LVIF_TEXT;
928 item.iItem = 0;
929 item.iSubItem = 1;
930 item.iImage = 0;
931 item.pszText = 0;
932 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
933 ok(r == -1, "should fail\n");
934
935 item.iSubItem = 0;
936 item.pszText = hello;
937 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
938 ok(r == 0, "should not fail\n");
939
940 SetRect(&r1, LVIR_ICON, 0, 0, 0);
941 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r1);
942 expect(1, r);
943
944 r = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
945 ok(r == TRUE, "should not fail\n");
946
947 item.iSubItem = 0;
948 item.pszText = hello;
949 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
950 ok(r == 0, "should not fail\n");
951
952 SetRect(&r2, LVIR_ICON, 0, 0, 0);
953 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r2);
954 expect(1, r);
955
956 ok(EqualRect(&r1, &r2), "rectangle should be the same\n");
957
958 DestroyWindow(hwnd);
959 }
960
961 static void test_checkboxes(void)
962 {
963 HWND hwnd;
964 LVITEMA item;
965 DWORD r;
966 static CHAR text[] = "Text",
967 text2[] = "Text2",
968 text3[] = "Text3";
969
970 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo", LVS_REPORT,
971 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
972 ok(hwnd != NULL, "failed to create listview window\n");
973
974 /* first without LVS_EX_CHECKBOXES set and an item and check that state is preserved */
975 item.mask = LVIF_TEXT | LVIF_STATE;
976 item.stateMask = 0xffff;
977 item.state = 0xfccc;
978 item.iItem = 0;
979 item.iSubItem = 0;
980 item.pszText = text;
981 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
982 expect(0, r);
983
984 item.iItem = 0;
985 item.mask = LVIF_STATE;
986 item.stateMask = 0xffff;
987 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
988 expect(1, r);
989 ok(item.state == 0xfccc, "state %x\n", item.state);
990
991 /* Don't set LVIF_STATE */
992 item.mask = LVIF_TEXT;
993 item.stateMask = 0xffff;
994 item.state = 0xfccc;
995 item.iItem = 1;
996 item.iSubItem = 0;
997 item.pszText = text;
998 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
999 expect(1, r);
1000
1001 item.iItem = 1;
1002 item.mask = LVIF_STATE;
1003 item.stateMask = 0xffff;
1004 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1005 expect(1, r);
1006 ok(item.state == 0, "state %x\n", item.state);
1007
1008 r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
1009 expect(0, r);
1010
1011 /* Having turned on checkboxes, check that all existing items are set to 0x1000 (unchecked) */
1012 item.iItem = 0;
1013 item.mask = LVIF_STATE;
1014 item.stateMask = 0xffff;
1015 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1016 expect(1, r);
1017 if (item.state != 0x1ccc)
1018 {
1019 win_skip("LVS_EX_CHECKBOXES style is unavailable. Skipping.\n");
1020 DestroyWindow(hwnd);
1021 return;
1022 }
1023
1024 /* Now add an item without specifying a state and check that its state goes to 0x1000 */
1025 item.iItem = 2;
1026 item.mask = LVIF_TEXT;
1027 item.state = 0;
1028 item.pszText = text2;
1029 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1030 expect(2, r);
1031
1032 item.iItem = 2;
1033 item.mask = LVIF_STATE;
1034 item.stateMask = 0xffff;
1035 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1036 expect(1, r);
1037 ok(item.state == 0x1000, "state %x\n", item.state);
1038
1039 /* Add a further item this time specifying a state and still its state goes to 0x1000 */
1040 item.iItem = 3;
1041 item.mask = LVIF_TEXT | LVIF_STATE;
1042 item.stateMask = 0xffff;
1043 item.state = 0x2aaa;
1044 item.pszText = text3;
1045 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1046 expect(3, r);
1047
1048 item.iItem = 3;
1049 item.mask = LVIF_STATE;
1050 item.stateMask = 0xffff;
1051 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1052 expect(1, r);
1053 ok(item.state == 0x1aaa, "state %x\n", item.state);
1054
1055 /* Set an item's state to checked */
1056 item.iItem = 3;
1057 item.mask = LVIF_STATE;
1058 item.stateMask = 0xf000;
1059 item.state = 0x2000;
1060 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1061 expect(1, r);
1062
1063 item.iItem = 3;
1064 item.mask = LVIF_STATE;
1065 item.stateMask = 0xffff;
1066 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1067 expect(1, r);
1068 ok(item.state == 0x2aaa, "state %x\n", item.state);
1069
1070 /* Check that only the bits we asked for are returned,
1071 * and that all the others are set to zero
1072 */
1073 item.iItem = 3;
1074 item.mask = LVIF_STATE;
1075 item.stateMask = 0xf000;
1076 item.state = 0xffff;
1077 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1078 expect(1, r);
1079 ok(item.state == 0x2000, "state %x\n", item.state);
1080
1081 /* Set the style again and check that doesn't change an item's state */
1082 r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
1083 ok(r == LVS_EX_CHECKBOXES, "ret %x\n", r);
1084
1085 item.iItem = 3;
1086 item.mask = LVIF_STATE;
1087 item.stateMask = 0xffff;
1088 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1089 expect(1, r);
1090 ok(item.state == 0x2aaa, "state %x\n", item.state);
1091
1092 /* Unsetting the checkbox extended style doesn't change an item's state */
1093 r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, 0);
1094 ok(r == LVS_EX_CHECKBOXES, "ret %x\n", r);
1095
1096 item.iItem = 3;
1097 item.mask = LVIF_STATE;
1098 item.stateMask = 0xffff;
1099 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1100 expect(1, r);
1101 ok(item.state == 0x2aaa, "state %x\n", item.state);
1102
1103 /* Now setting the style again will change an item's state */
1104 r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
1105 expect(0, r);
1106
1107 item.iItem = 3;
1108 item.mask = LVIF_STATE;
1109 item.stateMask = 0xffff;
1110 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1111 expect(1, r);
1112 ok(item.state == 0x1aaa, "state %x\n", item.state);
1113
1114 /* Toggle checkbox tests (bug 9934) */
1115 memset (&item, 0xcc, sizeof(item));
1116 item.mask = LVIF_STATE;
1117 item.iItem = 3;
1118 item.iSubItem = 0;
1119 item.state = LVIS_FOCUSED;
1120 item.stateMask = LVIS_FOCUSED;
1121 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1122 expect(1, r);
1123
1124 item.iItem = 3;
1125 item.mask = LVIF_STATE;
1126 item.stateMask = 0xffff;
1127 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1128 expect(1, r);
1129 ok(item.state == 0x1aab, "state %x\n", item.state);
1130
1131 r = SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
1132 expect(0, r);
1133 r = SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
1134 expect(0, r);
1135
1136 item.iItem = 3;
1137 item.mask = LVIF_STATE;
1138 item.stateMask = 0xffff;
1139 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1140 expect(1, r);
1141 ok(item.state == 0x2aab, "state %x\n", item.state);
1142
1143 r = SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
1144 expect(0, r);
1145 r = SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
1146 expect(0, r);
1147
1148 item.iItem = 3;
1149 item.mask = LVIF_STATE;
1150 item.stateMask = 0xffff;
1151 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1152 expect(1, r);
1153 ok(item.state == 0x1aab, "state %x\n", item.state);
1154
1155 DestroyWindow(hwnd);
1156 }
1157
1158 static void insert_column(HWND hwnd, int idx)
1159 {
1160 LVCOLUMNA column;
1161 INT rc;
1162
1163 memset(&column, 0xcc, sizeof(column));
1164 column.mask = LVCF_SUBITEM;
1165 column.iSubItem = idx;
1166
1167 rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, idx, (LPARAM)&column);
1168 expect(idx, rc);
1169 }
1170
1171 static void insert_item(HWND hwnd, int idx)
1172 {
1173 static CHAR text[] = "foo";
1174
1175 LVITEMA item;
1176 INT rc;
1177
1178 memset(&item, 0xcc, sizeof (item));
1179 item.mask = LVIF_TEXT;
1180 item.iItem = idx;
1181 item.iSubItem = 0;
1182 item.pszText = text;
1183
1184 rc = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
1185 expect(idx, rc);
1186 }
1187
1188 static void test_items(void)
1189 {
1190 const LPARAM lparamTest = 0x42;
1191 static CHAR text[] = "Text";
1192 char buffA[5];
1193 HWND hwnd;
1194 LVITEMA item;
1195 DWORD r;
1196
1197 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo", LVS_REPORT,
1198 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
1199 ok(hwnd != NULL, "failed to create listview window\n");
1200
1201 /*
1202 * Test setting/getting item params
1203 */
1204
1205 /* Set up two columns */
1206 insert_column(hwnd, 0);
1207 insert_column(hwnd, 1);
1208
1209 /* LVIS_SELECTED with zero stateMask */
1210 /* set */
1211 memset (&item, 0, sizeof (item));
1212 item.mask = LVIF_STATE;
1213 item.state = LVIS_SELECTED;
1214 item.stateMask = 0;
1215 item.iItem = 0;
1216 item.iSubItem = 0;
1217 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1218 expect(0, r);
1219 /* get */
1220 memset (&item, 0xcc, sizeof (item));
1221 item.mask = LVIF_STATE;
1222 item.stateMask = LVIS_SELECTED;
1223 item.state = 0;
1224 item.iItem = 0;
1225 item.iSubItem = 0;
1226 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1227 expect(1, r);
1228 ok(item.state & LVIS_SELECTED, "Expected LVIS_SELECTED\n");
1229 r = SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
1230 ok(r, "got %d\n", r);
1231
1232 /* LVIS_SELECTED with zero stateMask */
1233 /* set */
1234 memset (&item, 0, sizeof (item));
1235 item.mask = LVIF_STATE;
1236 item.state = LVIS_FOCUSED;
1237 item.stateMask = 0;
1238 item.iItem = 0;
1239 item.iSubItem = 0;
1240 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1241 expect(0, r);
1242 /* get */
1243 memset (&item, 0xcc, sizeof (item));
1244 item.mask = LVIF_STATE;
1245 item.stateMask = LVIS_FOCUSED;
1246 item.state = 0;
1247 item.iItem = 0;
1248 item.iSubItem = 0;
1249 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1250 expect(1, r);
1251 ok(item.state & LVIS_FOCUSED, "Expected LVIS_FOCUSED\n");
1252 r = SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
1253 ok(r, "got %d\n", r);
1254
1255 /* LVIS_CUT with LVIS_FOCUSED stateMask */
1256 /* set */
1257 memset (&item, 0, sizeof (item));
1258 item.mask = LVIF_STATE;
1259 item.state = LVIS_CUT;
1260 item.stateMask = LVIS_FOCUSED;
1261 item.iItem = 0;
1262 item.iSubItem = 0;
1263 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1264 expect(0, r);
1265 /* get */
1266 memset (&item, 0xcc, sizeof (item));
1267 item.mask = LVIF_STATE;
1268 item.stateMask = LVIS_CUT;
1269 item.state = 0;
1270 item.iItem = 0;
1271 item.iSubItem = 0;
1272 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1273 expect(1, r);
1274 ok(item.state & LVIS_CUT, "Expected LVIS_CUT\n");
1275 r = SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
1276 ok(r, "got %d\n", r);
1277
1278 /* Insert an item with just a param */
1279 memset (&item, 0xcc, sizeof (item));
1280 item.mask = LVIF_PARAM;
1281 item.iItem = 0;
1282 item.iSubItem = 0;
1283 item.lParam = lparamTest;
1284 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1285 expect(0, r);
1286
1287 /* Test getting of the param */
1288 memset (&item, 0xcc, sizeof (item));
1289 item.mask = LVIF_PARAM;
1290 item.iItem = 0;
1291 item.iSubItem = 0;
1292 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1293 expect(1, r);
1294 ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
1295
1296 /* Set up a subitem */
1297 memset (&item, 0xcc, sizeof (item));
1298 item.mask = LVIF_TEXT;
1299 item.iItem = 0;
1300 item.iSubItem = 1;
1301 item.pszText = text;
1302 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1303 expect(1, r);
1304
1305 item.mask = LVIF_TEXT;
1306 item.iItem = 0;
1307 item.iSubItem = 1;
1308 item.pszText = buffA;
1309 item.cchTextMax = sizeof(buffA);
1310 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1311 expect(1, r);
1312 ok(!memcmp(item.pszText, text, sizeof(text)), "got text %s, expected %s\n", item.pszText, text);
1313
1314 /* set up with extra flag */
1315 /* 1. reset subitem text */
1316 item.mask = LVIF_TEXT;
1317 item.iItem = 0;
1318 item.iSubItem = 1;
1319 item.pszText = NULL;
1320 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1321 expect(1, r);
1322
1323 item.mask = LVIF_TEXT;
1324 item.iItem = 0;
1325 item.iSubItem = 1;
1326 item.pszText = buffA;
1327 buffA[0] = 'a';
1328 item.cchTextMax = sizeof(buffA);
1329 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1330 expect(1, r);
1331 ok(item.pszText[0] == 0, "got %p\n", item.pszText);
1332
1333 /* 2. set new text with extra flag specified */
1334 item.mask = LVIF_TEXT | LVIF_DI_SETITEM;
1335 item.iItem = 0;
1336 item.iSubItem = 1;
1337 item.pszText = text;
1338 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1339 ok(r == 1 || broken(r == 0) /* NT4 */, "ret %d\n", r);
1340
1341 if (r == 1)
1342 {
1343 item.mask = LVIF_TEXT;
1344 item.iItem = 0;
1345 item.iSubItem = 1;
1346 item.pszText = buffA;
1347 buffA[0] = 'a';
1348 item.cchTextMax = sizeof(buffA);
1349 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1350 expect(1, r);
1351 ok(!memcmp(item.pszText, text, sizeof(text)), "got %s, expected %s\n", item.pszText, text);
1352 }
1353
1354 /* Query param from subitem: returns main item param */
1355 memset (&item, 0xcc, sizeof (item));
1356 item.mask = LVIF_PARAM;
1357 item.iItem = 0;
1358 item.iSubItem = 1;
1359 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1360 expect(1, r);
1361 ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
1362
1363 /* Set up param on first subitem: no effect */
1364 memset (&item, 0xcc, sizeof (item));
1365 item.mask = LVIF_PARAM;
1366 item.iItem = 0;
1367 item.iSubItem = 1;
1368 item.lParam = lparamTest+1;
1369 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1370 expect(0, r);
1371
1372 /* Query param from subitem again: should still return main item param */
1373 memset (&item, 0xcc, sizeof (item));
1374 item.mask = LVIF_PARAM;
1375 item.iItem = 0;
1376 item.iSubItem = 1;
1377 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1378 expect(1, r);
1379 ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
1380
1381 /**** Some tests of state highlighting ****/
1382 memset (&item, 0xcc, sizeof (item));
1383 item.mask = LVIF_STATE;
1384 item.iItem = 0;
1385 item.iSubItem = 0;
1386 item.state = LVIS_SELECTED;
1387 item.stateMask = LVIS_SELECTED | LVIS_DROPHILITED;
1388 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1389 expect(1, r);
1390 item.iSubItem = 1;
1391 item.state = LVIS_DROPHILITED;
1392 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
1393 expect(1, r);
1394
1395 memset (&item, 0xcc, sizeof (item));
1396 item.mask = LVIF_STATE;
1397 item.iItem = 0;
1398 item.iSubItem = 0;
1399 item.stateMask = -1;
1400 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1401 expect(1, r);
1402 ok(item.state == LVIS_SELECTED, "got state %x, expected %x\n", item.state, LVIS_SELECTED);
1403 item.iSubItem = 1;
1404 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1405 expect(1, r);
1406 todo_wine ok(item.state == LVIS_DROPHILITED, "got state %x, expected %x\n", item.state, LVIS_DROPHILITED);
1407
1408 /* some notnull but meaningless masks */
1409 memset (&item, 0, sizeof(item));
1410 item.mask = LVIF_NORECOMPUTE;
1411 item.iItem = 0;
1412 item.iSubItem = 0;
1413 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1414 expect(1, r);
1415 memset (&item, 0, sizeof(item));
1416 item.mask = LVIF_DI_SETITEM;
1417 item.iItem = 0;
1418 item.iSubItem = 0;
1419 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
1420 expect(1, r);
1421
1422 /* set text to callback value already having it */
1423 r = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
1424 expect(TRUE, r);
1425 memset (&item, 0, sizeof (item));
1426 item.mask = LVIF_TEXT;
1427 item.pszText = LPSTR_TEXTCALLBACKA;
1428 item.iItem = 0;
1429 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
1430 expect(0, r);
1431 memset (&item, 0, sizeof (item));
1432
1433 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1434
1435 item.pszText = LPSTR_TEXTCALLBACKA;
1436 r = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0 , (LPARAM) &item);
1437 expect(TRUE, r);
1438
1439 ok_sequence(sequences, PARENT_SEQ_INDEX, textcallback_set_again_parent_seq,
1440 "check callback text comparison rule", FALSE);
1441
1442 DestroyWindow(hwnd);
1443 }
1444
1445 static void test_columns(void)
1446 {
1447 HWND hwnd, header;
1448 LVCOLUMNA column;
1449 LVITEMA item;
1450 INT order[2];
1451 CHAR buff[5];
1452 DWORD rc;
1453
1454 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo", LVS_LIST,
1455 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
1456 ok(hwnd != NULL, "failed to create listview window\n");
1457
1458 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
1459 ok(header == NULL, "got %p\n", header);
1460
1461 rc = SendMessageA(hwnd, LVM_GETCOLUMNORDERARRAY, 2, (LPARAM)&order);
1462 ok(rc == 0, "got %d\n", rc);
1463
1464 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
1465 ok(header == NULL, "got %p\n", header);
1466
1467 DestroyWindow(hwnd);
1468
1469 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo", LVS_REPORT,
1470 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
1471 ok(hwnd != NULL, "failed to create listview window\n");
1472
1473 rc = SendMessageA(hwnd, LVM_DELETECOLUMN, -1, 0);
1474 ok(!rc, "got %d\n", rc);
1475
1476 rc = SendMessageA(hwnd, LVM_DELETECOLUMN, 0, 0);
1477 ok(!rc, "got %d\n", rc);
1478
1479 /* Add a column with no mask */
1480 memset(&column, 0xcc, sizeof(column));
1481 column.mask = 0;
1482 rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&column);
1483 ok(rc == 0, "Inserting column with no mask failed with %d\n", rc);
1484
1485 /* Check its width */
1486 rc = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
1487 ok(rc == 10, "Inserting column with no mask failed to set width to 10 with %d\n", rc);
1488
1489 DestroyWindow(hwnd);
1490
1491 /* LVM_GETCOLUMNORDERARRAY */
1492 hwnd = create_listview_control(LVS_REPORT);
1493 subclass_header(hwnd);
1494
1495 memset(&column, 0, sizeof(column));
1496 column.mask = LVCF_WIDTH;
1497 column.cx = 100;
1498 rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&column);
1499 expect(0, rc);
1500
1501 column.cx = 200;
1502 rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 1, (LPARAM)&column);
1503 expect(1, rc);
1504
1505 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1506
1507 rc = SendMessageA(hwnd, LVM_GETCOLUMNORDERARRAY, 2, (LPARAM)&order);
1508 expect(1, rc);
1509 ok(order[0] == 0, "Expected order 0, got %d\n", order[0]);
1510 ok(order[1] == 1, "Expected order 1, got %d\n", order[1]);
1511
1512 rc = SendMessageA(hwnd, LVM_GETCOLUMNORDERARRAY, 0, 0);
1513 expect(0, rc);
1514
1515 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_getorderarray_seq, "get order array", FALSE);
1516
1517 /* LVM_SETCOLUMNORDERARRAY */
1518 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1519
1520 order[0] = 0;
1521 order[1] = 1;
1522 rc = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
1523 expect(1, rc);
1524
1525 rc = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 0, 0);
1526 expect(0, rc);
1527
1528 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_setorderarray_seq, "set order array", FALSE);
1529
1530 /* after column added subitem is considered as present */
1531 insert_item(hwnd, 0);
1532
1533 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1534
1535 item.pszText = buff;
1536 item.cchTextMax = sizeof(buff);
1537 item.iItem = 0;
1538 item.iSubItem = 1;
1539 item.mask = LVIF_TEXT;
1540 memset(&g_itema, 0, sizeof(g_itema));
1541 rc = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
1542 expect(1, rc);
1543 ok(g_itema.iSubItem == 1, "got %d\n", g_itema.iSubItem);
1544
1545 ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
1546 "get subitem text after column added", FALSE);
1547
1548 DestroyWindow(hwnd);
1549 }
1550
1551 /* test setting imagelist between WM_NCCREATE and WM_CREATE */
1552 static WNDPROC listviewWndProc;
1553 static HIMAGELIST test_create_imagelist;
1554
1555 static LRESULT CALLBACK create_test_wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1556 {
1557 LRESULT ret;
1558
1559 if (uMsg == WM_CREATE)
1560 {
1561 CREATESTRUCTA *lpcs = (CREATESTRUCTA*)lParam;
1562 lpcs->style |= LVS_REPORT;
1563 }
1564 ret = CallWindowProcA(listviewWndProc, hwnd, uMsg, wParam, lParam);
1565 if (uMsg == WM_CREATE) SendMessageA(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)test_create_imagelist);
1566 return ret;
1567 }
1568
1569 /* Header creation is delayed in classic implementation. */
1570 #define TEST_NO_HEADER(a) test_header_presence_(a, FALSE, __LINE__)
1571 #define TEST_HEADER_EXPECTED(a) test_header_presence_(a, TRUE, __LINE__)
1572 #define TEST_NO_HEADER2(a, b) test_header_presence_(a, b, __LINE__)
1573 static void test_header_presence_(HWND hwnd, BOOL present, int line)
1574 {
1575 HWND header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
1576
1577 if (present)
1578 {
1579 ok_(__FILE__, line)(IsWindow(header), "Header should have been created.\n");
1580 if (header) /* FIXME: remove when todo's are fixed */
1581 ok_(__FILE__, line)(header == GetDlgItem(hwnd, 0), "Dialog item expected.\n");
1582 }
1583 else
1584 {
1585 ok_(__FILE__, line)(!IsWindow(header), "Header shouldn't be created.\n");
1586 ok_(__FILE__, line)(NULL == GetDlgItem(hwnd, 0), "NULL dialog item expected.\n");
1587 }
1588 }
1589
1590 static void test_create(BOOL is_version_6)
1591 {
1592 static const WCHAR testtextW[] = {'t','e','s','t',' ','t','e','x','t',0};
1593 char buff[16];
1594 HWND hList;
1595 HWND hHeader;
1596 LONG_PTR ret;
1597 LONG r;
1598 LVCOLUMNA col;
1599 RECT rect;
1600 WNDCLASSEXA cls;
1601 DWORD style;
1602 ATOM class;
1603
1604 if (is_win_xp() && is_version_6)
1605 {
1606 win_skip("Skipping some tests on XP.\n");
1607 return;
1608 }
1609
1610 cls.cbSize = sizeof(WNDCLASSEXA);
1611 r = GetClassInfoExA(GetModuleHandleA(NULL), WC_LISTVIEWA, &cls);
1612 ok(r, "Failed to get class info.\n");
1613 listviewWndProc = cls.lpfnWndProc;
1614 cls.lpfnWndProc = create_test_wndproc;
1615 cls.lpszClassName = "MyListView32";
1616 class = RegisterClassExA(&cls);
1617 ok(class, "Failed to register class.\n");
1618
1619 test_create_imagelist = pImageList_Create(16, 16, 0, 5, 10);
1620 hList = CreateWindowA("MyListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL, GetModuleHandleA(NULL), 0);
1621 ok((HIMAGELIST)SendMessageA(hList, LVM_GETIMAGELIST, 0, 0) == test_create_imagelist, "Image list not obtained\n");
1622 hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
1623 ok(IsWindow(hHeader) && IsWindowVisible(hHeader), "Listview not in report mode\n");
1624 ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
1625 DestroyWindow(hList);
1626
1627 /* header isn't created on LVS_ICON and LVS_LIST styles */
1628 hList = CreateWindowA(WC_LISTVIEWA, "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL, GetModuleHandleA(NULL), 0);
1629 TEST_NO_HEADER(hList);
1630
1631 /* insert column */
1632 memset(&col, 0, sizeof(LVCOLUMNA));
1633 col.mask = LVCF_WIDTH;
1634 col.cx = 100;
1635 r = SendMessageA(hList, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
1636 expect(0, r);
1637 TEST_HEADER_EXPECTED(hList);
1638 hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
1639 style = GetWindowLongA(hHeader, GWL_STYLE);
1640 ok(!(style & HDS_HIDDEN), "Not expected HDS_HIDDEN\n");
1641 DestroyWindow(hList);
1642
1643 hList = CreateWindowA(WC_LISTVIEWA, "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
1644 GetModuleHandleA(NULL), 0);
1645 TEST_NO_HEADER(hList);
1646 /* insert column */
1647 memset(&col, 0, sizeof(LVCOLUMNA));
1648 col.mask = LVCF_WIDTH;
1649 col.cx = 100;
1650 r = SendMessageA(hList, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
1651 expect(0, r);
1652 TEST_HEADER_EXPECTED(hList);
1653 DestroyWindow(hList);
1654
1655 /* try to switch LVS_ICON -> LVS_REPORT and back LVS_ICON -> LVS_REPORT */
1656 hList = CreateWindowA(WC_LISTVIEWA, "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
1657 GetModuleHandleA(NULL), 0);
1658 ret = SetWindowLongPtrA(hList, GWL_STYLE, GetWindowLongPtrA(hList, GWL_STYLE) | LVS_REPORT);
1659 ok(ret & WS_VISIBLE, "Style wrong, should have WS_VISIBLE\n");
1660 TEST_HEADER_EXPECTED(hList);
1661 ret = SetWindowLongPtrA(hList, GWL_STYLE, GetWindowLongA(hList, GWL_STYLE) & ~LVS_REPORT);
1662 ok((ret & WS_VISIBLE) && (ret & LVS_REPORT), "Style wrong, should have WS_VISIBLE|LVS_REPORT\n");
1663 TEST_HEADER_EXPECTED(hList);
1664 DestroyWindow(hList);
1665
1666 /* try to switch LVS_LIST -> LVS_REPORT and back LVS_LIST -> LVS_REPORT */
1667 hList = CreateWindowA(WC_LISTVIEWA, "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
1668 GetModuleHandleA(NULL), 0);
1669 ret = SetWindowLongPtrA(hList, GWL_STYLE,
1670 (GetWindowLongPtrA(hList, GWL_STYLE) & ~LVS_LIST) | LVS_REPORT);
1671 ok(((ret & WS_VISIBLE) && (ret & LVS_LIST)), "Style wrong, should have WS_VISIBLE|LVS_LIST\n");
1672 TEST_HEADER_EXPECTED(hList);
1673 ret = SetWindowLongPtrA(hList, GWL_STYLE, (GetWindowLongPtrA(hList, GWL_STYLE) & ~LVS_REPORT) | LVS_LIST);
1674 ok(((ret & WS_VISIBLE) && (ret & LVS_REPORT)), "Style wrong, should have WS_VISIBLE|LVS_REPORT\n");
1675 TEST_HEADER_EXPECTED(hList);
1676 DestroyWindow(hList);
1677
1678 /* LVS_REPORT without WS_VISIBLE */
1679 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1680 GetModuleHandleA(NULL), 0);
1681 hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
1682 todo_wine_if(is_version_6)
1683 TEST_NO_HEADER2(hList, is_version_6);
1684
1685 /* insert column */
1686 memset(&col, 0, sizeof(LVCOLUMNA));
1687 col.mask = LVCF_WIDTH;
1688 col.cx = 100;
1689 r = SendMessageA(hList, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
1690 expect(0, r);
1691 TEST_HEADER_EXPECTED(hList);
1692 DestroyWindow(hList);
1693
1694 /* LVS_REPORT without WS_VISIBLE, try to show it */
1695 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1696 GetModuleHandleA(NULL), 0);
1697 todo_wine_if(is_version_6)
1698 TEST_NO_HEADER2(hList, is_version_6);
1699
1700 ShowWindow(hList, SW_SHOW);
1701 TEST_HEADER_EXPECTED(hList);
1702 DestroyWindow(hList);
1703
1704 /* LVS_REPORT with LVS_NOCOLUMNHEADER */
1705 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT|LVS_NOCOLUMNHEADER|WS_VISIBLE,
1706 0, 0, 100, 100, NULL, NULL, GetModuleHandleA(NULL), 0);
1707 TEST_HEADER_EXPECTED(hList);
1708 hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
1709 /* HDS_DRAGDROP set by default */
1710 ok(GetWindowLongPtrA(hHeader, GWL_STYLE) & HDS_DRAGDROP, "Expected header to have HDS_DRAGDROP\n");
1711 DestroyWindow(hList);
1712
1713 /* setting LVS_EX_HEADERDRAGDROP creates header */
1714 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1715 GetModuleHandleA(NULL), 0);
1716 todo_wine_if(is_version_6)
1717 TEST_NO_HEADER2(hList, is_version_6);
1718
1719 SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
1720 TEST_HEADER_EXPECTED(hList);
1721 DestroyWindow(hList);
1722
1723 /* setting LVS_EX_GRIDLINES creates header */
1724 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1725 GetModuleHandleA(NULL), 0);
1726 todo_wine_if(is_version_6)
1727 TEST_NO_HEADER2(hList, is_version_6);
1728
1729 SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRIDLINES);
1730 TEST_HEADER_EXPECTED(hList);
1731 DestroyWindow(hList);
1732
1733 /* setting LVS_EX_FULLROWSELECT creates header */
1734 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1735 GetModuleHandleA(NULL), 0);
1736 todo_wine_if(is_version_6)
1737 TEST_NO_HEADER2(hList, is_version_6);
1738 SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
1739 TEST_HEADER_EXPECTED(hList);
1740 DestroyWindow(hList);
1741
1742 /* not report style accepts LVS_EX_HEADERDRAGDROP too */
1743 hList = create_listview_control(LVS_ICON);
1744 SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
1745 r = SendMessageA(hList, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
1746 ok(r & LVS_EX_HEADERDRAGDROP, "Expected LVS_EX_HEADERDRAGDROP to be set\n");
1747 DestroyWindow(hList);
1748
1749 /* requesting header info with LVM_GETSUBITEMRECT doesn't create it */
1750 hList = CreateWindowA(WC_LISTVIEWA, "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
1751 GetModuleHandleA(NULL), 0);
1752 todo_wine_if(is_version_6)
1753 TEST_NO_HEADER2(hList, is_version_6);
1754
1755 SetRect(&rect, LVIR_BOUNDS, 1, -10, -10);
1756 r = SendMessageA(hList, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
1757 ok(r == 1, "Unexpected ret value %d.\n", r);
1758 /* right value contains garbage, probably because header columns are not set up */
1759 ok(rect.bottom >= 0, "Unexpected rectangle.\n");
1760
1761 todo_wine_if(is_version_6)
1762 TEST_NO_HEADER2(hList, is_version_6);
1763 DestroyWindow(hList);
1764
1765 /* WM_MEASUREITEM should be sent when created with LVS_OWNERDRAWFIXED */
1766 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1767 hList = create_listview_control(LVS_OWNERDRAWFIXED | LVS_REPORT);
1768 ok_sequence(sequences, PARENT_SEQ_INDEX, create_ownerdrawfixed_parent_seq,
1769 "created with LVS_OWNERDRAWFIXED|LVS_REPORT - parent seq", FALSE);
1770 DestroyWindow(hList);
1771
1772 /* Test that window text is preserved. */
1773 hList = CreateWindowExA(0, WC_LISTVIEWA, "test text", WS_CHILD | WS_BORDER | WS_VISIBLE,
1774 0, 0, 100, 100, hwndparent, NULL, GetModuleHandleA(NULL), NULL);
1775 ok(hList != NULL, "Failed to create ListView window.\n");
1776 *buff = 0;
1777 GetWindowTextA(hList, buff, sizeof(buff));
1778 ok(!strcmp(buff, "test text"), "Unexpected window text %s.\n", buff);
1779 DestroyWindow(hList);
1780
1781 hList = CreateWindowExW(0, WC_LISTVIEWW, testtextW, WS_CHILD | WS_BORDER | WS_VISIBLE,
1782 0, 0, 100, 100, hwndparent, NULL, GetModuleHandleA(NULL), NULL);
1783 ok(hList != NULL, "Failed to create ListView window.\n");
1784 *buff = 0;
1785 GetWindowTextA(hList, buff, sizeof(buff));
1786 ok(!strcmp(buff, "test text"), "Unexpected window text %s.\n", buff);
1787 DestroyWindow(hList);
1788
1789 r = UnregisterClassA("MyListView32", NULL);
1790 ok(r, "Failed to unregister test class.\n");
1791 }
1792
1793 static void test_redraw(void)
1794 {
1795 HWND hwnd;
1796 HDC hdc;
1797 BOOL res;
1798 DWORD r;
1799 RECT rect;
1800
1801 hwnd = create_listview_control(LVS_REPORT);
1802 subclass_header(hwnd);
1803
1804 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1805
1806 InvalidateRect(hwnd, NULL, TRUE);
1807 UpdateWindow(hwnd);
1808 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, redraw_listview_seq, "redraw listview", FALSE);
1809
1810 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1811
1812 /* forward WM_ERASEBKGND to parent on CLR_NONE background color */
1813 /* 1. Without backbuffer */
1814 res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
1815 expect(TRUE, res);
1816
1817 hdc = GetWindowDC(hwndparent);
1818
1819 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1820 r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1821 ok(r == 1, "Expected not zero result\n");
1822 ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, forward_erasebkgnd_parent_seq,
1823 "forward WM_ERASEBKGND on CLR_NONE", FALSE);
1824
1825 res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_DEFAULT);
1826 expect(TRUE, res);
1827
1828 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1829 r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1830 expect(1, r);
1831 ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, empty_seq,
1832 "don't forward WM_ERASEBKGND on non-CLR_NONE", FALSE);
1833
1834 /* 2. With backbuffer */
1835 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_DOUBLEBUFFER,
1836 LVS_EX_DOUBLEBUFFER);
1837 res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
1838 expect(TRUE, res);
1839
1840 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1841 r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1842 expect(1, r);
1843 ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, forward_erasebkgnd_parent_seq,
1844 "forward WM_ERASEBKGND on CLR_NONE", FALSE);
1845
1846 res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_DEFAULT);
1847 expect(TRUE, res);
1848
1849 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1850 r = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
1851 todo_wine expect(1, r);
1852 ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, empty_seq,
1853 "don't forward WM_ERASEBKGND on non-CLR_NONE", FALSE);
1854
1855 ReleaseDC(hwndparent, hdc);
1856
1857 /* test setting the window style to what it already was */
1858 UpdateWindow(hwnd);
1859 SetWindowLongA(hwnd, GWL_STYLE, GetWindowLongA(hwnd, GWL_STYLE));
1860 GetUpdateRect(hwnd, &rect, FALSE);
1861 ok(rect.left == 0 && rect.top == 0 && rect.right == 0 && rect.bottom == 0,
1862 "Expected empty update rect, got %s\n", wine_dbgstr_rect(&rect));
1863
1864 DestroyWindow(hwnd);
1865 }
1866
1867 static LRESULT WINAPI cd_wndproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1868 {
1869 COLORREF clr, c0ffee = RGB(0xc0, 0xff, 0xee);
1870
1871 if(message == WM_NOTIFY) {
1872 NMHDR *nmhdr = (NMHDR*)lParam;
1873 if(nmhdr->code == NM_CUSTOMDRAW) {
1874 NMLVCUSTOMDRAW *nmlvcd = (NMLVCUSTOMDRAW*)nmhdr;
1875 struct message msg;
1876
1877 msg.message = message;
1878 msg.flags = sent|wparam|lparam|custdraw;
1879 msg.wParam = wParam;
1880 msg.lParam = lParam;
1881 msg.id = nmhdr->code;
1882 msg.stage = nmlvcd->nmcd.dwDrawStage;
1883 add_message(sequences, PARENT_CD_SEQ_INDEX, &msg);
1884
1885 switch(nmlvcd->nmcd.dwDrawStage) {
1886 case CDDS_PREPAINT:
1887 SetBkColor(nmlvcd->nmcd.hdc, c0ffee);
1888 return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYPOSTPAINT;
1889 case CDDS_ITEMPREPAINT:
1890 nmlvcd->clrTextBk = CLR_DEFAULT;
1891 nmlvcd->clrText = RGB(0, 255, 0);
1892 return CDRF_NOTIFYSUBITEMDRAW|CDRF_NOTIFYPOSTPAINT;
1893 case CDDS_ITEMPREPAINT | CDDS_SUBITEM:
1894 clr = GetBkColor(nmlvcd->nmcd.hdc);
1895 ok(nmlvcd->clrTextBk == CLR_DEFAULT, "got 0x%x\n", nmlvcd->clrTextBk);
1896 ok(nmlvcd->clrText == RGB(0, 255, 0), "got 0x%x\n", nmlvcd->clrText);
1897 if (!(GetWindowLongW(nmhdr->hwndFrom, GWL_STYLE) & LVS_SHOWSELALWAYS))
1898 {
1899 todo_wine_if(nmlvcd->iSubItem)
1900 ok(clr == c0ffee, "clr=%.8x\n", clr);
1901 }
1902 return CDRF_NOTIFYPOSTPAINT;
1903 case CDDS_ITEMPOSTPAINT | CDDS_SUBITEM:
1904 clr = GetBkColor(nmlvcd->nmcd.hdc);
1905 if (!(GetWindowLongW(nmhdr->hwndFrom, GWL_STYLE) & LVS_SHOWSELALWAYS))
1906 todo_wine ok(clr == c0ffee, "clr=%.8x\n", clr);
1907 ok(nmlvcd->clrTextBk == CLR_DEFAULT, "got 0x%x\n", nmlvcd->clrTextBk);
1908 ok(nmlvcd->clrText == RGB(0, 255, 0), "got 0x%x\n", nmlvcd->clrText);
1909 return CDRF_DODEFAULT;
1910 }
1911 return CDRF_DODEFAULT;
1912 }
1913 }
1914
1915 return DefWindowProcA(hwnd, message, wParam, lParam);
1916 }
1917
1918 static void test_customdraw(void)
1919 {
1920 HWND hwnd;
1921 WNDPROC oldwndproc;
1922 LVITEMA item;
1923
1924 hwnd = create_listview_control(LVS_REPORT);
1925
1926 insert_column(hwnd, 0);
1927 insert_column(hwnd, 1);
1928 insert_item(hwnd, 0);
1929
1930 oldwndproc = (WNDPROC)SetWindowLongPtrA(hwndparent, GWLP_WNDPROC,
1931 (LONG_PTR)cd_wndproc);
1932
1933 InvalidateRect(hwnd, NULL, TRUE);
1934 UpdateWindow(hwnd);
1935
1936 /* message tests */
1937 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1938 InvalidateRect(hwnd, NULL, TRUE);
1939 UpdateWindow(hwnd);
1940 ok_sequence(sequences, PARENT_CD_SEQ_INDEX, parent_report_cd_seq, "parent customdraw, LVS_REPORT", FALSE);
1941
1942 /* check colors when item is selected */
1943 SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) | LVS_SHOWSELALWAYS);
1944 item.mask = LVIF_STATE;
1945 item.stateMask = LVIS_SELECTED;
1946 item.state = LVIS_SELECTED;
1947 SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
1948
1949 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1950 InvalidateRect(hwnd, NULL, TRUE);
1951 UpdateWindow(hwnd);
1952 ok_sequence(sequences, PARENT_CD_SEQ_INDEX, parent_report_cd_seq, "parent customdraw, LVS_REPORT, selection", FALSE);
1953
1954 DestroyWindow(hwnd);
1955
1956 hwnd = create_listview_control(LVS_LIST);
1957
1958 insert_column(hwnd, 0);
1959 insert_column(hwnd, 1);
1960 insert_item(hwnd, 0);
1961
1962 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1963 InvalidateRect(hwnd, NULL, TRUE);
1964 UpdateWindow(hwnd);
1965 ok_sequence(sequences, PARENT_CD_SEQ_INDEX, parent_list_cd_seq, "parent customdraw, LVS_LIST", FALSE);
1966
1967 SetWindowLongPtrA(hwndparent, GWLP_WNDPROC, (LONG_PTR)oldwndproc);
1968 DestroyWindow(hwnd);
1969 }
1970
1971 static void test_icon_spacing(void)
1972 {
1973 /* LVM_SETICONSPACING */
1974 /* note: LVM_SETICONSPACING returns the previous icon spacing if successful */
1975
1976 HWND hwnd;
1977 WORD w, h;
1978 INT r;
1979
1980 hwnd = create_listview_control(LVS_ICON);
1981 ok(hwnd != NULL, "failed to create a listview window\n");
1982
1983 r = SendMessageA(hwnd, WM_NOTIFYFORMAT, (WPARAM)hwndparent, NF_REQUERY);
1984 expect(NFR_ANSI, r);
1985
1986 /* reset the icon spacing to defaults */
1987 SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
1988
1989 /* now we can request what the defaults are */
1990 r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
1991 w = LOWORD(r);
1992 h = HIWORD(r);
1993
1994 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1995
1996 r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(20, 30));
1997 ok(r == MAKELONG(w, h) ||
1998 broken(r == MAKELONG(w, w)), /* win98 */
1999 "Expected %d, got %d\n", MAKELONG(w, h), r);
2000
2001 r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(25, 35));
2002 expect(MAKELONG(20,30), r);
2003
2004 r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1,-1));
2005 expect(MAKELONG(25,35), r);
2006
2007 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_icon_spacing_seq, "test icon spacing seq", FALSE);
2008
2009 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2010 DestroyWindow(hwnd);
2011 }
2012
2013 static void test_color(void)
2014 {
2015 RECT rect;
2016 HWND hwnd;
2017 DWORD r;
2018 int i;
2019
2020 COLORREF color;
2021 COLORREF colors[4] = {RGB(0,0,0), RGB(100,50,200), CLR_NONE, RGB(255,255,255)};
2022
2023 hwnd = create_listview_control(LVS_REPORT);
2024 ok(hwnd != NULL, "failed to create a listview window\n");
2025
2026 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2027
2028 for (i = 0; i < 4; i++)
2029 {
2030 color = colors[i];
2031
2032 r = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, color);
2033 expect(TRUE, r);
2034 r = SendMessageA(hwnd, LVM_GETBKCOLOR, 0, 0);
2035 expect(color, r);
2036
2037 r = SendMessageA(hwnd, LVM_SETTEXTCOLOR, 0, color);
2038 expect (TRUE, r);
2039 r = SendMessageA(hwnd, LVM_GETTEXTCOLOR, 0, 0);
2040 expect(color, r);
2041
2042 r = SendMessageA(hwnd, LVM_SETTEXTBKCOLOR, 0, color);
2043 expect(TRUE, r);
2044 r = SendMessageA(hwnd, LVM_GETTEXTBKCOLOR, 0, 0);
2045 expect(color, r);
2046 }
2047
2048 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_color_seq, "test color seq", FALSE);
2049 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2050
2051 /* invalidation test done separately to avoid a message chain mess */
2052 r = ValidateRect(hwnd, NULL);
2053 expect(TRUE, r);
2054 r = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, colors[0]);
2055 expect(TRUE, r);
2056
2057 rect.right = rect.bottom = 1;
2058 r = GetUpdateRect(hwnd, &rect, TRUE);
2059 todo_wine expect(FALSE, r);
2060 ok(rect.right == 0 && rect.bottom == 0, "got update rectangle\n");
2061
2062 r = ValidateRect(hwnd, NULL);
2063 expect(TRUE, r);
2064 r = SendMessageA(hwnd, LVM_SETTEXTCOLOR, 0, colors[0]);
2065 expect(TRUE, r);
2066
2067 rect.right = rect.bottom = 1;
2068 r = GetUpdateRect(hwnd, &rect, TRUE);
2069 todo_wine expect(FALSE, r);
2070 ok(rect.right == 0 && rect.bottom == 0, "got update rectangle\n");
2071
2072 r = ValidateRect(hwnd, NULL);
2073 expect(TRUE, r);
2074 r = SendMessageA(hwnd, LVM_SETTEXTBKCOLOR, 0, colors[0]);
2075 expect(TRUE, r);
2076
2077 rect.right = rect.bottom = 1;
2078 r = GetUpdateRect(hwnd, &rect, TRUE);
2079 todo_wine expect(FALSE, r);
2080 ok(rect.right == 0 && rect.bottom == 0, "got update rectangle\n");
2081
2082 DestroyWindow(hwnd);
2083 }
2084
2085 static void test_item_count(void)
2086 {
2087 /* LVM_INSERTITEM, LVM_DELETEITEM, LVM_DELETEALLITEMS, LVM_GETITEMCOUNT */
2088
2089 HWND hwnd;
2090 DWORD r;
2091 HDC hdc;
2092 HFONT hOldFont;
2093 TEXTMETRICA tm;
2094 RECT rect;
2095 INT height;
2096
2097 LVITEMA item0;
2098 LVITEMA item1;
2099 LVITEMA item2;
2100 static CHAR item0text[] = "item0";
2101 static CHAR item1text[] = "item1";
2102 static CHAR item2text[] = "item2";
2103
2104 hwnd = create_listview_control(LVS_REPORT);
2105 ok(hwnd != NULL, "failed to create a listview window\n");
2106
2107 /* resize in dpiaware manner to fit all 3 items added */
2108 hdc = GetDC(0);
2109 hOldFont = SelectObject(hdc, GetStockObject(SYSTEM_FONT));
2110 GetTextMetricsA(hdc, &tm);
2111 /* 2 extra pixels for bounds and header border */
2112 height = tm.tmHeight + 2;
2113 SelectObject(hdc, hOldFont);
2114 ReleaseDC(0, hdc);
2115
2116 GetWindowRect(hwnd, &rect);
2117 /* 3 items + 1 header + 1 to be sure */
2118 MoveWindow(hwnd, 0, 0, rect.right - rect.left, 5 * height, FALSE);
2119
2120 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2121
2122 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2123 expect(0, r);
2124
2125 /* [item0] */
2126 item0.mask = LVIF_TEXT;
2127 item0.iItem = 0;
2128 item0.iSubItem = 0;
2129 item0.pszText = item0text;
2130 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item0);
2131 expect(0, r);
2132
2133 /* [item0, item1] */
2134 item1.mask = LVIF_TEXT;
2135 item1.iItem = 1;
2136 item1.iSubItem = 0;
2137 item1.pszText = item1text;
2138 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
2139 expect(1, r);
2140
2141 /* [item0, item1, item2] */
2142 item2.mask = LVIF_TEXT;
2143 item2.iItem = 2;
2144 item2.iSubItem = 0;
2145 item2.pszText = item2text;
2146 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item2);
2147 expect(2, r);
2148
2149 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2150 expect(3, r);
2151
2152 /* [item0, item1] */
2153 r = SendMessageA(hwnd, LVM_DELETEITEM, 2, 0);
2154 expect(TRUE, r);
2155
2156 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2157 expect(2, r);
2158
2159 /* [] */
2160 r = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
2161 expect(TRUE, r);
2162
2163 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2164 expect(0, r);
2165
2166 /* [item0] */
2167 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
2168 expect(0, r);
2169
2170 /* [item0, item1] */
2171 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
2172 expect(1, r);
2173
2174 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2175 expect(2, r);
2176
2177 /* [item0, item1, item2] */
2178 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item2);
2179 expect(2, r);
2180
2181 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2182 expect(3, r);
2183
2184 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_item_count_seq, "test item count seq", FALSE);
2185
2186 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2187 DestroyWindow(hwnd);
2188 }
2189
2190 static void test_item_position(void)
2191 {
2192 /* LVM_SETITEMPOSITION/LVM_GETITEMPOSITION */
2193
2194 HWND hwnd;
2195 DWORD r;
2196 POINT position;
2197
2198 LVITEMA item0;
2199 LVITEMA item1;
2200 LVITEMA item2;
2201 static CHAR item0text[] = "item0";
2202 static CHAR item1text[] = "item1";
2203 static CHAR item2text[] = "item2";
2204
2205 hwnd = create_listview_control(LVS_ICON);
2206 ok(hwnd != NULL, "failed to create a listview window\n");
2207
2208 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2209
2210 /* [item0] */
2211 item0.mask = LVIF_TEXT;
2212 item0.iItem = 0;
2213 item0.iSubItem = 0;
2214 item0.pszText = item0text;
2215 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item0);
2216 expect(0, r);
2217
2218 /* [item0, item1] */
2219 item1.mask = LVIF_TEXT;
2220 item1.iItem = 1;
2221 item1.iSubItem = 0;
2222 item1.pszText = item1text;
2223 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
2224 expect(1, r);
2225
2226 /* [item0, item1, item2] */
2227 item2.mask = LVIF_TEXT;
2228 item2.iItem = 2;
2229 item2.iSubItem = 0;
2230 item2.pszText = item2text;
2231 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item2);
2232 expect(2, r);
2233
2234 r = SendMessageA(hwnd, LVM_SETITEMPOSITION, 1, MAKELPARAM(10,5));
2235 expect(TRUE, r);
2236 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 1, (LPARAM) &position);
2237 expect(TRUE, r);
2238 expect2(10, 5, position.x, position.y);
2239
2240 r = SendMessageA(hwnd, LVM_SETITEMPOSITION, 2, MAKELPARAM(0,0));
2241 expect(TRUE, r);
2242 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 2, (LPARAM) &position);
2243 expect(TRUE, r);
2244 expect2(0, 0, position.x, position.y);
2245
2246 r = SendMessageA(hwnd, LVM_SETITEMPOSITION, 0, MAKELPARAM(20,20));
2247 expect(TRUE, r);
2248 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM) &position);
2249 expect(TRUE, r);
2250 expect2(20, 20, position.x, position.y);
2251
2252 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_itempos_seq, "test item position seq", TRUE);
2253
2254 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2255 DestroyWindow(hwnd);
2256 }
2257
2258 static void test_getorigin(void)
2259 {
2260 /* LVM_GETORIGIN */
2261
2262 HWND hwnd;
2263 DWORD r;
2264 POINT position;
2265
2266 position.x = position.y = 0;
2267
2268 hwnd = create_listview_control(LVS_ICON);
2269 ok(hwnd != NULL, "failed to create a listview window\n");
2270 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2271
2272 r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
2273 expect(TRUE, r);
2274 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2275 DestroyWindow(hwnd);
2276
2277 hwnd = create_listview_control(LVS_SMALLICON);
2278 ok(hwnd != NULL, "failed to create a listview window\n");
2279 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2280
2281 r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
2282 expect(TRUE, r);
2283 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2284 DestroyWindow(hwnd);
2285
2286 hwnd = create_listview_control(LVS_LIST);
2287 ok(hwnd != NULL, "failed to create a listview window\n");
2288 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2289
2290 r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
2291 expect(FALSE, r);
2292 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2293 DestroyWindow(hwnd);
2294
2295 hwnd = create_listview_control(LVS_REPORT);
2296 ok(hwnd != NULL, "failed to create a listview window\n");
2297 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2298
2299 r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
2300 expect(FALSE, r);
2301 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2302 DestroyWindow(hwnd);
2303 }
2304
2305 static void test_multiselect(void)
2306 {
2307 typedef struct t_select_task
2308 {
2309 const char *descr;
2310 int initPos;
2311 int loopVK;
2312 int count;
2313 int result;
2314 } select_task;
2315
2316 HWND hwnd;
2317 INT r;
2318 int i, j;
2319 static const int items=5;
2320 DWORD item_count;
2321 BYTE kstate[256];
2322 select_task task;
2323 LONG_PTR style;
2324 LVITEMA item;
2325
2326 static struct t_select_task task_list[] = {
2327 { "using VK_DOWN", 0, VK_DOWN, -1, -1 },
2328 { "using VK_UP", -1, VK_UP, -1, -1 },
2329 { "using VK_END", 0, VK_END, 1, -1 },
2330 { "using VK_HOME", -1, VK_HOME, 1, -1 }
2331 };
2332
2333 hwnd = create_listview_control(LVS_REPORT);
2334
2335 for (i = 0; i < items; i++)
2336 insert_item(hwnd, 0);
2337
2338 item_count = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2339 expect(items, item_count);
2340
2341 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2342 ok(r == -1, "got %d\n", r);
2343
2344 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, 0);
2345 ok(r == -1, "got %d\n", r);
2346
2347 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, 0);
2348 ok(r == 0, "got %d\n", r);
2349
2350 /* out of range index */
2351 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, items);
2352 ok(r == 0, "got %d\n", r);
2353
2354 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2355 ok(r == 0, "got %d\n", r);
2356
2357 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -2);
2358 ok(r == 0, "got %d\n", r);
2359
2360 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2361 ok(r == 0, "got %d\n", r);
2362
2363 for (i = 0; i < ARRAY_SIZE(task_list); i++) {
2364 DWORD selected_count;
2365 LVITEMA item;
2366
2367 task = task_list[i];
2368
2369 /* deselect all items */
2370 item.state = 0;
2371 item.stateMask = LVIS_SELECTED;
2372 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2373 ok(r, "got %d\n", r);
2374 SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2375
2376 /* set initial position */
2377 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, (task.initPos == -1 ? item_count -1 : task.initPos));
2378 ok(r, "got %d\n", r);
2379
2380 item.state = LVIS_SELECTED;
2381 item.stateMask = LVIS_SELECTED;
2382 r = SendMessageA(hwnd, LVM_SETITEMSTATE, task.initPos == -1 ? item_count-1 : task.initPos, (LPARAM)&item);
2383 ok(r, "got %d\n", r);
2384
2385 selected_count = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2386 ok(selected_count == 1, "expected 1, got %d\n", selected_count);
2387
2388 /* Set SHIFT key pressed */
2389 GetKeyboardState(kstate);
2390 kstate[VK_SHIFT]=0x80;
2391 SetKeyboardState(kstate);
2392
2393 for (j=1;j<=(task.count == -1 ? item_count : task.count);j++) {
2394 r = SendMessageA(hwnd, WM_KEYDOWN, task.loopVK, 0);
2395 expect(0,r);
2396 r = SendMessageA(hwnd, WM_KEYUP, task.loopVK, 0);
2397 expect(0,r);
2398 }
2399
2400 selected_count = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2401
2402 ok((task.result == -1 ? item_count : task.result) == selected_count,
2403 "Failed multiple selection %s. There should be %d selected items (is %d)\n",
2404 task.descr, item_count, selected_count);
2405
2406 /* Set SHIFT key released */
2407 GetKeyboardState(kstate);
2408 kstate[VK_SHIFT]=0x00;
2409 SetKeyboardState(kstate);
2410 }
2411 DestroyWindow(hwnd);
2412
2413 /* make multiple selection, then switch to LVS_SINGLESEL */
2414 hwnd = create_listview_control(LVS_REPORT);
2415 for (i=0;i<items;i++) {
2416 insert_item(hwnd, 0);
2417 }
2418 item_count = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
2419 expect(items,item_count);
2420
2421 /* try with NULL pointer */
2422 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, 0);
2423 expect(FALSE, r);
2424
2425 /* select all, check notifications */
2426 item.state = 0;
2427 item.stateMask = LVIS_SELECTED;
2428 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2429 ok(r, "got %d\n", r);
2430
2431 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2432
2433 item.stateMask = LVIS_SELECTED;
2434 item.state = LVIS_SELECTED;
2435 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2436 expect(TRUE, r);
2437
2438 ok_sequence(sequences, PARENT_SEQ_INDEX, change_all_parent_seq,
2439 "select all notification", FALSE);
2440
2441 /* select all again (all selected already) */
2442 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2443
2444 memset(&g_nmlistview_changing, 0xcc, sizeof(g_nmlistview_changing));
2445
2446 item.stateMask = LVIS_SELECTED;
2447 item.state = LVIS_SELECTED;
2448 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2449 expect(TRUE, r);
2450
2451 ok(g_nmlistview_changing.uNewState == LVIS_SELECTED, "got 0x%x\n", g_nmlistview_changing.uNewState);
2452 ok(g_nmlistview_changing.uOldState == LVIS_SELECTED, "got 0x%x\n", g_nmlistview_changing.uOldState);
2453 ok(g_nmlistview_changing.uChanged == LVIF_STATE, "got 0x%x\n", g_nmlistview_changing.uChanged);
2454
2455 ok_sequence(sequences, PARENT_SEQ_INDEX, changing_all_parent_seq,
2456 "select all notification 2", FALSE);
2457
2458 /* deselect all items */
2459 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2460
2461 item.state = 0;
2462 item.stateMask = LVIS_SELECTED;
2463 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2464 ok(r, "got %d\n", r);
2465
2466 ok_sequence(sequences, PARENT_SEQ_INDEX, change_all_parent_seq,
2467 "deselect all notification", FALSE);
2468
2469 /* deselect all items again */
2470 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2471 item.state = 0;
2472 item.stateMask = LVIS_SELECTED;
2473 SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2474 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "deselect all notification 2", FALSE);
2475
2476 /* any non-zero state value does the same */
2477 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2478
2479 memset(&g_nmlistview_changing, 0xcc, sizeof(g_nmlistview_changing));
2480
2481 item.stateMask = LVIS_SELECTED;
2482 item.state = LVIS_CUT;
2483 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2484 expect(TRUE, r);
2485
2486 ok(g_nmlistview_changing.uNewState == 0, "got 0x%x\n", g_nmlistview_changing.uNewState);
2487 ok(g_nmlistview_changing.uOldState == 0, "got 0x%x\n", g_nmlistview_changing.uOldState);
2488 ok(g_nmlistview_changing.uChanged == LVIF_STATE, "got 0x%x\n", g_nmlistview_changing.uChanged);
2489
2490 ok_sequence(sequences, PARENT_SEQ_INDEX, changing_all_parent_seq,
2491 "set state all notification 3", FALSE);
2492
2493 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2494 ok(r, "got %d\n", r);
2495 for (i = 0; i < 3; i++) {
2496 item.state = LVIS_SELECTED;
2497 item.stateMask = LVIS_SELECTED;
2498 r = SendMessageA(hwnd, LVM_SETITEMSTATE, i, (LPARAM)&item);
2499 ok(r, "got %d\n", r);
2500 }
2501
2502 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2503 expect(3, r);
2504 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2505 expect(-1, r);
2506
2507 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2508 ok(!(style & LVS_SINGLESEL), "LVS_SINGLESEL isn't expected\n");
2509 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SINGLESEL);
2510 /* check that style is accepted */
2511 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2512 ok(style & LVS_SINGLESEL, "LVS_SINGLESEL expected\n");
2513
2514 for (i=0;i<3;i++) {
2515 r = SendMessageA(hwnd, LVM_GETITEMSTATE, i, LVIS_SELECTED);
2516 ok(r & LVIS_SELECTED, "Expected item %d to be selected\n", i);
2517 }
2518 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2519 expect(3, r);
2520 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2521 ok(r == -1, "got %d\n", r);
2522
2523 /* select one more */
2524 item.state = LVIS_SELECTED;
2525 item.stateMask = LVIS_SELECTED;
2526 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 3, (LPARAM)&item);
2527 ok(r, "got %d\n", r);
2528
2529 for (i=0;i<3;i++) {
2530 r = SendMessageA(hwnd, LVM_GETITEMSTATE, i, LVIS_SELECTED);
2531 ok(!(r & LVIS_SELECTED), "Expected item %d to be unselected\n", i);
2532 }
2533
2534 r = SendMessageA(hwnd, LVM_GETITEMSTATE, 3, LVIS_SELECTED);
2535 ok(r & LVIS_SELECTED, "Expected item %d to be selected\n", i);
2536
2537 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2538 expect(1, r);
2539 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2540 expect(-1, r);
2541
2542 /* try to select all on LVS_SINGLESEL */
2543 memset(&item, 0, sizeof(item));
2544 item.stateMask = LVIS_SELECTED;
2545 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2546 expect(TRUE, r);
2547 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2548 ok(r == -1, "got %d\n", r);
2549
2550 item.stateMask = LVIS_SELECTED;
2551 item.state = LVIS_SELECTED;
2552 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2553 expect(FALSE, r);
2554
2555 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2556 expect(0, r);
2557 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2558 expect(-1, r);
2559
2560 /* try to deselect all on LVS_SINGLESEL */
2561 item.stateMask = LVIS_SELECTED;
2562 item.state = LVIS_SELECTED;
2563 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2564 expect(TRUE, r);
2565
2566 item.stateMask = LVIS_SELECTED;
2567 item.state = 0;
2568 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2569 expect(TRUE, r);
2570 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2571 expect(0, r);
2572
2573 /* 1. selection mark is update when new focused item is set */
2574 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2575 SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_SINGLESEL);
2576
2577 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2578 expect(-1, r);
2579
2580 item.stateMask = LVIS_FOCUSED;
2581 item.state = LVIS_FOCUSED;
2582 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
2583 expect(TRUE, r);
2584
2585 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2586 expect(0, r);
2587
2588 /* it's not updated if already set */
2589 item.stateMask = LVIS_FOCUSED;
2590 item.state = LVIS_FOCUSED;
2591 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 1, (LPARAM)&item);
2592 expect(TRUE, r);
2593
2594 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2595 expect(0, r);
2596
2597 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2598 expect(0, r);
2599
2600 item.stateMask = LVIS_FOCUSED;
2601 item.state = LVIS_FOCUSED;
2602 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 1, (LPARAM)&item);
2603 expect(TRUE, r);
2604
2605 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2606 expect(-1, r);
2607
2608 /* need to reset focused item first */
2609 item.stateMask = LVIS_FOCUSED;
2610 item.state = 0;
2611 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2612 expect(TRUE, r);
2613
2614 item.stateMask = LVIS_FOCUSED;
2615 item.state = LVIS_FOCUSED;
2616 r = SendMessageA(hwnd, LVM_SETITEMSTATE, 2, (LPARAM)&item);
2617 expect(TRUE, r);
2618
2619 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2620 expect(2, r);
2621
2622 item.stateMask = LVIS_FOCUSED;
2623 item.state = 0;
2624 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2625 expect(TRUE, r);
2626
2627 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2628 expect(2, r);
2629
2630 /* 2. same tests, with LVM_SETITEM */
2631 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2632 SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_SINGLESEL);
2633
2634 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2635 expect(2, r);
2636
2637 item.stateMask = LVIS_FOCUSED;
2638 item.state = LVIS_FOCUSED;
2639 item.mask = LVIF_STATE;
2640 item.iItem = item.iSubItem = 0;
2641 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
2642 expect(TRUE, r);
2643
2644 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2645 expect(0, r);
2646
2647 /* it's not updated if already set */
2648 item.stateMask = LVIS_FOCUSED;
2649 item.state = LVIS_FOCUSED;
2650 item.mask = LVIF_STATE;
2651 item.iItem = 1;
2652 item.iSubItem = 0;
2653 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
2654 expect(TRUE, r);
2655
2656 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2657 expect(0, r);
2658
2659 r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
2660 expect(0, r);
2661
2662 item.stateMask = LVIS_FOCUSED;
2663 item.state = LVIS_FOCUSED;
2664 item.mask = LVIF_STATE;
2665 item.iItem = 1;
2666 item.iSubItem = 0;
2667 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
2668 expect(TRUE, r);
2669
2670 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2671 expect(-1, r);
2672
2673 /* need to reset focused item first */
2674 item.stateMask = LVIS_FOCUSED;
2675 item.state = 0;
2676 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2677 expect(TRUE, r);
2678
2679 item.stateMask = LVIS_FOCUSED;
2680 item.state = LVIS_FOCUSED;
2681 item.mask = LVIF_STATE;
2682 item.iItem = 2;
2683 item.iSubItem = 0;
2684 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
2685 expect(TRUE, r);
2686
2687 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2688 expect(2, r);
2689
2690 item.stateMask = LVIS_FOCUSED;
2691 item.state = 0;
2692 r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
2693 expect(TRUE, r);
2694
2695 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2696 expect(2, r);
2697
2698 DestroyWindow(hwnd);
2699 }
2700
2701 static void test_subitem_rect(void)
2702 {
2703 HWND hwnd;
2704 DWORD r;
2705 LVCOLUMNA col;
2706 RECT rect, rect2;
2707 INT arr[3];
2708
2709 /* test LVM_GETSUBITEMRECT for header */
2710 hwnd = create_listview_control(LVS_REPORT);
2711 ok(hwnd != NULL, "failed to create a listview window\n");
2712 /* add some columns */
2713 memset(&col, 0, sizeof(LVCOLUMNA));
2714 col.mask = LVCF_WIDTH;
2715 col.cx = 100;
2716 r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
2717 expect(0, r);
2718 col.cx = 150;
2719 r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 1, (LPARAM)&col);
2720 expect(1, r);
2721 col.cx = 200;
2722 r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 2, (LPARAM)&col);
2723 expect(2, r);
2724 /* item = -1 means header, subitem index is 1 based */
2725 SetRect(&rect, LVIR_BOUNDS, 0, 0, 0);
2726 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2727 expect(0, r);
2728
2729 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2730 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2731 expect(1, r);
2732
2733 expect(100, rect.left);
2734 expect(250, rect.right);
2735 expect(3, rect.top);
2736
2737 SetRect(&rect, LVIR_BOUNDS, 2, 0, 0);
2738 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2739 expect(1, r);
2740
2741 expect(250, rect.left);
2742 expect(450, rect.right);
2743 expect(3, rect.top);
2744
2745 /* item LVS_REPORT padding isn't applied to subitems */
2746 insert_item(hwnd, 0);
2747
2748 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2749 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2750 expect(1, r);
2751 expect(100, rect.left);
2752 expect(250, rect.right);
2753
2754 SetRect(&rect, LVIR_ICON, 1, 0, 0);
2755 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2756 expect(1, r);
2757 /* no icon attached - zero width rectangle, with no left padding */
2758 expect(100, rect.left);
2759 expect(100, rect.right);
2760
2761 SetRect(&rect, LVIR_LABEL, 1, 0, 0);
2762 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2763 expect(1, r);
2764 /* same as full LVIR_BOUNDS */
2765 expect(100, rect.left);
2766 expect(250, rect.right);
2767
2768 r = SendMessageA(hwnd, LVM_SCROLL, 10, 0);
2769 ok(r, "got %d\n", r);
2770
2771 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2772 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2773 expect(1, r);
2774 expect(90, rect.left);
2775 expect(240, rect.right);
2776
2777 SendMessageA(hwnd, LVM_SCROLL, -10, 0);
2778
2779 /* test header interaction */
2780 subclass_header(hwnd);
2781 flush_sequences(sequences, NUM_MSG_SEQUENCES);
2782
2783 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2784 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2785 expect(1, r);
2786
2787 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2788 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2789 expect(1, r);
2790
2791 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2792 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -10, (LPARAM)&rect);
2793 expect(1, r);
2794
2795 SetRect(&rect, LVIR_BOUNDS, 1, 0, 0);
2796 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 20, (LPARAM)&rect);
2797 expect(1, r);
2798
2799 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getsubitemrect_seq, "LVM_GETSUBITEMRECT negative index", FALSE);
2800
2801 DestroyWindow(hwnd);
2802
2803 /* test subitem rects after re-arranging columns */
2804 hwnd = create_listview_control(LVS_REPORT);
2805 ok(hwnd != NULL, "failed to create a listview window\n");
2806 memset(&col, 0, sizeof(LVCOLUMNA));
2807 col.mask = LVCF_WIDTH;
2808
2809 col.cx = 100;
2810 r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
2811 expect(0, r);
2812
2813 col.cx = 200;
2814 r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 1, (LPARAM)&col);
2815 expect(1, r);
2816
2817 col.cx = 300;
2818 r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 2, (LPARAM)&col);
2819 expect(2, r);
2820
2821 insert_item(hwnd, 0);
2822 insert_item(hwnd, 1);
2823
2824 /* wrong item is refused for main item */
2825 SetRect(&rect, LVIR_BOUNDS, 0, -1, -1);
2826 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect);
2827 expect(FALSE, r);
2828
2829 /* for subitems rectangle is calculated even if there's no item added */
2830 SetRect(&rect, LVIR_BOUNDS, 1, -1, -1);
2831 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect);
2832 expect(TRUE, r);
2833
2834 SetRect(&rect2, LVIR_BOUNDS, 1, -1, -1);
2835 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect2);
2836 expect(TRUE, r);
2837 expect(rect.right, rect2.right);
2838 expect(rect.left, rect2.left);
2839 expect(rect.bottom, rect2.top);
2840 ok(rect2.bottom > rect2.top, "expected not zero height\n");
2841
2842 arr[0] = 1; arr[1] = 0; arr[2] = 2;
2843 r = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 3, (LPARAM)arr);
2844 expect(TRUE, r);
2845
2846 SetRect(&rect, LVIR_BOUNDS, 0, -1, -1);
2847 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2848 expect(TRUE, r);
2849 expect(0, rect.left);
2850 expect(600, rect.right);
2851
2852 SetRect(&rect, LVIR_BOUNDS, 1, -1, -1);
2853 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2854 expect(TRUE, r);
2855 expect(0, rect.left);
2856 expect(200, rect.right);
2857
2858 SetRect(&rect2, LVIR_BOUNDS, 1, -1, -1);
2859 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect2);
2860 expect(TRUE, r);
2861 expect(0, rect2.left);
2862 expect(200, rect2.right);
2863 /* items are of the same height */
2864 ok(rect2.top > 0, "expected positive item height\n");
2865 expect(rect.bottom, rect2.top);
2866 expect(rect.bottom * 2 - rect.top, rect2.bottom);
2867
2868 SetRect(&rect, LVIR_BOUNDS, 2, -1, -1);
2869 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
2870 expect(TRUE, r);
2871 expect(300, rect.left);
2872 expect(600, rect.right);
2873
2874 DestroyWindow(hwnd);
2875
2876 /* try it for non LVS_REPORT style */
2877 hwnd = CreateWindowA(WC_LISTVIEWA, "Test", LVS_ICON, 0, 0, 100, 100, NULL, NULL,
2878 GetModuleHandleA(NULL), 0);
2879 SetRect(&rect, LVIR_BOUNDS, 1, -10, -10);
2880 r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
2881 expect(0, r);
2882 /* rect is unchanged */
2883 expect(0, rect.left);
2884 expect(-10, rect.right);
2885 expect(1, rect.top);
2886 expect(-10, rect.bottom);
2887 DestroyWindow(hwnd);
2888 }
2889
2890 /* comparison callback for test_sorting */
2891 static INT WINAPI test_CallBackCompare(LPARAM first, LPARAM second, LPARAM lParam)
2892 {
2893 if (first == second) return 0;
2894 return (first > second ? 1 : -1);
2895 }
2896
2897 static void test_sorting(void)
2898 {
2899 HWND hwnd;
2900 LVITEMA item = {0};
2901 INT r;
2902 LONG_PTR style;
2903 static CHAR names[][5] = {"A", "B", "C", "D", "0"};
2904 CHAR buff[10];
2905
2906 hwnd = create_listview_control(LVS_REPORT);
2907 ok(hwnd != NULL, "failed to create a listview window\n");
2908
2909 /* insert some items */
2910 item.mask = LVIF_PARAM | LVIF_STATE;
2911 item.state = LVIS_SELECTED;
2912 item.iItem = 0;
2913 item.iSubItem = 0;
2914 item.lParam = 3;
2915 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
2916 expect(0, r);
2917
2918 item.mask = LVIF_PARAM;
2919 item.iItem = 1;
2920 item.iSubItem = 0;
2921 item.lParam = 2;
2922 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
2923 expect(1, r);
2924
2925 item.mask = LVIF_STATE | LVIF_PARAM;
2926 item.state = LVIS_SELECTED;
2927 item.iItem = 2;
2928 item.iSubItem = 0;
2929 item.lParam = 4;
2930 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
2931 expect(2, r);
2932
2933 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2934 expect(-1, r);
2935
2936 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2937 expect(2, r);
2938
2939 r = SendMessageA(hwnd, LVM_SORTITEMS, 0, (LPARAM)test_CallBackCompare);
2940 expect(TRUE, r);
2941
2942 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
2943 expect(2, r);
2944 r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
2945 expect(-1, r);
2946 r = SendMessageA(hwnd, LVM_GETITEMSTATE, 0, LVIS_SELECTED);
2947 expect(0, r);
2948 r = SendMessageA(hwnd, LVM_GETITEMSTATE, 1, LVIS_SELECTED);
2949 expect(LVIS_SELECTED, r);
2950 r = SendMessageA(hwnd, LVM_GETITEMSTATE, 2, LVIS_SELECTED);
2951 expect(LVIS_SELECTED, r);
2952
2953 DestroyWindow(hwnd);
2954
2955 /* switch to LVS_SORTASCENDING when some items added */
2956 hwnd = create_listview_control(LVS_REPORT);
2957 ok(hwnd != NULL, "failed to create a listview window\n");
2958
2959 item.mask = LVIF_TEXT;
2960 item.iItem = 0;
2961 item.iSubItem = 0;
2962 item.pszText = names[1];
2963 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
2964 expect(0, r);
2965
2966 item.mask = LVIF_TEXT;
2967 item.iItem = 1;
2968 item.iSubItem = 0;
2969 item.pszText = names[2];
2970 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
2971 expect(1, r);
2972
2973 item.mask = LVIF_TEXT;
2974 item.iItem = 2;
2975 item.iSubItem = 0;
2976 item.pszText = names[0];
2977 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
2978 expect(2, r);
2979
2980 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2981 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SORTASCENDING);
2982 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
2983 ok(style & LVS_SORTASCENDING, "Expected LVS_SORTASCENDING to be set\n");
2984
2985 /* no sorting performed when switched to LVS_SORTASCENDING */
2986 item.mask = LVIF_TEXT;
2987 item.iItem = 0;
2988 item.pszText = buff;
2989 item.cchTextMax = sizeof(buff);
2990 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
2991 expect(TRUE, r);
2992 ok(lstrcmpA(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
2993
2994 item.iItem = 1;
2995 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
2996 expect(TRUE, r);
2997 ok(lstrcmpA(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
2998
2999 item.iItem = 2;
3000 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3001 expect(TRUE, r);
3002 ok(lstrcmpA(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
3003
3004 /* adding new item doesn't resort list */
3005 item.mask = LVIF_TEXT;
3006 item.iItem = 3;
3007 item.iSubItem = 0;
3008 item.pszText = names[3];
3009 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
3010 expect(3, r);
3011
3012 item.mask = LVIF_TEXT;
3013 item.iItem = 0;
3014 item.pszText = buff;
3015 item.cchTextMax = sizeof(buff);
3016 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3017 expect(TRUE, r);
3018 ok(lstrcmpA(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
3019
3020 item.iItem = 1;
3021 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3022 expect(TRUE, r);
3023 ok(lstrcmpA(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
3024
3025 item.iItem = 2;
3026 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3027 expect(TRUE, r);
3028 ok(lstrcmpA(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
3029
3030 item.iItem = 3;
3031 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3032 expect(TRUE, r);
3033 ok(lstrcmpA(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
3034
3035 /* corner case - item should be placed at first position */
3036 item.mask = LVIF_TEXT;
3037 item.iItem = 4;
3038 item.iSubItem = 0;
3039 item.pszText = names[4];
3040 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
3041 expect(0, r);
3042
3043 item.iItem = 0;
3044 item.pszText = buff;
3045 item.cchTextMax = sizeof(buff);
3046 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3047 expect(TRUE, r);
3048 ok(lstrcmpA(buff, names[4]) == 0, "Expected '%s', got '%s'\n", names[4], buff);
3049
3050 item.iItem = 1;
3051 item.pszText = buff;
3052 item.cchTextMax = sizeof(buff);
3053 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3054 expect(TRUE, r);
3055 ok(lstrcmpA(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
3056
3057 item.iItem = 2;
3058 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3059 expect(TRUE, r);
3060 ok(lstrcmpA(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
3061
3062 item.iItem = 3;
3063 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3064 expect(TRUE, r);
3065 ok(lstrcmpA(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
3066
3067 item.iItem = 4;
3068 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
3069 expect(TRUE, r);
3070 ok(lstrcmpA(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
3071
3072 DestroyWindow(hwnd);
3073 }
3074
3075 static void test_ownerdata(void)
3076 {
3077 static char test_str[] = "test";
3078
3079 HWND hwnd;
3080 LONG_PTR style, ret;
3081 DWORD res;
3082 LVITEMA item;
3083
3084 /* it isn't possible to set LVS_OWNERDATA after creation */
3085 if (g_is_below_5)
3086 {
3087 win_skip("set LVS_OWNERDATA after creation leads to crash on < 5.80\n");
3088 }
3089 else
3090 {
3091 hwnd = create_listview_control(LVS_REPORT);
3092 ok(hwnd != NULL, "failed to create a listview window\n");
3093 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3094 ok(!(style & LVS_OWNERDATA) && style, "LVS_OWNERDATA isn't expected\n");
3095
3096 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3097
3098 ret = SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_OWNERDATA);
3099 ok(ret == style, "Expected set GWL_STYLE to succeed\n");
3100 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_ownerdata_switchto_seq,
3101 "try to switch to LVS_OWNERDATA seq", FALSE);
3102
3103 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3104 ok(!(style & LVS_OWNERDATA), "LVS_OWNERDATA isn't expected\n");
3105 DestroyWindow(hwnd);
3106 }
3107
3108 /* try to set LVS_OWNERDATA after creation just having it */
3109 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3110 ok(hwnd != NULL, "failed to create a listview window\n");
3111 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3112 ok(style & LVS_OWNERDATA, "LVS_OWNERDATA is expected\n");
3113
3114 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3115
3116 ret = SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_OWNERDATA);
3117 ok(ret == style, "Expected set GWL_STYLE to succeed\n");
3118 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_ownerdata_switchto_seq,
3119 "try to switch to LVS_OWNERDATA seq", FALSE);
3120 DestroyWindow(hwnd);
3121
3122 /* try to remove LVS_OWNERDATA after creation just having it */
3123 if (g_is_below_5)
3124 {
3125 win_skip("remove LVS_OWNERDATA after creation leads to crash on < 5.80\n");
3126 }
3127 else
3128 {
3129 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3130 ok(hwnd != NULL, "failed to create a listview window\n");
3131 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3132 ok(style & LVS_OWNERDATA, "LVS_OWNERDATA is expected\n");
3133
3134 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3135
3136 ret = SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_OWNERDATA);
3137 ok(ret == style, "Expected set GWL_STYLE to succeed\n");
3138 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_ownerdata_switchto_seq,
3139 "try to switch to LVS_OWNERDATA seq", FALSE);
3140 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3141 ok(style & LVS_OWNERDATA, "LVS_OWNERDATA is expected\n");
3142 DestroyWindow(hwnd);
3143 }
3144
3145 /* try select an item */
3146 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3147 ok(hwnd != NULL, "failed to create a listview window\n");
3148 res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
3149 expect(1, res);
3150 res = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
3151 expect(0, res);
3152 memset(&item, 0, sizeof(item));
3153 item.stateMask = LVIS_SELECTED;
3154 item.state = LVIS_SELECTED;
3155 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3156 expect(TRUE, res);
3157 res = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
3158 expect(1, res);
3159 res = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
3160 expect(1, res);
3161 DestroyWindow(hwnd);
3162
3163 /* LVM_SETITEM and LVM_SETITEMTEXT is unsupported on LVS_OWNERDATA */
3164 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3165 ok(hwnd != NULL, "failed to create a listview window\n");
3166 res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
3167 expect(1, res);
3168 res = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
3169 expect(1, res);
3170 memset(&item, 0, sizeof(item));
3171 item.mask = LVIF_STATE;
3172 item.iItem = 0;
3173 item.stateMask = LVIS_SELECTED;
3174 item.state = LVIS_SELECTED;
3175 res = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
3176 expect(FALSE, res);
3177 memset(&item, 0, sizeof(item));
3178 item.pszText = test_str;
3179 res = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
3180 expect(FALSE, res);
3181 DestroyWindow(hwnd);
3182
3183 /* check notifications after focused/selected changed */
3184 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3185 ok(hwnd != NULL, "failed to create a listview window\n");
3186 res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 20, 0);
3187 expect(1, res);
3188
3189 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3190
3191 memset(&item, 0, sizeof(item));
3192 item.stateMask = LVIS_SELECTED;
3193 item.state = LVIS_SELECTED;
3194 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3195 expect(TRUE, res);
3196
3197 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_select_focus_parent_seq,
3198 "ownerdata select notification", TRUE);
3199
3200 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3201
3202 memset(&item, 0, sizeof(item));
3203 item.stateMask = LVIS_FOCUSED;
3204 item.state = LVIS_FOCUSED;
3205 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3206 expect(TRUE, res);
3207
3208 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_select_focus_parent_seq,
3209 "ownerdata focus notification", TRUE);
3210
3211 /* select all, check notifications */
3212 item.stateMask = LVIS_SELECTED;
3213 item.state = 0;
3214 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3215 expect(TRUE, res);
3216
3217 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3218
3219 item.stateMask = LVIS_SELECTED;
3220 item.state = LVIS_SELECTED;
3221
3222 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3223 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3224 expect(TRUE, res);
3225 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3226 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3227 ok(g_nmlistview.uNewState == LVIS_SELECTED, "got new state 0x%08x\n", g_nmlistview.uNewState);
3228 ok(g_nmlistview.uOldState == 0, "got old state 0x%08x\n", g_nmlistview.uOldState);
3229 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3230 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3231 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3232
3233 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
3234 "ownerdata select all notification", FALSE);
3235
3236 /* select all again, note that all items are selected already */
3237 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3238 item.stateMask = LVIS_SELECTED;
3239 item.state = LVIS_SELECTED;
3240
3241 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3242 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3243 expect(TRUE, res);
3244 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3245 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3246 ok(g_nmlistview.uNewState == LVIS_SELECTED, "got new state 0x%08x\n", g_nmlistview.uNewState);
3247 ok(g_nmlistview.uOldState == 0, "got old state 0x%08x\n", g_nmlistview.uOldState);
3248 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3249 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3250 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3251
3252 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
3253 "ownerdata select all notification", FALSE);
3254
3255 /* deselect all */
3256 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3257 item.stateMask = LVIS_SELECTED;
3258 item.state = 0;
3259
3260 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3261 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3262 expect(TRUE, res);
3263 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3264 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3265 ok(g_nmlistview.uNewState == 0, "got new state 0x%08x\n", g_nmlistview.uNewState);
3266 ok(g_nmlistview.uOldState == LVIS_SELECTED, "got old state 0x%08x\n", g_nmlistview.uOldState);
3267 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3268 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3269 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3270
3271 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_deselect_all_parent_seq,
3272 "ownerdata deselect all notification", TRUE);
3273
3274 /* nothing selected, deselect all again */
3275 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3276 item.stateMask = LVIS_SELECTED;
3277 item.state = 0;
3278
3279 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3280 expect(TRUE, res);
3281
3282 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "ownerdata deselect all notification", FALSE);
3283
3284 /* select one, then deselect all */
3285 item.stateMask = LVIS_SELECTED;
3286 item.state = LVIS_SELECTED;
3287 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3288 expect(TRUE, res);
3289 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3290 item.stateMask = LVIS_SELECTED;
3291 item.state = 0;
3292
3293 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3294 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3295 expect(TRUE, res);
3296 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3297 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3298 ok(g_nmlistview.uNewState == 0, "got new state 0x%08x\n", g_nmlistview.uNewState);
3299 ok(g_nmlistview.uOldState == LVIS_SELECTED, "got old state 0x%08x\n", g_nmlistview.uOldState);
3300 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3301 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3302 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3303
3304 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_deselect_all_parent_seq,
3305 "ownerdata select all notification", TRUE);
3306
3307 /* remove focused, try to focus all */
3308 item.stateMask = LVIS_FOCUSED;
3309 item.state = LVIS_FOCUSED;
3310 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3311 expect(TRUE, res);
3312 item.stateMask = LVIS_FOCUSED;
3313 item.state = 0;
3314 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3315 expect(TRUE, res);
3316 item.stateMask = LVIS_FOCUSED;
3317 res = SendMessageA(hwnd, LVM_GETITEMSTATE, 0, LVIS_FOCUSED);
3318 expect(0, res);
3319
3320 /* setting all to focused returns failure value */
3321 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3322 item.stateMask = LVIS_FOCUSED;
3323 item.state = LVIS_FOCUSED;
3324
3325 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3326 expect(FALSE, res);
3327
3328 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3329 "ownerdata focus all notification", FALSE);
3330
3331 /* focus single item, remove all */
3332 item.stateMask = LVIS_FOCUSED;
3333 item.state = LVIS_FOCUSED;
3334 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3335 expect(TRUE, res);
3336 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3337 item.stateMask = LVIS_FOCUSED;
3338 item.state = 0;
3339
3340 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3341 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3342 expect(TRUE, res);
3343 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3344 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3345 ok(g_nmlistview.uNewState == 0, "got new state 0x%08x\n", g_nmlistview.uNewState);
3346 ok(g_nmlistview.uOldState == LVIS_FOCUSED, "got old state 0x%08x\n", g_nmlistview.uOldState);
3347 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3348 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3349 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3350
3351 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_defocus_all_parent_seq,
3352 "ownerdata remove focus all notification", TRUE);
3353
3354 /* set all cut */
3355 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3356 item.stateMask = LVIS_CUT;
3357 item.state = LVIS_CUT;
3358
3359 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3360 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3361 expect(TRUE, res);
3362 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3363 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3364 ok(g_nmlistview.uNewState == LVIS_CUT, "got new state 0x%08x\n", g_nmlistview.uNewState);
3365 ok(g_nmlistview.uOldState == 0, "got old state 0x%08x\n", g_nmlistview.uOldState);
3366 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3367 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3368 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3369
3370 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
3371 "ownerdata cut all notification", FALSE);
3372
3373 /* all marked cut, try again */
3374 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3375 item.stateMask = LVIS_CUT;
3376 item.state = LVIS_CUT;
3377
3378 memset(&g_nmlistview, 0xcc, sizeof(g_nmlistview));
3379 res = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
3380 expect(TRUE, res);
3381 ok(g_nmlistview.iItem == -1, "got item %d\n", g_nmlistview.iItem);
3382 ok(g_nmlistview.iSubItem == 0, "got subitem %d\n", g_nmlistview.iSubItem);
3383 ok(g_nmlistview.uNewState == LVIS_CUT, "got new state 0x%08x\n", g_nmlistview.uNewState);
3384 ok(g_nmlistview.uOldState == 0, "got old state 0x%08x\n", g_nmlistview.uOldState);
3385 ok(g_nmlistview.uChanged == LVIF_STATE, "got changed 0x%08x\n", g_nmlistview.uChanged);
3386 ok(g_nmlistview.ptAction.x == 0 && g_nmlistview.ptAction.y == 0, "got wrong ptAction value\n");
3387 ok(g_nmlistview.lParam == 0, "got wrong lparam\n");
3388
3389 ok_sequence(sequences, PARENT_SEQ_INDEX, ownerdata_setstate_all_parent_seq,
3390 "ownerdata cut all notification #2", FALSE);
3391
3392 DestroyWindow(hwnd);
3393
3394 /* check notifications on LVM_GETITEM */
3395 /* zero callback mask */
3396 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3397 ok(hwnd != NULL, "failed to create a listview window\n");
3398 res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
3399 expect(1, res);
3400
3401 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3402
3403 memset(&item, 0, sizeof(item));
3404 item.stateMask = LVIS_SELECTED;
3405 item.mask = LVIF_STATE;
3406 res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3407 expect(TRUE, res);
3408
3409 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3410 "ownerdata getitem selected state 1", FALSE);
3411
3412 /* non zero callback mask but not we asking for */
3413 res = SendMessageA(hwnd, LVM_SETCALLBACKMASK, LVIS_OVERLAYMASK, 0);
3414 expect(TRUE, res);
3415
3416 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3417
3418 memset(&item, 0, sizeof(item));
3419 item.stateMask = LVIS_SELECTED;
3420 item.mask = LVIF_STATE;
3421 res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3422 expect(TRUE, res);
3423
3424 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3425 "ownerdata getitem selected state 2", FALSE);
3426
3427 /* LVIS_OVERLAYMASK callback mask, asking for index */
3428 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3429
3430 memset(&item, 0, sizeof(item));
3431 item.stateMask = LVIS_OVERLAYMASK;
3432 item.mask = LVIF_STATE;
3433 res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3434 expect(TRUE, res);
3435
3436 ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
3437 "ownerdata getitem selected state 2", FALSE);
3438
3439 DestroyWindow(hwnd);
3440
3441 /* LVS_SORTASCENDING/LVS_SORTDESCENDING aren't compatible with LVS_OWNERDATA */
3442 hwnd = create_listview_control(LVS_OWNERDATA | LVS_SORTASCENDING | LVS_REPORT);
3443 ok(hwnd != NULL, "failed to create a listview window\n");
3444 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3445 ok(style & LVS_OWNERDATA, "Expected LVS_OWNERDATA\n");
3446 ok(style & LVS_SORTASCENDING, "Expected LVS_SORTASCENDING to be set\n");
3447 SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_SORTASCENDING);
3448 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3449 ok(!(style & LVS_SORTASCENDING), "Expected LVS_SORTASCENDING not set\n");
3450 DestroyWindow(hwnd);
3451 /* apparently it's allowed to switch these style on after creation */
3452 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3453 ok(hwnd != NULL, "failed to create a listview window\n");
3454 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3455 ok(style & LVS_OWNERDATA, "Expected LVS_OWNERDATA\n");
3456 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SORTASCENDING);
3457 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3458 ok(style & LVS_SORTASCENDING, "Expected LVS_SORTASCENDING to be set\n");
3459 DestroyWindow(hwnd);
3460
3461 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3462 ok(hwnd != NULL, "failed to create a listview window\n");
3463 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3464 ok(style & LVS_OWNERDATA, "Expected LVS_OWNERDATA\n");
3465 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SORTDESCENDING);
3466 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3467 ok(style & LVS_SORTDESCENDING, "Expected LVS_SORTDESCENDING to be set\n");
3468 DestroyWindow(hwnd);
3469
3470 /* The focused item is updated after the invalidation */
3471 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3472 ok(hwnd != NULL, "failed to create a listview window\n");
3473 res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 3, 0);
3474 expect(TRUE, res);
3475
3476 memset(&item, 0, sizeof(item));
3477 item.stateMask = LVIS_FOCUSED;
3478 item.state = LVIS_FOCUSED;
3479 res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
3480 expect(TRUE, res);
3481
3482 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3483 res = SendMessageA(hwnd, LVM_SETITEMCOUNT, 0, 0);
3484 expect(TRUE, res);
3485 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3486 "ownerdata setitemcount", FALSE);
3487
3488 res = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
3489 expect(-1, res);
3490 DestroyWindow(hwnd);
3491 }
3492
3493 static void test_norecompute(void)
3494 {
3495 static CHAR testA[] = "test";
3496 CHAR buff[10];
3497 LVITEMA item;
3498 HWND hwnd;
3499 DWORD res;
3500
3501 /* self containing control */
3502 hwnd = create_listview_control(LVS_REPORT);
3503 ok(hwnd != NULL, "failed to create a listview window\n");
3504 memset(&item, 0, sizeof(item));
3505 item.mask = LVIF_TEXT | LVIF_STATE;
3506 item.iItem = 0;
3507 item.stateMask = LVIS_SELECTED;
3508 item.state = LVIS_SELECTED;
3509 item.pszText = testA;
3510 res = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3511 expect(0, res);
3512 /* retrieve with LVIF_NORECOMPUTE */
3513 item.mask = LVIF_TEXT | LVIF_NORECOMPUTE;
3514 item.iItem = 0;
3515 item.pszText = buff;
3516 item.cchTextMax = ARRAY_SIZE(buff);
3517 res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3518 expect(TRUE, res);
3519 ok(lstrcmpA(buff, testA) == 0, "Expected (%s), got (%s)\n", testA, buff);
3520
3521 item.mask = LVIF_TEXT;
3522 item.iItem = 1;
3523 item.pszText = LPSTR_TEXTCALLBACKA;
3524 res = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3525 expect(1, res);
3526
3527 item.mask = LVIF_TEXT | LVIF_NORECOMPUTE;
3528 item.iItem = 1;
3529 item.pszText = buff;
3530 item.cchTextMax = ARRAY_SIZE(buff);
3531
3532 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3533 res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3534 expect(TRUE, res);
3535 ok(item.pszText == LPSTR_TEXTCALLBACKA, "Expected (%p), got (%p)\n",
3536 LPSTR_TEXTCALLBACKA, (VOID*)item.pszText);
3537 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "retrieve with LVIF_NORECOMPUTE seq", FALSE);
3538
3539 DestroyWindow(hwnd);
3540
3541 /* LVS_OWNERDATA */
3542 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3543 ok(hwnd != NULL, "failed to create a listview window\n");
3544
3545 item.mask = LVIF_STATE;
3546 item.stateMask = LVIS_SELECTED;
3547 item.state = LVIS_SELECTED;
3548 item.iItem = 0;
3549 res = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3550 expect(0, res);
3551
3552 item.mask = LVIF_TEXT | LVIF_NORECOMPUTE;
3553 item.iItem = 0;
3554 item.pszText = buff;
3555 item.cchTextMax = ARRAY_SIZE(buff);
3556 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3557 res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
3558 expect(TRUE, res);
3559 ok(item.pszText == LPSTR_TEXTCALLBACKA, "Expected (%p), got (%p)\n",
3560 LPSTR_TEXTCALLBACKA, (VOID*)item.pszText);
3561 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "retrieve with LVIF_NORECOMPUTE seq 2", FALSE);
3562
3563 DestroyWindow(hwnd);
3564 }
3565
3566 static void test_nosortheader(void)
3567 {
3568 HWND hwnd, header;
3569 LONG_PTR style;
3570
3571 hwnd = create_listview_control(LVS_REPORT);
3572 ok(hwnd != NULL, "failed to create a listview window\n");
3573
3574 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
3575 ok(IsWindow(header), "header expected\n");
3576
3577 style = GetWindowLongPtrA(header, GWL_STYLE);
3578 ok(style & HDS_BUTTONS, "expected header to have HDS_BUTTONS\n");
3579
3580 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3581 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_NOSORTHEADER);
3582 /* HDS_BUTTONS retained */
3583 style = GetWindowLongPtrA(header, GWL_STYLE);
3584 ok(style & HDS_BUTTONS, "expected header to retain HDS_BUTTONS\n");
3585
3586 DestroyWindow(hwnd);
3587
3588 /* create with LVS_NOSORTHEADER */
3589 hwnd = create_listview_control(LVS_NOSORTHEADER | LVS_REPORT);
3590 ok(hwnd != NULL, "failed to create a listview window\n");
3591
3592 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
3593 ok(IsWindow(header), "header expected\n");
3594
3595 style = GetWindowLongPtrA(header, GWL_STYLE);
3596 ok(!(style & HDS_BUTTONS), "expected header to have no HDS_BUTTONS\n");
3597
3598 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3599 SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_NOSORTHEADER);
3600 /* not changed here */
3601 style = GetWindowLongPtrA(header, GWL_STYLE);
3602 ok(!(style & HDS_BUTTONS), "expected header to have no HDS_BUTTONS\n");
3603
3604 DestroyWindow(hwnd);
3605 }
3606
3607 static void test_setredraw(void)
3608 {
3609 HWND hwnd;
3610 DWORD_PTR style;
3611 DWORD ret;
3612 HDC hdc;
3613 RECT rect;
3614
3615 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
3616 ok(hwnd != NULL, "failed to create a listview window\n");
3617
3618 /* Passing WM_SETREDRAW to DefWinProc removes WS_VISIBLE.
3619 ListView seems to handle it internally without DefWinProc */
3620
3621 /* default value first */
3622 ret = SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
3623 expect(0, ret);
3624 /* disable */
3625 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3626 ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
3627 ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3628 expect(0, ret);
3629 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
3630 ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
3631 ret = SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
3632 expect(0, ret);
3633
3634 /* check update rect after redrawing */
3635 ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3636 expect(0, ret);
3637 InvalidateRect(hwnd, NULL, FALSE);
3638 RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
3639 rect.right = rect.bottom = 1;
3640 GetUpdateRect(hwnd, &rect, FALSE);
3641 expect(0, rect.right);
3642 expect(0, rect.bottom);
3643
3644 /* WM_ERASEBKGND */
3645 hdc = GetWindowDC(hwndparent);
3646 ret = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
3647 expect(TRUE, ret);
3648 ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3649 expect(0, ret);
3650 ret = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
3651 expect(TRUE, ret);
3652 ret = SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
3653 expect(0, ret);
3654 ReleaseDC(hwndparent, hdc);
3655
3656 /* check notification messages to show that repainting is disabled */
3657 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
3658 expect(TRUE, ret);
3659 ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3660 expect(0, ret);
3661 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3662
3663 InvalidateRect(hwnd, NULL, TRUE);
3664 UpdateWindow(hwnd);
3665 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3666 "redraw after WM_SETREDRAW (FALSE)", FALSE);
3667
3668 ret = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
3669 expect(TRUE, ret);
3670 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3671 InvalidateRect(hwnd, NULL, TRUE);
3672 UpdateWindow(hwnd);
3673 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
3674 "redraw after WM_SETREDRAW (FALSE) with CLR_NONE bkgnd", FALSE);
3675
3676 /* message isn't forwarded to header */
3677 subclass_header(hwnd);
3678 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3679 ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3680 expect(0, ret);
3681 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, setredraw_seq,
3682 "WM_SETREDRAW: not forwarded to header", FALSE);
3683
3684 DestroyWindow(hwnd);
3685 }
3686
3687 static void test_hittest(void)
3688 {
3689 HWND hwnd;
3690 DWORD r;
3691 RECT bounds;
3692 LVITEMA item;
3693 static CHAR text[] = "1234567890ABCDEFGHIJKLMNOPQRST";
3694 POINT pos;
3695 INT x, y, i;
3696 WORD vert;
3697 HIMAGELIST himl, himl2;
3698 HBITMAP hbmp;
3699
3700 hwnd = create_listview_control(LVS_REPORT);
3701 ok(hwnd != NULL, "failed to create a listview window\n");
3702
3703 /* LVS_REPORT with a single subitem (2 columns) */
3704 insert_column(hwnd, 0);
3705 insert_column(hwnd, 1);
3706 insert_item(hwnd, 0);
3707
3708 item.iSubItem = 0;
3709 /* the only purpose of that line is to be as long as a half item rect */
3710 item.pszText = text;
3711 r = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
3712 expect(TRUE, r);
3713
3714 r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
3715 expect(TRUE, r);
3716 r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
3717 expect(TRUE, r);
3718
3719 SetRect(&bounds, LVIR_BOUNDS, 0, 0, 0);
3720 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&bounds);
3721 expect(1, r);
3722 ok(bounds.bottom - bounds.top > 0, "Expected non zero item height\n");
3723 ok(bounds.right - bounds.left > 0, "Expected non zero item width\n");
3724 r = SendMessageA(hwnd, LVM_GETITEMSPACING, TRUE, 0);
3725 vert = HIWORD(r);
3726 ok(bounds.bottom - bounds.top == vert,
3727 "Vertical spacing inconsistent (%d != %d)\n", bounds.bottom - bounds.top, vert);
3728 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pos);
3729 expect(TRUE, r);
3730
3731 /* LVS_EX_FULLROWSELECT not set, no icons attached */
3732
3733 /* outside columns by x position - valid is [0, 199] */
3734 x = -1;
3735 y = pos.y + (bounds.bottom - bounds.top) / 2;
3736 test_lvm_hittest(hwnd, x, y, -1, LVHT_TOLEFT, 0, FALSE, FALSE);
3737 test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3738
3739 x = pos.x + 50; /* column half width */
3740 y = pos.y + (bounds.bottom - bounds.top) / 2;
3741 test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMLABEL, 0, FALSE, FALSE);
3742 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3743 x = pos.x + 150; /* outside column */
3744 y = pos.y + (bounds.bottom - bounds.top) / 2;
3745 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3746 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3747 y = (bounds.bottom - bounds.top) / 2;
3748 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3749 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3750 /* outside possible client rectangle (to right) */
3751 x = pos.x + 500;
3752 y = pos.y + (bounds.bottom - bounds.top) / 2;
3753 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3754 test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3755 y = (bounds.bottom - bounds.top) / 2;
3756 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3757 test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3758 /* subitem returned with -1 item too */
3759 x = pos.x + 150;
3760 y = bounds.top - vert;
3761 test_lvm_subitemhittest(hwnd, x, y, -1, 1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3762 test_lvm_subitemhittest(hwnd, x, y - vert + 1, -1, 1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3763 /* return values appear to underflow with negative indices */
3764 i = -2;
3765 y = y - vert;
3766 while (i > -10) {
3767 test_lvm_subitemhittest(hwnd, x, y, i, 1, LVHT_ONITEMLABEL, TRUE, FALSE, TRUE);
3768 test_lvm_subitemhittest(hwnd, x, y - vert + 1, i, 1, LVHT_ONITEMLABEL, TRUE, FALSE, TRUE);
3769 y = y - vert;
3770 i--;
3771 }
3772 /* parent client area is 100x100 by default */
3773 MoveWindow(hwnd, 0, 0, 300, 100, FALSE);
3774 x = pos.x + 150; /* outside column */
3775 y = pos.y + (bounds.bottom - bounds.top) / 2;
3776 test_lvm_hittest(hwnd, x, y, -1, LVHT_NOWHERE, 0, FALSE, FALSE);
3777 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3778 y = (bounds.bottom - bounds.top) / 2;
3779 test_lvm_hittest(hwnd, x, y, -1, LVHT_NOWHERE, 0, FALSE, TRUE);
3780 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3781 /* the same with LVS_EX_FULLROWSELECT */
3782 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
3783 x = pos.x + 150; /* outside column */
3784 y = pos.y + (bounds.bottom - bounds.top) / 2;
3785 test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEM, LVHT_ONITEMLABEL, FALSE, FALSE);
3786 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3787 y = (bounds.bottom - bounds.top) / 2;
3788 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3789 MoveWindow(hwnd, 0, 0, 100, 100, FALSE);
3790 x = pos.x + 150; /* outside column */
3791 y = pos.y + (bounds.bottom - bounds.top) / 2;
3792 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3793 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3794 y = (bounds.bottom - bounds.top) / 2;
3795 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3796 test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
3797 /* outside possible client rectangle (to right) */
3798 x = pos.x + 500;
3799 y = pos.y + (bounds.bottom - bounds.top) / 2;
3800 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, FALSE);
3801 test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3802 y = (bounds.bottom - bounds.top) / 2;
3803 test_lvm_hittest(hwnd, x, y, -1, LVHT_TORIGHT, 0, FALSE, TRUE);
3804 test_lvm_subitemhittest(hwnd, x, y, -1, -1, LVHT_NOWHERE, FALSE, FALSE, FALSE);
3805 /* try with icons, state icons index is 1 based so at least 2 bitmaps needed */
3806 himl = pImageList_Create(16, 16, 0, 4, 4);
3807 ok(himl != NULL, "failed to create imagelist\n");
3808 hbmp = CreateBitmap(16, 16, 1, 1, NULL);
3809 ok(hbmp != NULL, "failed to create bitmap\n");
3810 r = pImageList_Add(himl, hbmp, 0);
3811 ok(r == 0, "should be zero\n");
3812 hbmp = CreateBitmap(16, 16, 1, 1, NULL);
3813 ok(hbmp != NULL, "failed to create bitmap\n");
3814 r = pImageList_Add(himl, hbmp, 0);
3815 ok(r == 1, "should be one\n");
3816
3817 r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
3818 expect(0, r);
3819
3820 item.mask = LVIF_IMAGE;
3821 item.iImage = 0;
3822 item.iItem = 0;
3823 item.iSubItem = 0;
3824 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
3825 expect(TRUE, r);
3826 /* on state icon */
3827 x = pos.x + 8;
3828 y = pos.y + (bounds.bottom - bounds.top) / 2;
3829 test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMSTATEICON, 0, FALSE, FALSE);
3830 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3831 y = (bounds.bottom - bounds.top) / 2;
3832 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3833
3834 /* state icons indices are 1 based, check with valid index */
3835 item.mask = LVIF_STATE;
3836 item.state = INDEXTOSTATEIMAGEMASK(1);
3837 item.stateMask = LVIS_STATEIMAGEMASK;
3838 item.iItem = 0;
3839 item.iSubItem = 0;
3840 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
3841 expect(TRUE, r);
3842 /* on state icon */
3843 x = pos.x + 8;
3844 y = pos.y + (bounds.bottom - bounds.top) / 2;
3845 test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMSTATEICON, 0, FALSE, FALSE);
3846 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3847 y = (bounds.bottom - bounds.top) / 2;
3848 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
3849
3850 himl2 = (HIMAGELIST)SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
3851 ok(himl2 == himl, "should return handle\n");
3852
3853 r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
3854 expect(0, r);
3855 /* on item icon */
3856 x = pos.x + 8;
3857 y = pos.y + (bounds.bottom - bounds.top) / 2;
3858 test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEMICON, 0, FALSE, FALSE);
3859 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMICON, FALSE, FALSE, FALSE);
3860 y = (bounds.bottom - bounds.top) / 2;
3861 test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMICON, FALSE, FALSE, FALSE);
3862
3863 DestroyWindow(hwnd);
3864 }
3865
3866 static void test_getviewrect(void)
3867 {
3868 HWND hwnd;
3869 DWORD r;
3870 RECT rect;
3871 LVITEMA item;
3872
3873 hwnd = create_listview_control(LVS_REPORT);
3874 ok(hwnd != NULL, "failed to create a listview window\n");
3875
3876 /* empty */
3877 r = SendMessageA(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
3878 expect(TRUE, r);
3879
3880 insert_column(hwnd, 0);
3881 insert_column(hwnd, 1);
3882
3883 memset(&item, 0, sizeof(item));
3884 item.iItem = 0;
3885 item.iSubItem = 0;
3886 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3887 ok(!r, "got %d\n", r);
3888
3889 r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
3890 expect(TRUE, r);
3891 r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(120, 0));
3892 expect(TRUE, r);
3893
3894 SetRect(&rect, -1, -1, -1, -1);
3895 r = SendMessageA(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
3896 expect(TRUE, r);
3897 /* left is set to (2e31-1) - XP SP2 */
3898 expect(0, rect.right);
3899 expect(0, rect.top);
3900 expect(0, rect.bottom);
3901
3902 /* switch to LVS_ICON */
3903 SetWindowLongA(hwnd, GWL_STYLE, GetWindowLongA(hwnd, GWL_STYLE) & ~LVS_REPORT);
3904
3905 SetRect(&rect, -1, -1, -1, -1);
3906 r = SendMessageA(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
3907 expect(TRUE, r);
3908 expect(0, rect.left);
3909 expect(0, rect.top);
3910 /* precise value differs for 2k, XP and Vista */
3911 ok(rect.bottom > 0, "Expected positive bottom value, got %d\n", rect.bottom);
3912 ok(rect.right > 0, "Expected positive right value, got %d\n", rect.right);
3913
3914 DestroyWindow(hwnd);
3915 }
3916
3917 static void test_getitemposition(void)
3918 {
3919 HWND hwnd, header;
3920 DWORD r;
3921 POINT pt;
3922 RECT rect;
3923
3924 hwnd = create_listview_control(LVS_REPORT);
3925 ok(hwnd != NULL, "failed to create a listview window\n");
3926 header = subclass_header(hwnd);
3927
3928 /* LVS_REPORT, single item, no columns added */
3929 insert_item(hwnd, 0);
3930
3931 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3932
3933 pt.x = pt.y = -1;
3934 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
3935 expect(TRUE, r);
3936 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getitemposition_seq1, "get item position 1", FALSE);
3937
3938 /* LVS_REPORT, single item, single column */
3939 insert_column(hwnd, 0);
3940
3941 flush_sequences(sequences, NUM_MSG_SEQUENCES);
3942
3943 pt.x = pt.y = -1;
3944 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
3945 expect(TRUE, r);
3946 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getitemposition_seq2, "get item position 2", TRUE);
3947
3948 SetRectEmpty(&rect);
3949 r = SendMessageA(header, HDM_GETITEMRECT, 0, (LPARAM)&rect);
3950 ok(r, "got %d\n", r);
3951 /* some padding? */
3952 expect(2, pt.x);
3953 /* offset by header height */
3954 expect(rect.bottom - rect.top, pt.y);
3955
3956 DestroyWindow(hwnd);
3957 }
3958
3959 static void test_columnscreation(void)
3960 {
3961 HWND hwnd, header;
3962 DWORD r;
3963
3964 hwnd = create_listview_control(LVS_REPORT);
3965 ok(hwnd != NULL, "failed to create a listview window\n");
3966
3967 insert_item(hwnd, 0);
3968
3969 /* headers columns aren't created automatically */
3970 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
3971 ok(IsWindow(header), "Expected header handle\n");
3972 r = SendMessageA(header, HDM_GETITEMCOUNT, 0, 0);
3973 expect(0, r);
3974
3975 DestroyWindow(hwnd);
3976 }
3977
3978 static void test_getitemrect(void)
3979 {
3980 HWND hwnd;
3981 HIMAGELIST himl, himl_ret;
3982 HBITMAP hbm;
3983 RECT rect;
3984 DWORD r;
3985 LVITEMA item;
3986 LVCOLUMNA col;
3987 INT order[2];
3988 POINT pt;
3989
3990 /* rectangle isn't empty for empty text items */
3991 hwnd = create_listview_control(LVS_LIST);
3992 memset(&item, 0, sizeof(item));
3993 item.mask = 0;
3994 item.iItem = 0;
3995 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
3996 expect(0, r);
3997 rect.left = LVIR_LABEL;
3998 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
3999 expect(TRUE, r);
4000 expect(0, rect.left);
4001 expect(0, rect.top);
4002 /* estimate it as width / height ratio */
4003 todo_wine
4004 ok((rect.right / rect.bottom) >= 5, "got right %d, bottom %d\n", rect.right, rect.bottom);
4005 DestroyWindow(hwnd);
4006
4007 hwnd = create_listview_control(LVS_REPORT);
4008 ok(hwnd != NULL, "failed to create a listview window\n");
4009
4010 /* empty item */
4011 memset(&item, 0, sizeof(item));
4012 item.iItem = 0;
4013 item.iSubItem = 0;
4014 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
4015 expect(0, r);
4016
4017 SetRect(&rect, LVIR_BOUNDS, -1, -1, -1);
4018 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4019 expect(TRUE, r);
4020
4021 /* zero width rectangle with no padding */
4022 expect(0, rect.left);
4023 expect(0, rect.right);
4024
4025 insert_column(hwnd, 0);
4026 insert_column(hwnd, 1);
4027
4028 col.mask = LVCF_WIDTH;
4029 col.cx = 50;
4030 r = SendMessageA(hwnd, LVM_SETCOLUMNA, 0, (LPARAM)&col);
4031 expect(TRUE, r);
4032
4033 col.mask = LVCF_WIDTH;
4034 col.cx = 100;
4035 r = SendMessageA(hwnd, LVM_SETCOLUMNA, 1, (LPARAM)&col);
4036 expect(TRUE, r);
4037
4038 SetRect(&rect, LVIR_BOUNDS, -1, -1, -1);
4039 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4040 expect(TRUE, r);
4041
4042 /* still no left padding */
4043 expect(0, rect.left);
4044 expect(150, rect.right);
4045
4046 SetRect(&rect, LVIR_SELECTBOUNDS, -1, -1, -1);
4047 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4048 expect(TRUE, r);
4049 /* padding */
4050 expect(2, rect.left);
4051
4052 SetRect(&rect, LVIR_LABEL, -1, -1, -1);
4053 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4054 expect(TRUE, r);
4055 /* padding, column width */
4056 expect(2, rect.left);
4057 expect(50, rect.right);
4058
4059 /* no icons attached */
4060 SetRect(&rect, LVIR_ICON, -1, -1, -1);
4061 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4062 expect(TRUE, r);
4063 /* padding */
4064 expect(2, rect.left);
4065 expect(2, rect.right);
4066
4067 /* change order */
4068 order[0] = 1; order[1] = 0;
4069 r = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
4070 expect(TRUE, r);
4071 pt.x = -1;
4072 r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
4073 expect(TRUE, r);
4074 /* 1 indexed column width + padding */
4075 expect(102, pt.x);
4076 /* rect is at zero too */
4077 SetRect(&rect, LVIR_BOUNDS, -1, -1, -1);
4078 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4079 expect(TRUE, r);
4080 expect(0, rect.left);
4081 /* just width sum */
4082 expect(150, rect.right);
4083
4084 SetRect(&rect, LVIR_SELECTBOUNDS, -1, -1, -1);
4085 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4086 expect(TRUE, r);
4087 /* column width + padding */
4088 expect(102, rect.left);
4089
4090 /* back to initial order */
4091 order[0] = 0; order[1] = 1;
4092 r = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
4093 expect(TRUE, r);
4094
4095 /* state icons */
4096 himl = pImageList_Create(16, 16, 0, 2, 2);
4097 ok(himl != NULL, "failed to create imagelist\n");
4098 hbm = CreateBitmap(16, 16, 1, 1, NULL);
4099 ok(hbm != NULL, "failed to create bitmap\n");
4100 r = pImageList_Add(himl, hbm, 0);
4101 expect(0, r);
4102 hbm = CreateBitmap(16, 16, 1, 1, NULL);
4103 ok(hbm != NULL, "failed to create bitmap\n");
4104 r = pImageList_Add(himl, hbm, 0);
4105 expect(1, r);
4106
4107 r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
4108 expect(0, r);
4109
4110 item.mask = LVIF_STATE;
4111 item.state = INDEXTOSTATEIMAGEMASK(1);
4112 item.stateMask = LVIS_STATEIMAGEMASK;
4113 item.iItem = 0;
4114 item.iSubItem = 0;
4115 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
4116 expect(TRUE, r);
4117
4118 /* icon bounds */
4119 SetRect(&rect, LVIR_ICON, -1, -1, -1);
4120 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4121 expect(TRUE, r);
4122 /* padding + stateicon width */
4123 expect(18, rect.left);
4124 expect(18, rect.right);
4125 /* label bounds */
4126 SetRect(&rect, LVIR_LABEL, -1, -1, -1);
4127 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4128 expect(TRUE, r);
4129 /* padding + stateicon width -> column width */
4130 expect(18, rect.left);
4131 expect(50, rect.right);
4132
4133 himl_ret = (HIMAGELIST)SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
4134 ok(himl_ret == himl, "got %p, expected %p\n", himl_ret, himl);
4135
4136 r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
4137 expect(0, r);
4138
4139 item.mask = LVIF_STATE | LVIF_IMAGE;
4140 item.iImage = 1;
4141 item.state = 0;
4142 item.stateMask = ~0;
4143 item.iItem = 0;
4144 item.iSubItem = 0;
4145 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
4146 expect(TRUE, r);
4147
4148 /* icon bounds */
4149 SetRect(&rect, LVIR_ICON, -1, -1, -1);
4150 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4151 expect(TRUE, r);
4152 /* padding, icon width */
4153 expect(2, rect.left);
4154 expect(18, rect.right);
4155 /* label bounds */
4156 SetRect(&rect, LVIR_LABEL, -1, -1, -1);
4157 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4158 expect(TRUE, r);
4159 /* padding + icon width -> column width */
4160 expect(18, rect.left);
4161 expect(50, rect.right);
4162
4163 /* select bounds */
4164 SetRect(&rect, LVIR_SELECTBOUNDS, -1, -1, -1);
4165 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4166 expect(TRUE, r);
4167 /* padding, column width */
4168 expect(2, rect.left);
4169 expect(50, rect.right);
4170
4171 /* try with indentation */
4172 item.mask = LVIF_INDENT;
4173 item.iIndent = 1;
4174 item.iItem = 0;
4175 item.iSubItem = 0;
4176 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
4177 expect(TRUE, r);
4178
4179 /* bounds */
4180 SetRect(&rect, LVIR_BOUNDS, -1, -1, -1);
4181 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4182 expect(TRUE, r);
4183 /* padding + 1 icon width, column width */
4184 expect(0, rect.left);
4185 expect(150, rect.right);
4186
4187 /* select bounds */
4188 SetRect(&rect, LVIR_SELECTBOUNDS, -1, -1, -1);
4189 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4190 expect(TRUE, r);
4191 /* padding + 1 icon width, column width */
4192 expect(2 + 16, rect.left);
4193 expect(50, rect.right);
4194
4195 /* label bounds */
4196 SetRect(&rect, LVIR_LABEL, -1, -1, -1);
4197 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4198 expect(TRUE, r);
4199 /* padding + 2 icon widths, column width */
4200 expect(2 + 16*2, rect.left);
4201 expect(50, rect.right);
4202
4203 /* icon bounds */
4204 SetRect(&rect, LVIR_ICON, -1, -1, -1);
4205 r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
4206 expect(TRUE, r);
4207 /* padding + 1 icon width indentation, icon width */
4208 expect(2 + 16, rect.left);
4209 expect(34, rect.right);
4210
4211 DestroyWindow(hwnd);
4212 }
4213
4214 static void test_editbox(void)
4215 {
4216 static CHAR testitemA[] = "testitem";
4217 static CHAR testitem1A[] = "testitem_quitelongname";
4218 static CHAR testitem2A[] = "testITEM_quitelongname";
4219 static CHAR buffer[25];
4220 HWND hwnd, hwndedit, hwndedit2, header;
4221 LVITEMA item;
4222 INT r;
4223
4224 hwnd = create_listview_control(LVS_EDITLABELS | LVS_REPORT);
4225 ok(hwnd != NULL, "failed to create a listview window\n");
4226
4227 insert_column(hwnd, 0);
4228
4229 memset(&item, 0, sizeof(item));
4230 item.mask = LVIF_TEXT;
4231 item.pszText = testitemA;
4232 item.iItem = 0;
4233 item.iSubItem = 0;
4234 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
4235 expect(0, r);
4236
4237 /* test notifications without edit created */
4238 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4239 r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)0xdeadbeef);
4240 expect(0, r);
4241 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
4242 "edit box WM_COMMAND (EN_SETFOCUS), no edit created", FALSE);
4243 /* same thing but with valid window */
4244 hwndedit = CreateWindowA(WC_EDITA, "Test edit", WS_VISIBLE | WS_CHILD, 0, 0, 20,
4245 10, hwnd, (HMENU)1, (HINSTANCE)GetWindowLongPtrA(hwnd, GWLP_HINSTANCE), 0);
4246 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4247 r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)hwndedit);
4248 expect(0, r);
4249 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
4250 "edit box WM_COMMAND (EN_SETFOCUS), no edit created #2", FALSE);
4251 DestroyWindow(hwndedit);
4252
4253 /* setting focus is necessary */
4254 SetFocus(hwnd);
4255 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4256 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4257
4258 /* test children Z-order after Edit box created */
4259 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4260 ok(IsWindow(header), "Expected header to be created\n");
4261 ok(GetTopWindow(hwnd) == header, "Expected header to be on top\n");
4262 ok(GetNextWindow(header, GW_HWNDNEXT) == hwndedit, "got %p\n", GetNextWindow(header, GW_HWNDNEXT));
4263
4264 /* modify initial string */
4265 r = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
4266 expect(TRUE, r);
4267
4268 /* edit window is resized and repositioned,
4269 check again for Z-order - it should be preserved */
4270 ok(GetTopWindow(hwnd) == header, "Expected header to be on top\n");
4271 ok(GetNextWindow(header, GW_HWNDNEXT) == hwndedit, "got %p\n", GetNextWindow(header, GW_HWNDNEXT));
4272
4273 /* return focus to listview */
4274 SetFocus(hwnd);
4275
4276 memset(&item, 0, sizeof(item));
4277 item.mask = LVIF_TEXT;
4278 item.pszText = buffer;
4279 item.cchTextMax = sizeof(buffer);
4280 item.iItem = 0;
4281 item.iSubItem = 0;
4282 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
4283 expect(TRUE, r);
4284
4285 ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
4286
4287 /* send LVM_EDITLABEL on already created edit */
4288 SetFocus(hwnd);
4289 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4290 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4291 /* focus will be set to edit */
4292 ok(GetFocus() == hwndedit, "Expected Edit window to be focused\n");
4293 hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4294 ok(IsWindow(hwndedit2), "Expected Edit window to be created\n");
4295
4296 /* creating label disabled when control isn't focused */
4297 SetFocus(0);
4298 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4299 todo_wine ok(hwndedit == NULL, "Expected Edit window not to be created\n");
4300
4301 /* check EN_KILLFOCUS handling */
4302 memset(&item, 0, sizeof(item));
4303 item.pszText = testitemA;
4304 item.iItem = 0;
4305 item.iSubItem = 0;
4306 r = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
4307 expect(TRUE, r);
4308
4309 SetFocus(hwnd);
4310 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4311 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4312 /* modify edit and notify control that it lost focus */
4313 r = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
4314 expect(TRUE, r);
4315 g_editbox_disp_info.item.pszText = NULL;
4316 r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
4317 expect(0, r);
4318 ok(g_editbox_disp_info.item.pszText != NULL, "expected notification with not null text\n");
4319
4320 memset(&item, 0, sizeof(item));
4321 item.pszText = buffer;
4322 item.cchTextMax = sizeof(buffer);
4323 item.iItem = 0;
4324 item.iSubItem = 0;
4325 r = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
4326 expect(lstrlenA(item.pszText), r);
4327 ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
4328 ok(!IsWindow(hwndedit), "Expected Edit window to be freed\n");
4329
4330 /* change item name to differ in casing only */
4331 SetFocus(hwnd);
4332 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4333 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4334 /* modify edit and notify control that it lost focus */
4335 r = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem2A);
4336 expect(TRUE, r);
4337 g_editbox_disp_info.item.pszText = NULL;
4338 r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
4339 expect(0, r);
4340 ok(g_editbox_disp_info.item.pszText != NULL, "got %p\n", g_editbox_disp_info.item.pszText);
4341
4342 memset(&item, 0, sizeof(item));
4343 item.pszText = buffer;
4344 item.cchTextMax = sizeof(buffer);
4345 item.iItem = 0;
4346 item.iSubItem = 0;
4347 r = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
4348 expect(lstrlenA(item.pszText), r);
4349 ok(strcmp(buffer, testitem2A) == 0, "got %s, expected %s\n", buffer, testitem2A);
4350 ok(!IsWindow(hwndedit), "Expected Edit window to be freed\n");
4351
4352 /* end edit without saving */
4353 SetFocus(hwnd);
4354 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4355 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4356 r = SendMessageA(hwndedit, WM_KEYDOWN, VK_ESCAPE, 0);
4357 expect(0, r);
4358 ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
4359 "edit box - end edit, no change, escape", TRUE);
4360 /* end edit with saving */
4361 SetFocus(hwnd);
4362 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4363 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4364 r = SendMessageA(hwndedit, WM_KEYDOWN, VK_RETURN, 0);
4365 expect(0, r);
4366 ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
4367 "edit box - end edit, no change, return", TRUE);
4368
4369 memset(&item, 0, sizeof(item));
4370 item.pszText = buffer;
4371 item.cchTextMax = sizeof(buffer);
4372 item.iItem = 0;
4373 item.iSubItem = 0;
4374 r = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
4375 expect(lstrlenA(item.pszText), r);
4376 ok(strcmp(buffer, testitem2A) == 0, "Expected item text to change\n");
4377
4378 /* LVM_EDITLABEL with -1 destroys current edit */
4379 hwndedit = (HWND)SendMessageA(hwnd, LVM_GETEDITCONTROL, 0, 0);
4380 ok(hwndedit == NULL, "Expected Edit window not to be created\n");
4381 /* no edit present */
4382 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, -1, 0);
4383 ok(hwndedit == NULL, "Expected Edit window not to be created\n");
4384 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4385 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4386 /* edit present */
4387 ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
4388 hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, -1, 0);
4389 ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
4390 ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
4391 ok(GetFocus() == hwnd, "Expected List to be focused\n");
4392 /* check another negative value */
4393 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4394 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4395 ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
4396 hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, -2, 0);
4397 ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
4398 ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
4399 ok(GetFocus() == hwnd, "Expected List to be focused\n");
4400 /* and value greater than max item index */
4401 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4402 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4403 ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
4404 r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
4405 hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, r, 0);
4406 ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
4407 ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
4408 ok(GetFocus() == hwnd, "Expected List to be focused\n");
4409
4410 /* messaging tests */
4411 SetFocus(hwnd);
4412 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4413 blockEdit = FALSE;
4414 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4415 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4416 /* testing only sizing messages */
4417 ok_sequence(sequences, EDITBOX_SEQ_INDEX, editbox_create_pos,
4418 "edit box create - sizing", FALSE);
4419
4420 /* WM_COMMAND with EN_KILLFOCUS isn't forwarded to parent */
4421 SetFocus(hwnd);
4422 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4423 ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
4424 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4425 r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
4426 expect(0, r);
4427 ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
4428 "edit box WM_COMMAND (EN_KILLFOCUS)", TRUE);
4429
4430 DestroyWindow(hwnd);
4431 }
4432
4433 static void test_notifyformat(void)
4434 {
4435 HWND hwnd, header;
4436 DWORD r;
4437
4438 hwnd = create_listview_control(LVS_REPORT);
4439 ok(hwnd != NULL, "failed to create a listview window\n");
4440
4441 /* CCM_GETUNICODEFORMAT == LVM_GETUNICODEFORMAT,
4442 CCM_SETUNICODEFORMAT == LVM_SETUNICODEFORMAT */
4443 r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4444 expect(0, r);
4445 SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
4446 /* set */
4447 r = SendMessageA(hwnd, LVM_SETUNICODEFORMAT, 1, 0);
4448 expect(0, r);
4449 r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4450 ok(r == 1, "Unexpected return value %d.\n", r);
4451 r = SendMessageA(hwnd, LVM_SETUNICODEFORMAT, 0, 0);
4452 expect(1, r);
4453 r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4454 expect(0, r);
4455
4456 DestroyWindow(hwnd);
4457
4458 /* test failure in parent WM_NOTIFYFORMAT */
4459 notifyFormat = 0;
4460 hwnd = create_listview_control(LVS_REPORT);
4461 ok(hwnd != NULL, "failed to create a listview window\n");
4462 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4463 ok(IsWindow(header), "expected header to be created\n");
4464 r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4465 expect(0, r);
4466 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4467 ok( r == 1, "Expected 1, got %d\n", r );
4468 r = SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
4469 ok(r != 0, "Expected valid format\n");
4470
4471 notifyFormat = NFR_UNICODE;
4472 r = SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
4473 expect(NFR_UNICODE, r);
4474 r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4475 expect(1, r);
4476 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4477 ok( r == 1, "Expected 1, got %d\n", r );
4478
4479 notifyFormat = NFR_ANSI;
4480 r = SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
4481 expect(NFR_ANSI, r);
4482 r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4483 expect(0, r);
4484 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4485 ok( r == 1, "Expected 1, got %d\n", r );
4486
4487 DestroyWindow(hwnd);
4488
4489 hwndparentW = create_parent_window(TRUE);
4490 ok(IsWindow(hwndparentW), "Unicode parent creation failed\n");
4491 if (!IsWindow(hwndparentW)) return;
4492
4493 notifyFormat = -1;
4494 hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
4495 ok(hwnd != NULL, "failed to create a listview window\n");
4496 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4497 ok(IsWindow(header), "expected header to be created\n");
4498 r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4499 expect(1, r);
4500 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4501 expect(1, r);
4502 DestroyWindow(hwnd);
4503 /* receiving error code defaulting to ansi */
4504 notifyFormat = 0;
4505 hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
4506 ok(hwnd != NULL, "failed to create a listview window\n");
4507 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4508 ok(IsWindow(header), "expected header to be created\n");
4509 r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4510 expect(0, r);
4511 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4512 expect(1, r);
4513 DestroyWindow(hwnd);
4514 /* receiving ansi code from unicode window, use it */
4515 notifyFormat = NFR_ANSI;
4516 hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
4517 ok(hwnd != NULL, "failed to create a listview window\n");
4518 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4519 ok(IsWindow(header), "expected header to be created\n");
4520 r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4521 expect(0, r);
4522 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4523 expect(1, r);
4524 DestroyWindow(hwnd);
4525 /* unicode listview with ansi parent window */
4526 notifyFormat = -1;
4527 hwnd = create_listview_controlW(LVS_REPORT, hwndparent);
4528 ok(hwnd != NULL, "failed to create a listview window\n");
4529 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4530 ok(IsWindow(header), "expected header to be created\n");
4531 r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4532 expect(0, r);
4533 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4534 expect(1, r);
4535 DestroyWindow(hwnd);
4536 /* unicode listview with ansi parent window, return error code */
4537 notifyFormat = 0;
4538 hwnd = create_listview_controlW(LVS_REPORT, hwndparent);
4539 ok(hwnd != NULL, "failed to create a listview window\n");
4540 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
4541 ok(IsWindow(header), "expected header to be created\n");
4542 r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
4543 expect(0, r);
4544 r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
4545 expect(1, r);
4546 DestroyWindow(hwnd);
4547
4548 DestroyWindow(hwndparentW);
4549 }
4550
4551 static void test_indentation(void)
4552 {
4553 HWND hwnd;
4554 LVITEMA item;
4555 DWORD r;
4556
4557 hwnd = create_listview_control(LVS_REPORT);
4558 ok(hwnd != NULL, "failed to create a listview window\n");
4559
4560 memset(&item, 0, sizeof(item));
4561 item.mask = LVIF_INDENT;
4562 item.iItem = 0;
4563 item.iIndent = I_INDENTCALLBACK;
4564 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
4565 expect(0, r);
4566
4567 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4568
4569 item.iItem = 0;
4570 item.mask = LVIF_INDENT;
4571 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
4572 expect(TRUE, r);
4573
4574 ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
4575 "get indent dispinfo", FALSE);
4576
4577 DestroyWindow(hwnd);
4578 }
4579
4580 static INT CALLBACK DummyCompareEx(LPARAM first, LPARAM second, LPARAM param)
4581 {
4582 return 0;
4583 }
4584
4585 static BOOL is_below_comctl_5(void)
4586 {
4587 HWND hwnd;
4588 BOOL ret;
4589
4590 hwnd = create_listview_control(LVS_REPORT);
4591 ok(hwnd != NULL, "failed to create a listview window\n");
4592 insert_item(hwnd, 0);
4593
4594 ret = SendMessageA(hwnd, LVM_SORTITEMSEX, 0, (LPARAM)&DummyCompareEx);
4595
4596 DestroyWindow(hwnd);
4597
4598 return !ret;
4599 }
4600
4601 static void test_get_set_view(void)
4602 {
4603 HWND hwnd;
4604 DWORD ret;
4605 DWORD_PTR style;
4606
4607 /* test style->view mapping */
4608 hwnd = create_listview_control(LVS_REPORT);
4609 ok(hwnd != NULL, "failed to create a listview window\n");
4610
4611 ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
4612 expect(LV_VIEW_DETAILS, ret);
4613
4614 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4615 /* LVS_ICON == 0 */
4616 SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_REPORT);
4617 ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
4618 expect(LV_VIEW_ICON, ret);
4619
4620 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4621 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SMALLICON);
4622 ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
4623 expect(LV_VIEW_SMALLICON, ret);
4624
4625 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4626 SetWindowLongPtrA(hwnd, GWL_STYLE, (style & ~LVS_SMALLICON) | LVS_LIST);
4627 ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
4628 expect(LV_VIEW_LIST, ret);
4629
4630 /* switching view doesn't touch window style */
4631 ret = SendMessageA(hwnd, LVM_SETVIEW, LV_VIEW_DETAILS, 0);
4632 expect(1, ret);
4633 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4634 ok(style & LVS_LIST, "Expected style to be preserved\n");
4635 ret = SendMessageA(hwnd, LVM_SETVIEW, LV_VIEW_ICON, 0);
4636 expect(1, ret);
4637 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4638 ok(style & LVS_LIST, "Expected style to be preserved\n");
4639 ret = SendMessageA(hwnd, LVM_SETVIEW, LV_VIEW_SMALLICON, 0);
4640 expect(1, ret);
4641 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4642 ok(style & LVS_LIST, "Expected style to be preserved\n");
4643
4644 /* now change window style to see if view is remapped */
4645 style = GetWindowLongPtrA(hwnd, GWL_STYLE);
4646 SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SHOWSELALWAYS);
4647 ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
4648 expect(LV_VIEW_SMALLICON, ret);
4649
4650 DestroyWindow(hwnd);
4651 }
4652
4653 static void test_canceleditlabel(void)
4654 {
4655 HWND hwnd, hwndedit;
4656 DWORD ret;
4657 CHAR buff[10];
4658 LVITEMA itema;
4659 static CHAR test[] = "test";
4660 static const CHAR test1[] = "test1";
4661
4662 hwnd = create_listview_control(LVS_EDITLABELS | LVS_REPORT);
4663 ok(hwnd != NULL, "failed to create a listview window\n");
4664
4665 insert_item(hwnd, 0);
4666
4667 /* try without edit created */
4668 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4669 ret = SendMessageA(hwnd, LVM_CANCELEDITLABEL, 0, 0);
4670 expect(TRUE, ret);
4671 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
4672 "cancel edit label without edit", FALSE);
4673
4674 /* cancel without data change */
4675 SetFocus(hwnd);
4676 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4677 ok(IsWindow(hwndedit), "Expected edit control to be created\n");
4678 ret = SendMessageA(hwnd, LVM_CANCELEDITLABEL, 0, 0);
4679 expect(TRUE, ret);
4680 ok(!IsWindow(hwndedit), "Expected edit control to be destroyed\n");
4681
4682 /* cancel after data change */
4683 memset(&itema, 0, sizeof(itema));
4684 itema.pszText = test;
4685 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&itema);
4686 expect(TRUE, ret);
4687 SetFocus(hwnd);
4688 hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
4689 ok(IsWindow(hwndedit), "Expected edit control to be created\n");
4690 ret = SetWindowTextA(hwndedit, test1);
4691 expect(1, ret);
4692 ret = SendMessageA(hwnd, LVM_CANCELEDITLABEL, 0, 0);
4693 expect(TRUE, ret);
4694 ok(!IsWindow(hwndedit), "Expected edit control to be destroyed\n");
4695 memset(&itema, 0, sizeof(itema));
4696 itema.pszText = buff;
4697 itema.cchTextMax = ARRAY_SIZE(buff);
4698 ret = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&itema);
4699 expect(5, ret);
4700 ok(strcmp(buff, test1) == 0, "Expected label text not to change\n");
4701
4702 DestroyWindow(hwnd);
4703 }
4704
4705 static void test_mapidindex(void)
4706 {
4707 HWND hwnd;
4708 INT ret;
4709
4710 /* LVM_MAPINDEXTOID unsupported with LVS_OWNERDATA */
4711 hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
4712 ok(hwnd != NULL, "failed to create a listview window\n");
4713 insert_item(hwnd, 0);
4714 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
4715 expect(-1, ret);
4716 DestroyWindow(hwnd);
4717
4718 hwnd = create_listview_control(LVS_REPORT);
4719 ok(hwnd != NULL, "failed to create a listview window\n");
4720
4721 /* LVM_MAPINDEXTOID with invalid index */
4722 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
4723 expect(-1, ret);
4724
4725 insert_item(hwnd, 0);
4726 insert_item(hwnd, 1);
4727
4728 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, -1, 0);
4729 expect(-1, ret);
4730 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 2, 0);
4731 expect(-1, ret);
4732
4733 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
4734 expect(0, ret);
4735 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 1, 0);
4736 expect(1, ret);
4737 /* remove 0 indexed item, id retained */
4738 SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
4739 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
4740 expect(1, ret);
4741 /* new id starts from previous value */
4742 insert_item(hwnd, 1);
4743 ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 1, 0);
4744 expect(2, ret);
4745
4746 /* get index by id */
4747 ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, -1, 0);
4748 expect(-1, ret);
4749 ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, 0, 0);
4750 expect(-1, ret);
4751 ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, 1, 0);
4752 expect(0, ret);
4753 ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, 2, 0);
4754 expect(1, ret);
4755
4756 DestroyWindow(hwnd);
4757 }
4758
4759 static void test_getitemspacing(void)
4760 {
4761 HWND hwnd;
4762 DWORD ret;
4763 INT cx, cy;
4764 HIMAGELIST himl40, himl80;
4765
4766 cx = GetSystemMetrics(SM_CXICONSPACING) - GetSystemMetrics(SM_CXICON);
4767 cy = GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
4768
4769 /* LVS_ICON */
4770 hwnd = create_listview_control(LVS_ICON);
4771 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4772 expect(cx, LOWORD(ret));
4773 expect(cy, HIWORD(ret));
4774
4775 /* now try with icons */
4776 himl40 = pImageList_Create(40, 40, 0, 4, 4);
4777 ok(himl40 != NULL, "failed to create imagelist\n");
4778 himl80 = pImageList_Create(80, 80, 0, 4, 4);
4779 ok(himl80 != NULL, "failed to create imagelist\n");
4780 ret = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
4781 expect(0, ret);
4782
4783 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4784 /* spacing + icon size returned */
4785 expect(cx + 40, LOWORD(ret));
4786 expect(cy + 40, HIWORD(ret));
4787 /* try changing icon size */
4788 SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl80);
4789
4790 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4791 /* spacing + icon size returned */
4792 expect(cx + 80, LOWORD(ret));
4793 expect(cy + 80, HIWORD(ret));
4794
4795 /* set own icon spacing */
4796 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(100, 100));
4797 expect(cx + 80, LOWORD(ret));
4798 expect(cy + 80, HIWORD(ret));
4799
4800 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4801 /* set size returned */
4802 expect(100, LOWORD(ret));
4803 expect(100, HIWORD(ret));
4804
4805 /* now change image list - icon spacing should be unaffected */
4806 SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
4807
4808 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4809 /* set size returned */
4810 expect(100, LOWORD(ret));
4811 expect(100, HIWORD(ret));
4812
4813 /* spacing = 0 - keep previous value */
4814 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(0, -1));
4815 expect(100, LOWORD(ret));
4816 expect(100, HIWORD(ret));
4817
4818 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4819 expect(100, LOWORD(ret));
4820
4821 expect(0xFFFF, HIWORD(ret));
4822
4823 if (sizeof(void*) == 8)
4824 {
4825 /* NOTE: -1 is not treated the same as (DWORD)-1 by 64bit listview */
4826 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, (DWORD)-1);
4827 expect(100, LOWORD(ret));
4828 expect(0xFFFF, HIWORD(ret));
4829
4830 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, -1);
4831 expect(0xFFFF, LOWORD(ret));
4832 expect(0xFFFF, HIWORD(ret));
4833 }
4834 else
4835 {
4836 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, -1);
4837 expect(100, LOWORD(ret));
4838 expect(0xFFFF, HIWORD(ret));
4839 }
4840 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4841 /* spacing + icon size returned */
4842 expect(cx + 40, LOWORD(ret));
4843 expect(cy + 40, HIWORD(ret));
4844
4845 SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, 0);
4846 pImageList_Destroy(himl80);
4847 DestroyWindow(hwnd);
4848 /* LVS_SMALLICON */
4849 hwnd = create_listview_control(LVS_SMALLICON);
4850 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4851 expect(cx, LOWORD(ret));
4852 expect(cy, HIWORD(ret));
4853
4854 /* spacing does not depend on selected view type */
4855 ret = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
4856 expect(0, ret);
4857
4858 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4859 /* spacing + icon size returned */
4860 expect(cx + 40, LOWORD(ret));
4861 expect(cy + 40, HIWORD(ret));
4862
4863 SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, 0);
4864 pImageList_Destroy(himl40);
4865 DestroyWindow(hwnd);
4866 /* LVS_REPORT */
4867 hwnd = create_listview_control(LVS_REPORT);
4868 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4869 expect(cx, LOWORD(ret));
4870 expect(cy, HIWORD(ret));
4871
4872 DestroyWindow(hwnd);
4873 /* LVS_LIST */
4874 hwnd = create_listview_control(LVS_LIST);
4875 ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
4876 expect(cx, LOWORD(ret));
4877 expect(cy, HIWORD(ret));
4878
4879 DestroyWindow(hwnd);
4880 }
4881
4882 static INT get_current_font_height(HWND listview)
4883 {
4884 TEXTMETRICA tm;
4885 HFONT hfont;
4886 HWND hwnd;
4887 HDC hdc;
4888
4889 hwnd = (HWND)SendMessageA(listview, LVM_GETHEADER, 0, 0);
4890 if (!hwnd)
4891 hwnd = listview;
4892
4893 hfont = (HFONT)SendMessageA(hwnd, WM_GETFONT, 0, 0);
4894 if (!hfont) {
4895 hdc = GetDC(hwnd);
4896 GetTextMetricsA(hdc, &tm);
4897 ReleaseDC(hwnd, hdc);
4898 }
4899 else {
4900 HFONT oldfont;
4901
4902 hdc = GetDC(0);
4903 oldfont = SelectObject(hdc, hfont);
4904 GetTextMetricsA(hdc, &tm);
4905 SelectObject(hdc, oldfont);
4906 ReleaseDC(0, hdc);
4907 }
4908
4909 return tm.tmHeight;
4910 }
4911
4912 static void test_getcolumnwidth(void)
4913 {
4914 HWND hwnd;
4915 INT ret;
4916 DWORD_PTR style;
4917 LVCOLUMNA col;
4918 LVITEMA itema;
4919 INT height;
4920
4921 /* default column width */
4922 hwnd = create_listview_control(LVS_ICON);
4923 ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4924 expect(0, ret);
4925 style = GetWindowLongA(hwnd, GWL_STYLE);
4926 SetWindowLongA(hwnd, GWL_STYLE, style | LVS_LIST);
4927 ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4928 todo_wine expect(8, ret);
4929 style = GetWindowLongA(hwnd, GWL_STYLE) & ~LVS_LIST;
4930 SetWindowLongA(hwnd, GWL_STYLE, style | LVS_REPORT);
4931 col.mask = 0;
4932 ret = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
4933 expect(0, ret);
4934 ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4935 expect(10, ret);
4936 DestroyWindow(hwnd);
4937
4938 /* default column width with item added */
4939 hwnd = create_listview_control(LVS_LIST);
4940 memset(&itema, 0, sizeof(itema));
4941 ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
4942 ok(!ret, "got %d\n", ret);
4943 ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
4944 height = get_current_font_height(hwnd);
4945 ok((ret / height) >= 6, "got width %d, height %d\n", ret, height);
4946 DestroyWindow(hwnd);
4947 }
4948
4949 static void test_scrollnotify(void)
4950 {
4951 HWND hwnd;
4952 DWORD ret;
4953
4954 hwnd = create_listview_control(LVS_REPORT);
4955
4956 insert_column(hwnd, 0);
4957 insert_column(hwnd, 1);
4958 insert_item(hwnd, 0);
4959
4960 /* make it scrollable - resize */
4961 ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
4962 expect(TRUE, ret);
4963 ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
4964 expect(TRUE, ret);
4965
4966 /* try with dummy call */
4967 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4968 ret = SendMessageA(hwnd, LVM_SCROLL, 0, 0);
4969 expect(TRUE, ret);
4970 ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
4971 "scroll notify 1", TRUE);
4972
4973 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4974 ret = SendMessageA(hwnd, LVM_SCROLL, 1, 0);
4975 expect(TRUE, ret);
4976 ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
4977 "scroll notify 2", TRUE);
4978
4979 flush_sequences(sequences, NUM_MSG_SEQUENCES);
4980 ret = SendMessageA(hwnd, LVM_SCROLL, 1, 1);
4981 expect(TRUE, ret);
4982 ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
4983 "scroll notify 3", TRUE);
4984
4985 DestroyWindow(hwnd);
4986 }
4987
4988 static void test_LVS_EX_TRANSPARENTBKGND(void)
4989 {
4990 HWND hwnd;
4991 DWORD ret;
4992 HDC hdc;
4993
4994 hwnd = create_listview_control(LVS_REPORT);
4995
4996 ret = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
4997 expect(TRUE, ret);
4998
4999 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
5000 LVS_EX_TRANSPARENTBKGND);
5001
5002 ret = SendMessageA(hwnd, LVM_GETBKCOLOR, 0, 0);
5003 if (ret != CLR_NONE)
5004 {
5005 win_skip("LVS_EX_TRANSPARENTBKGND unsupported\n");
5006 DestroyWindow(hwnd);
5007 return;
5008 }
5009
5010 /* try to set some back color and check this style bit */
5011 ret = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
5012 expect(TRUE, ret);
5013 ret = SendMessageA(hwnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
5014 ok(!(ret & LVS_EX_TRANSPARENTBKGND), "Expected LVS_EX_TRANSPARENTBKGND to unset\n");
5015
5016 /* now test what this style actually does */
5017 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
5018 LVS_EX_TRANSPARENTBKGND);
5019
5020 hdc = GetWindowDC(hwndparent);
5021
5022 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5023 SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
5024 ok_sequence(sequences, PARENT_SEQ_INDEX, lvs_ex_transparentbkgnd_seq,
5025 "LVS_EX_TRANSPARENTBKGND parent", FALSE);
5026
5027 ReleaseDC(hwndparent, hdc);
5028
5029 DestroyWindow(hwnd);
5030 }
5031
5032 static void test_approximate_viewrect(void)
5033 {
5034 static CHAR test[] = "abracadabra, a very long item label";
5035 DWORD item_width, item_height, header_height;
5036 static CHAR column_header[] = "Header";
5037 unsigned const column_width = 100;
5038 DWORD ret, item_count;
5039 HIMAGELIST himl;
5040 LVITEMA itema;
5041 LVCOLUMNA col;
5042 HBITMAP hbmp;
5043 HWND hwnd;
5044
5045 /* LVS_ICON */
5046 hwnd = create_listview_control(LVS_ICON);
5047 himl = pImageList_Create(40, 40, 0, 4, 4);
5048 ok(himl != NULL, "failed to create imagelist\n");
5049 hbmp = CreateBitmap(40, 40, 1, 1, NULL);
5050 ok(hbmp != NULL, "failed to create bitmap\n");
5051 ret = pImageList_Add(himl, hbmp, 0);
5052 expect(0, ret);
5053 ret = SendMessageA(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
5054 expect(0, ret);
5055
5056 itema.mask = LVIF_IMAGE;
5057 itema.iImage = 0;
5058 itema.iItem = 0;
5059 itema.iSubItem = 0;
5060 ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
5061 expect(0, ret);
5062
5063 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(75, 75));
5064 ok(ret != 0, "Unexpected return value %#x.\n", ret);
5065
5066 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
5067 expect(MAKELONG(77,827), ret);
5068
5069 ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(50, 50));
5070 ok(ret != 0, "got 0\n");
5071
5072 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
5073 expect(MAKELONG(102,302), ret);
5074
5075 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
5076 expect(MAKELONG(52,52), ret);
5077
5078 itema.pszText = test;
5079 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&itema);
5080 expect(TRUE, ret);
5081 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
5082 expect(MAKELONG(52,52), ret);
5083
5084 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 0, MAKELPARAM(100,100));
5085 expect(MAKELONG(52,2), ret);
5086 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 1, MAKELPARAM(100,100));
5087 expect(MAKELONG(52,52), ret);
5088 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 2, MAKELPARAM(100,100));
5089 expect(MAKELONG(102,52), ret);
5090 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 3, MAKELPARAM(100,100));
5091 expect(MAKELONG(102,102), ret);
5092 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 4, MAKELPARAM(100,100));
5093 expect(MAKELONG(102,102), ret);
5094 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 5, MAKELPARAM(100,100));
5095 expect(MAKELONG(102,152), ret);
5096 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 6, MAKELPARAM(100,100));
5097 expect(MAKELONG(102,152), ret);
5098 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 7, MAKELPARAM(160,100));
5099 expect(MAKELONG(152,152), ret);
5100
5101 DestroyWindow(hwnd);
5102
5103 /* LVS_REPORT */
5104 hwnd = create_listview_control(LVS_REPORT);
5105
5106 /* Empty control without columns */
5107 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 0, MAKELPARAM(100, 100));
5108 todo_wine
5109 ok(LOWORD(ret) == 0, "Unexpected width %d.\n", LOWORD(ret));
5110 ok(HIWORD(ret) != 0, "Unexpected height %d.\n", HIWORD(ret));
5111
5112 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 0, 0);
5113 ok(LOWORD(ret) == 0, "Unexpected width %d.\n", LOWORD(ret));
5114 todo_wine
5115 ok(HIWORD(ret) != 0, "Unexpected height %d.\n", HIWORD(ret));
5116
5117 header_height = HIWORD(ret);
5118
5119 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 1, 0);
5120 ok(LOWORD(ret) == 0, "Unexpected width %d.\n", LOWORD(ret));
5121 todo_wine
5122 ok(HIWORD(ret) > header_height, "Unexpected height %d.\n", HIWORD(ret));
5123
5124 item_height = HIWORD(ret) - header_height;
5125
5126 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -2, 0);
5127 ok(LOWORD(ret) == 0, "Unexpected width %d.\n", LOWORD(ret));
5128 ok(HIWORD(ret) == (header_height - 2 * item_height), "Unexpected height %d.\n", HIWORD(ret)) ;
5129
5130 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, 0);
5131 ok(LOWORD(ret) == 0, "Unexpected width %d.\n", LOWORD(ret));
5132 ok(HIWORD(ret) == header_height, "Unexpected height.\n");
5133 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 2, 0);
5134 ok(LOWORD(ret) == 0, "Unexpected width %d.\n", LOWORD(ret));
5135 ok(HIWORD(ret) == header_height + 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5136
5137 /* Insert column */
5138 col.mask = LVCF_TEXT | LVCF_WIDTH;
5139 col.pszText = column_header;
5140 col.cx = column_width;
5141 ret = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
5142 ok(ret == 0, "Unexpected return value %d.\n", ret);
5143
5144 /* Empty control with column */
5145 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 0, 0);
5146 todo_wine {
5147 ok(LOWORD(ret) >= column_width, "Unexpected width %d.\n", LOWORD(ret));
5148 ok(HIWORD(ret) != 0, "Unexpected height %d.\n", HIWORD(ret));
5149 }
5150 header_height = HIWORD(ret);
5151 item_width = LOWORD(ret);
5152
5153 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 1, 0);
5154 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5155 todo_wine
5156 ok(HIWORD(ret) > header_height, "Unexpected height %d.\n", HIWORD(ret));
5157
5158 item_height = HIWORD(ret) - header_height;
5159
5160 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -2, 0);
5161 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5162 ok(HIWORD(ret) == header_height - 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5163
5164 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, 0);
5165 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5166 ok(HIWORD(ret) == header_height, "Unexpected height %d.\n", HIWORD(ret));
5167
5168 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 2, 0);
5169 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5170 ok(HIWORD(ret) == header_height + 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5171
5172 for (item_count = 1; item_count <= 2; ++item_count)
5173 {
5174 itema.mask = LVIF_TEXT;
5175 itema.iItem = 0;
5176 itema.iSubItem = 0;
5177 itema.pszText = test;
5178 ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
5179 ok(ret == 0, "Unexpected return value %d.\n", ret);
5180
5181 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 0, 0);
5182 ok(LOWORD(ret) >= column_width, "Unexpected width %d.\n", LOWORD(ret));
5183 todo_wine
5184 ok(HIWORD(ret) != 0, "Unexpected height %d.\n", HIWORD(ret));
5185
5186 header_height = HIWORD(ret);
5187 item_width = LOWORD(ret);
5188
5189 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 1, 0);
5190 ok(LOWORD(ret) == item_width, "Unexpected width %d, item %d\n", LOWORD(ret), item_count - 1);
5191 ok(HIWORD(ret) > header_height, "Unexpected height %d. item %d.\n", HIWORD(ret), item_count - 1);
5192
5193 item_height = HIWORD(ret) - header_height;
5194
5195 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -2, 0);
5196 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5197 todo_wine
5198 ok(HIWORD(ret) == header_height - 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5199
5200 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, 0);
5201 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5202 ok(HIWORD(ret) == header_height + item_count * item_height, "Unexpected height %d.\n", HIWORD(ret));
5203
5204 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 2, 0);
5205 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5206 ok(HIWORD(ret) == header_height + 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5207
5208 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 2, MAKELONG(item_width * 2, header_height + 3 * item_height));
5209 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5210 ok(HIWORD(ret) == header_height + 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5211
5212 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -2, MAKELONG(item_width * 2, 0));
5213 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5214 todo_wine
5215 ok(HIWORD(ret) == header_height - 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5216
5217 ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -2, MAKELONG(-1, -1));
5218 ok(LOWORD(ret) == item_width, "Unexpected width %d.\n", LOWORD(ret));
5219 todo_wine
5220 ok(HIWORD(ret) == header_height - 2 * item_height, "Unexpected height %d.\n", HIWORD(ret));
5221 }
5222
5223 DestroyWindow(hwnd);
5224
5225 }
5226
5227 static void test_finditem(void)
5228 {
5229 LVFINDINFOA fi;
5230 static char f[5];
5231 HWND hwnd;
5232 INT r;
5233
5234 hwnd = create_listview_control(LVS_REPORT);
5235 insert_item(hwnd, 0);
5236
5237 memset(&fi, 0, sizeof(fi));
5238
5239 /* full string search, inserted text was "foo" */
5240 strcpy(f, "foo");
5241 fi.flags = LVFI_STRING;
5242 fi.psz = f;
5243 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5244 expect(0, r);
5245
5246 fi.flags = LVFI_STRING | LVFI_PARTIAL;
5247 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5248 expect(0, r);
5249
5250 fi.flags = LVFI_PARTIAL;
5251 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5252 expect(0, r);
5253
5254 /* partial string search, inserted text was "foo" */
5255 strcpy(f, "fo");
5256 fi.flags = LVFI_STRING | LVFI_PARTIAL;
5257 fi.psz = f;
5258 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5259 expect(0, r);
5260
5261 fi.flags = LVFI_STRING;
5262 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5263 expect(-1, r);
5264
5265 fi.flags = LVFI_PARTIAL;
5266 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5267 expect(0, r);
5268
5269 /* partial string search, part after start char */
5270 strcpy(f, "oo");
5271 fi.flags = LVFI_STRING | LVFI_PARTIAL;
5272 fi.psz = f;
5273 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5274 expect(-1, r);
5275
5276 /* try with LVFI_SUBSTRING */
5277 strcpy(f, "fo");
5278 fi.flags = LVFI_SUBSTRING;
5279 fi.psz = f;
5280 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5281 expect(0, r);
5282 strcpy(f, "f");
5283 fi.flags = LVFI_SUBSTRING;
5284 fi.psz = f;
5285 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5286 expect(0, r);
5287 strcpy(f, "o");
5288 fi.flags = LVFI_SUBSTRING;
5289 fi.psz = f;
5290 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5291 expect(-1, r);
5292
5293 strcpy(f, "o");
5294 fi.flags = LVFI_SUBSTRING | LVFI_PARTIAL;
5295 fi.psz = f;
5296 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5297 expect(-1, r);
5298
5299 strcpy(f, "f");
5300 fi.flags = LVFI_SUBSTRING | LVFI_STRING;
5301 fi.psz = f;
5302 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5303 expect(0, r);
5304
5305 fi.flags = LVFI_SUBSTRING | LVFI_PARTIAL;
5306 r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
5307 expect(0, r);
5308
5309 DestroyWindow(hwnd);
5310 }
5311
5312 static void test_LVS_EX_HEADERINALLVIEWS(void)
5313 {
5314 HWND hwnd, header;
5315 DWORD style;
5316
5317 hwnd = create_listview_control(LVS_ICON);
5318
5319 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
5320 LVS_EX_HEADERINALLVIEWS);
5321
5322 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5323 if (!IsWindow(header))
5324 {
5325 win_skip("LVS_EX_HEADERINALLVIEWS unsupported\n");
5326 DestroyWindow(hwnd);
5327 return;
5328 }
5329
5330 /* LVS_NOCOLUMNHEADER works as before */
5331 style = GetWindowLongA(hwnd, GWL_STYLE);
5332 SetWindowLongW(hwnd, GWL_STYLE, style | LVS_NOCOLUMNHEADER);
5333 style = GetWindowLongA(header, GWL_STYLE);
5334 ok(style & HDS_HIDDEN, "Expected HDS_HIDDEN\n");
5335 style = GetWindowLongA(hwnd, GWL_STYLE);
5336 SetWindowLongW(hwnd, GWL_STYLE, style & ~LVS_NOCOLUMNHEADER);
5337 style = GetWindowLongA(header, GWL_STYLE);
5338 ok(!(style & HDS_HIDDEN), "Expected HDS_HIDDEN to be unset\n");
5339
5340 /* try to remove style */
5341 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS, 0);
5342 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5343 ok(IsWindow(header), "Expected header to be created\n");
5344 style = GetWindowLongA(header, GWL_STYLE);
5345 ok(!(style & HDS_HIDDEN), "HDS_HIDDEN not expected\n");
5346
5347 DestroyWindow(hwnd);
5348
5349 /* check other styles */
5350 hwnd = create_listview_control(LVS_LIST);
5351 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
5352 LVS_EX_HEADERINALLVIEWS);
5353 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5354 ok(IsWindow(header), "Expected header to be created\n");
5355 DestroyWindow(hwnd);
5356
5357 hwnd = create_listview_control(LVS_SMALLICON);
5358 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
5359 LVS_EX_HEADERINALLVIEWS);
5360 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5361 ok(IsWindow(header), "Expected header to be created\n");
5362 DestroyWindow(hwnd);
5363
5364 hwnd = create_listview_control(LVS_REPORT);
5365 SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
5366 LVS_EX_HEADERINALLVIEWS);
5367 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5368 ok(IsWindow(header), "Expected header to be created\n");
5369 DestroyWindow(hwnd);
5370 }
5371
5372 static void test_hover(void)
5373 {
5374 HWND hwnd, fg;
5375 DWORD r;
5376
5377 hwnd = create_listview_control(LVS_ICON);
5378 SetForegroundWindow(hwndparent);
5379 fg = GetForegroundWindow();
5380 if (fg != hwndparent)
5381 {
5382 skip("Window is not in the foreground. Skipping hover tests.\n");
5383 DestroyWindow(hwnd);
5384 return;
5385 }
5386
5387 /* test WM_MOUSEHOVER forwarding */
5388 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5389 r = SendMessageA(hwnd, WM_MOUSEHOVER, 0, 0);
5390 expect(0, r);
5391 ok_sequence(sequences, PARENT_SEQ_INDEX, hover_parent, "NM_HOVER allow test", TRUE);
5392 g_block_hover = TRUE;
5393 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5394 r = SendMessageA(hwnd, WM_MOUSEHOVER, 0, 0);
5395 expect(0, r);
5396 ok_sequence(sequences, PARENT_SEQ_INDEX, hover_parent, "NM_HOVER block test", TRUE);
5397 g_block_hover = FALSE;
5398
5399 r = SendMessageA(hwnd, LVM_SETHOVERTIME, 0, 500);
5400 expect(HOVER_DEFAULT, r);
5401 r = SendMessageA(hwnd, LVM_GETHOVERTIME, 0, 0);
5402 expect(500, r);
5403
5404 DestroyWindow(hwnd);
5405 }
5406
5407 static void test_destroynotify(void)
5408 {
5409 HWND hwnd;
5410 BOOL ret;
5411
5412 hwnd = create_listview_control(LVS_REPORT);
5413 ok(hwnd != NULL, "failed to create listview window\n");
5414
5415 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5416 DestroyWindow(hwnd);
5417 ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_destroy, "check destroy order", FALSE);
5418
5419 /* same for ownerdata list */
5420 hwnd = create_listview_control(LVS_REPORT|LVS_OWNERDATA);
5421 ok(hwnd != NULL, "failed to create listview window\n");
5422
5423 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5424 DestroyWindow(hwnd);
5425 ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_ownerdata_destroy, "check destroy order, ownerdata", FALSE);
5426
5427 hwnd = create_listview_control(LVS_REPORT|LVS_OWNERDATA);
5428 ok(hwnd != NULL, "failed to create listview window\n");
5429
5430 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5431 ret = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
5432 ok(ret == TRUE, "got %d\n", ret);
5433 ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_ownerdata_deleteall, "deleteall ownerdata", FALSE);
5434 DestroyWindow(hwnd);
5435 }
5436
5437 static void test_header_notification(void)
5438 {
5439 static char textA[] = "newtext";
5440 HWND list, header;
5441 HDITEMA item;
5442 NMHEADERA nmh;
5443 LVCOLUMNA col;
5444 DWORD ret;
5445 BOOL r;
5446
5447 list = create_listview_control(LVS_REPORT);
5448 ok(list != NULL, "failed to create listview window\n");
5449
5450 memset(&col, 0, sizeof(col));
5451 col.mask = LVCF_WIDTH;
5452 col.cx = 100;
5453 ret = SendMessageA(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
5454 expect(0, ret);
5455
5456 /* check list parent notification after header item changed,
5457 this test should be placed before header subclassing to avoid
5458 Listview -> Header messages to be logged */
5459 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5460
5461 col.mask = LVCF_TEXT;
5462 col.pszText = textA;
5463 r = SendMessageA(list, LVM_SETCOLUMNA, 0, (LPARAM)&col);
5464 expect(TRUE, r);
5465
5466 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_header_changed_seq,
5467 "header notify, listview", FALSE);
5468 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5469 "header notify, parent", FALSE);
5470
5471 header = subclass_header(list);
5472
5473 ret = SendMessageA(header, HDM_GETITEMCOUNT, 0, 0);
5474 expect(1, ret);
5475
5476 memset(&item, 0, sizeof(item));
5477 item.mask = HDI_WIDTH;
5478 ret = SendMessageA(header, HDM_GETITEMA, 0, (LPARAM)&item);
5479 expect(1, ret);
5480 expect(100, item.cxy);
5481
5482 nmh.hdr.hwndFrom = header;
5483 nmh.hdr.idFrom = GetWindowLongPtrA(header, GWLP_ID);
5484 nmh.hdr.code = HDN_ITEMCHANGEDA;
5485 nmh.iItem = 0;
5486 nmh.iButton = 0;
5487 item.mask = HDI_WIDTH;
5488 item.cxy = 50;
5489 nmh.pitem = &item;
5490 ret = SendMessageA(list, WM_NOTIFY, 0, (LPARAM)&nmh);
5491 expect(0, ret);
5492
5493 DestroyWindow(list);
5494 }
5495
5496 static void test_header_notification2(void)
5497 {
5498 static char textA[] = "newtext";
5499 HWND list, header;
5500 HDITEMW itemW;
5501 NMHEADERW nmhdr;
5502 LVCOLUMNA col;
5503 DWORD ret;
5504 WCHAR buffer[100];
5505 struct message parent_header_notify_seq[] = {
5506 { WM_NOTIFY, sent|id, 0, 0, 0 },
5507 { 0 }
5508 };
5509
5510 list = create_listview_control(LVS_REPORT);
5511 ok(list != NULL, "failed to create listview window\n");
5512
5513 memset(&col, 0, sizeof(col));
5514 col.mask = LVCF_WIDTH | LVCF_TEXT;
5515 col.cx = 100;
5516 col.pszText = textA;
5517 ret = SendMessageA(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
5518 expect(0, ret);
5519
5520 header = (HWND)SendMessageA(list, LVM_GETHEADER, 0, 0);
5521 ok(header != 0, "No header\n");
5522 memset(&itemW, 0, sizeof(itemW));
5523 itemW.mask = HDI_WIDTH | HDI_ORDER | HDI_TEXT;
5524 itemW.pszText = buffer;
5525 itemW.cchTextMax = ARRAY_SIZE(buffer);
5526 ret = SendMessageW(header, HDM_GETITEMW, 0, (LPARAM)&itemW);
5527 expect(1, ret);
5528
5529 nmhdr.hdr.hwndFrom = header;
5530 nmhdr.hdr.idFrom = GetWindowLongPtrW(header, GWLP_ID);
5531 nmhdr.iItem = 0;
5532 nmhdr.iButton = 0;
5533 nmhdr.pitem = &itemW;
5534
5535 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5536 nmhdr.hdr.code = HDN_ITEMCHANGINGW;
5537 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5538 ok(ret == 0, "got %d\n", ret);
5539 parent_header_notify_seq[0].id = HDN_ITEMCHANGINGA;
5540 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_notify_seq,
5541 "header notify, parent", TRUE);
5542 todo_wine
5543 ok(nmhdr.hdr.code == HDN_ITEMCHANGINGA, "Expected ANSI notification code\n");
5544 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5545 nmhdr.hdr.code = HDN_ITEMCHANGEDW;
5546 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5547 ok(ret == 0, "got %d\n", ret);
5548 parent_header_notify_seq[0].id = HDN_ITEMCHANGEDA;
5549 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_notify_seq,
5550 "header notify, parent", TRUE);
5551 todo_wine
5552 ok(nmhdr.hdr.code == HDN_ITEMCHANGEDA, "Expected ANSI notification code\n");
5553 /* HDN_ITEMCLICK sets focus to list, which generates messages we don't want to check */
5554 SetFocus(list);
5555 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5556 nmhdr.hdr.code = HDN_ITEMCLICKW;
5557 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5558 ok(ret == 0, "got %d\n", ret);
5559 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_click_seq,
5560 "header notify, parent", FALSE);
5561 ok(nmhdr.hdr.code == HDN_ITEMCLICKA, "Expected ANSI notification code\n");
5562 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5563 nmhdr.hdr.code = HDN_ITEMDBLCLICKW;
5564 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5565 ok(ret == 0, "got %d\n", ret);
5566 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5567 "header notify, parent", FALSE);
5568 ok(nmhdr.hdr.code == HDN_ITEMDBLCLICKW, "Expected Unicode notification code\n");
5569 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5570 nmhdr.hdr.code = HDN_DIVIDERDBLCLICKW;
5571 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5572 ok(ret == 0, "got %d\n", ret);
5573 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_divider_dclick_seq,
5574 "header notify, parent", TRUE);
5575 ok(nmhdr.hdr.code == HDN_DIVIDERDBLCLICKA, "Expected ANSI notification code\n");
5576 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5577 nmhdr.hdr.code = HDN_BEGINTRACKW;
5578 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5579 ok(ret == 0, "got %d\n", ret);
5580 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5581 "header notify, parent", FALSE);
5582 ok(nmhdr.hdr.code == HDN_BEGINTRACKW, "Expected Unicode notification code\n");
5583 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5584 nmhdr.hdr.code = HDN_ENDTRACKW;
5585 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5586 ok(ret == 0, "got %d\n", ret);
5587 parent_header_notify_seq[0].id = HDN_ENDTRACKA;
5588 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_notify_seq,
5589 "header notify, parent", FALSE);
5590 ok(nmhdr.hdr.code == HDN_ENDTRACKA, "Expected ANSI notification code\n");
5591 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5592 nmhdr.hdr.code = HDN_TRACKW;
5593 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5594 ok(ret == 0, "got %d\n", ret);
5595 parent_header_notify_seq[0].id = HDN_TRACKA;
5596 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_notify_seq,
5597 "header notify, parent", FALSE);
5598 ok(nmhdr.hdr.code == HDN_TRACKA, "Expected ANSI notification code\n");
5599 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5600 nmhdr.hdr.code = HDN_BEGINDRAG;
5601 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5602 ok(ret == 1, "got %d\n", ret);
5603 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5604 "header notify, parent", FALSE);
5605 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5606 nmhdr.hdr.code = HDN_ENDDRAG;
5607 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5608 ok(ret == 0, "got %d\n", ret);
5609 parent_header_notify_seq[0].id = HDN_ENDDRAG;
5610 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_notify_seq,
5611 "header notify, parent", FALSE);
5612 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5613 nmhdr.hdr.code = HDN_FILTERCHANGE;
5614 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5615 ok(ret == 0, "got %d\n", ret);
5616 parent_header_notify_seq[0].id = HDN_FILTERCHANGE;
5617 parent_header_notify_seq[0].flags |= optional; /* NT4 does not send this message */
5618 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_header_notify_seq,
5619 "header notify, parent", FALSE);
5620 parent_header_notify_seq[0].flags &= ~optional;
5621 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5622 nmhdr.hdr.code = HDN_BEGINFILTEREDIT;
5623 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5624 ok(ret == 0, "got %d\n", ret);
5625 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5626 "header notify, parent", FALSE);
5627 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5628 nmhdr.hdr.code = HDN_ENDFILTEREDIT;
5629 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5630 ok(ret == 0, "got %d\n", ret);
5631 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5632 "header notify, parent", FALSE);
5633 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5634 nmhdr.hdr.code = HDN_ITEMSTATEICONCLICK;
5635 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5636 ok(ret == 0, "got %d\n", ret);
5637 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5638 "header notify, parent", FALSE);
5639 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5640 nmhdr.hdr.code = HDN_ITEMKEYDOWN;
5641 ret = SendMessageW(list, WM_NOTIFY, 0, (LPARAM)&nmhdr);
5642 ok(ret == 0, "got %d\n", ret);
5643 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
5644 "header notify, parent", FALSE);
5645
5646 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5647
5648 DestroyWindow(list);
5649 }
5650
5651 static void test_createdragimage(void)
5652 {
5653 HIMAGELIST himl;
5654 POINT pt;
5655 HWND list;
5656
5657 list = create_listview_control(LVS_ICON);
5658 ok(list != NULL, "failed to create listview window\n");
5659
5660 insert_item(list, 0);
5661
5662 /* NULL point */
5663 himl = (HIMAGELIST)SendMessageA(list, LVM_CREATEDRAGIMAGE, 0, 0);
5664 ok(himl == NULL, "got %p\n", himl);
5665
5666 himl = (HIMAGELIST)SendMessageA(list, LVM_CREATEDRAGIMAGE, 0, (LPARAM)&pt);
5667 ok(himl != NULL, "got %p\n", himl);
5668 pImageList_Destroy(himl);
5669
5670 DestroyWindow(list);
5671 }
5672
5673 static void test_dispinfo(void)
5674 {
5675 static const char testA[] = "TEST";
5676 WCHAR buff[10];
5677 LVITEMA item;
5678 HWND hwnd;
5679 DWORD ret;
5680
5681 hwnd = create_listview_control(LVS_ICON);
5682 ok(hwnd != NULL, "failed to create listview window\n");
5683
5684 insert_item(hwnd, 0);
5685
5686 memset(&item, 0, sizeof(item));
5687 item.pszText = LPSTR_TEXTCALLBACKA;
5688 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
5689 expect(1, ret);
5690
5691 g_disp_A_to_W = TRUE;
5692 item.pszText = (char*)buff;
5693 item.cchTextMax = ARRAY_SIZE(buff);
5694 ret = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
5695 ok(ret == sizeof(testA)-1, "got %d, expected 4\n", ret);
5696 g_disp_A_to_W = FALSE;
5697
5698 ok(memcmp(item.pszText, testA, sizeof(testA)) == 0,
5699 "got %s, expected %s\n", item.pszText, testA);
5700
5701 DestroyWindow(hwnd);
5702 }
5703
5704 static void test_LVM_SETITEMTEXT(void)
5705 {
5706 static char testA[] = "TEST";
5707 LVITEMA item;
5708 HWND hwnd;
5709 DWORD ret;
5710
5711 hwnd = create_listview_control(LVS_ICON);
5712 ok(hwnd != NULL, "failed to create listview window\n");
5713
5714 insert_item(hwnd, 0);
5715
5716 /* null item pointer */
5717 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, 0);
5718 expect(FALSE, ret);
5719
5720 ret = SendMessageA(hwnd, LVM_SETITEMTEXTW, 0, 0);
5721 expect(FALSE, ret);
5722
5723 /* index out of bounds */
5724 item.pszText = testA;
5725 item.cchTextMax = 0; /* ignored */
5726 item.iSubItem = 0;
5727
5728 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 1, (LPARAM)&item);
5729 expect(FALSE, ret);
5730
5731 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, -1, (LPARAM)&item);
5732 expect(FALSE, ret);
5733
5734 ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
5735 expect(TRUE, ret);
5736
5737 DestroyWindow(hwnd);
5738 }
5739
5740 static void test_LVM_REDRAWITEMS(void)
5741 {
5742 HWND list;
5743 DWORD ret;
5744
5745 list = create_listview_control(LVS_ICON);
5746 ok(list != NULL, "failed to create listview window\n");
5747
5748 ret = SendMessageA(list, LVM_REDRAWITEMS, 0, 0);
5749 expect(TRUE, ret);
5750
5751 insert_item(list, 0);
5752
5753 ret = SendMessageA(list, LVM_REDRAWITEMS, -1, 0);
5754 expect(TRUE, ret);
5755
5756 ret = SendMessageA(list, LVM_REDRAWITEMS, 0, -1);
5757 expect(TRUE, ret);
5758
5759 ret = SendMessageA(list, LVM_REDRAWITEMS, 0, 0);
5760 expect(TRUE, ret);
5761
5762 ret = SendMessageA(list, LVM_REDRAWITEMS, 0, 1);
5763 expect(TRUE, ret);
5764
5765 ret = SendMessageA(list, LVM_REDRAWITEMS, 0, 2);
5766 expect(TRUE, ret);
5767
5768 ret = SendMessageA(list, LVM_REDRAWITEMS, 1, 0);
5769 expect(TRUE, ret);
5770
5771 ret = SendMessageA(list, LVM_REDRAWITEMS, 2, 3);
5772 expect(TRUE, ret);
5773
5774 DestroyWindow(list);
5775 }
5776
5777 static void test_imagelists(void)
5778 {
5779 HWND hwnd, header;
5780 HIMAGELIST himl1, himl2, himl3;
5781 LRESULT ret;
5782
5783 himl1 = pImageList_Create(40, 40, 0, 4, 4);
5784 himl2 = pImageList_Create(40, 40, 0, 4, 4);
5785 himl3 = pImageList_Create(40, 40, 0, 4, 4);
5786 ok(himl1 != NULL, "Failed to create imagelist\n");
5787 ok(himl2 != NULL, "Failed to create imagelist\n");
5788 ok(himl3 != NULL, "Failed to create imagelist\n");
5789
5790 hwnd = create_listview_control(LVS_REPORT | LVS_SHAREIMAGELISTS);
5791 header = subclass_header(hwnd);
5792
5793 ok(header != NULL, "Expected header\n");
5794 ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
5795 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5796
5797 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5798
5799 ret = SendMessageW(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl1);
5800 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5801 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
5802 "set normal image list", FALSE);
5803
5804 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5805
5806 ret = SendMessageW(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl2);
5807 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5808 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
5809 "set state image list", TRUE);
5810
5811 ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
5812 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5813
5814 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5815
5816 ret = SendMessageW(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl3);
5817 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5818 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_header_set_imagelist,
5819 "set small image list", FALSE);
5820
5821 ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
5822 ok((HIMAGELIST)ret == himl3, "Expected imagelist %p, got %p\n", himl3, (HIMAGELIST)ret);
5823 DestroyWindow(hwnd);
5824
5825 hwnd = create_listview_control(WS_VISIBLE | LVS_ICON);
5826
5827 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5828
5829 ret = SendMessageW(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl1);
5830 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5831 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
5832 "set normal image list", FALSE);
5833
5834 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5835
5836 ret = SendMessageW(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl2);
5837 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5838 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
5839 "set state image list", FALSE);
5840
5841 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5842
5843 ret = SendMessageW(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl3);
5844 ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
5845 ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
5846 "set small image list", FALSE);
5847
5848 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5849 ok(header == NULL, "Expected no header, got %p\n", header);
5850
5851 SetWindowLongPtrA(hwnd, GWL_STYLE, GetWindowLongPtrA(hwnd, GWL_STYLE) | LVS_REPORT);
5852
5853 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5854 ok(header != NULL, "Expected header, got NULL\n");
5855
5856 ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
5857 ok((HIMAGELIST)ret == himl3, "Expected imagelist %p, got %p\n", himl3, (HIMAGELIST)ret);
5858
5859 DestroyWindow(hwnd);
5860 }
5861
5862 static void test_deleteitem(void)
5863 {
5864 LVITEMA item;
5865 UINT state;
5866 HWND hwnd;
5867 BOOL ret;
5868
5869 hwnd = create_listview_control(LVS_REPORT);
5870
5871 insert_item(hwnd, 0);
5872 insert_item(hwnd, 0);
5873 insert_item(hwnd, 0);
5874 insert_item(hwnd, 0);
5875 insert_item(hwnd, 0);
5876
5877 g_focus_test_LVN_DELETEITEM = TRUE;
5878
5879 /* delete focused item (not the last index) */
5880 item.stateMask = LVIS_FOCUSED;
5881 item.state = LVIS_FOCUSED;
5882 ret = SendMessageA(hwnd, LVM_SETITEMSTATE, 2, (LPARAM)&item);
5883 ok(ret == TRUE, "got %d\n", ret);
5884 ret = SendMessageA(hwnd, LVM_DELETEITEM, 2, 0);
5885 ok(ret == TRUE, "got %d\n", ret);
5886 /* next item gets focus */
5887 state = SendMessageA(hwnd, LVM_GETITEMSTATE, 2, LVIS_FOCUSED);
5888 ok(state == LVIS_FOCUSED, "got %x\n", state);
5889
5890 /* focus last item and delete it */
5891 item.stateMask = LVIS_FOCUSED;
5892 item.state = LVIS_FOCUSED;
5893 ret = SendMessageA(hwnd, LVM_SETITEMSTATE, 3, (LPARAM)&item);
5894 ok(ret == TRUE, "got %d\n", ret);
5895 ret = SendMessageA(hwnd, LVM_DELETEITEM, 3, 0);
5896 ok(ret == TRUE, "got %d\n", ret);
5897 /* new last item gets focus */
5898 state = SendMessageA(hwnd, LVM_GETITEMSTATE, 2, LVIS_FOCUSED);
5899 ok(state == LVIS_FOCUSED, "got %x\n", state);
5900
5901 /* focus first item and delete it */
5902 item.stateMask = LVIS_FOCUSED;
5903 item.state = LVIS_FOCUSED;
5904 ret = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
5905 ok(ret == TRUE, "got %d\n", ret);
5906 ret = SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
5907 ok(ret == TRUE, "got %d\n", ret);
5908 /* new first item gets focus */
5909 state = SendMessageA(hwnd, LVM_GETITEMSTATE, 0, LVIS_FOCUSED);
5910 ok(state == LVIS_FOCUSED, "got %x\n", state);
5911
5912 g_focus_test_LVN_DELETEITEM = FALSE;
5913
5914 DestroyWindow(hwnd);
5915 }
5916
5917 static void test_insertitem(void)
5918 {
5919 LVITEMA item;
5920 UINT state;
5921 HWND hwnd;
5922 INT ret;
5923
5924 hwnd = create_listview_control(LVS_REPORT);
5925
5926 /* insert item 0 focused */
5927 item.mask = LVIF_STATE;
5928 item.state = LVIS_FOCUSED;
5929 item.stateMask = LVIS_FOCUSED;
5930 item.iItem = 0;
5931 item.iSubItem = 0;
5932 ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
5933 ok(ret == 0, "got %d\n", ret);
5934
5935 state = SendMessageA(hwnd, LVM_GETITEMSTATE, 0, LVIS_FOCUSED);
5936 ok(state == LVIS_FOCUSED, "got %x\n", state);
5937
5938 flush_sequences(sequences, NUM_MSG_SEQUENCES);
5939
5940 /* insert item 1, focus shift */
5941 item.mask = LVIF_STATE;
5942 item.state = LVIS_FOCUSED;
5943 item.stateMask = LVIS_FOCUSED;
5944 item.iItem = 1;
5945 item.iSubItem = 0;
5946 ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
5947 ok(ret == 1, "got %d\n", ret);
5948
5949 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_insert_focused_seq, "insert focused", TRUE);
5950
5951 state = SendMessageA(hwnd, LVM_GETITEMSTATE, 1, LVIS_FOCUSED);
5952 ok(state == LVIS_FOCUSED, "got %x\n", state);
5953
5954 /* insert item 2, no focus shift */
5955 item.mask = LVIF_STATE;
5956 item.state = 0;
5957 item.stateMask = LVIS_FOCUSED;
5958 item.iItem = 2;
5959 item.iSubItem = 0;
5960 ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
5961 ok(ret == 2, "got %d\n", ret);
5962
5963 state = SendMessageA(hwnd, LVM_GETITEMSTATE, 1, LVIS_FOCUSED);
5964 ok(state == LVIS_FOCUSED, "got %x\n", state);
5965
5966 DestroyWindow(hwnd);
5967 }
5968
5969 static void test_header_proc(void)
5970 {
5971 HWND hwnd, header, hdr;
5972 WNDPROC proc1, proc2;
5973
5974 hwnd = create_listview_control(LVS_REPORT);
5975
5976 header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
5977 ok(header != NULL, "got %p\n", header);
5978
5979 hdr = CreateWindowExA(0, WC_HEADERA, NULL,
5980 WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
5981 0, 0, 0, 0,
5982 NULL, NULL, NULL, NULL);
5983 ok(hdr != NULL, "got %p\n", hdr);
5984
5985 proc1 = (WNDPROC)GetWindowLongPtrW(header, GWLP_WNDPROC);
5986 proc2 = (WNDPROC)GetWindowLongPtrW(hdr, GWLP_WNDPROC);
5987 ok(proc1 == proc2, "got %p, expected %p\n", proc1, proc2);
5988
5989 DestroyWindow(hdr);
5990 DestroyWindow(hwnd);
5991 }
5992
5993 static void flush_events(void)
5994 {
5995 MSG msg;
5996 int diff = 200;
5997 int min_timeout = 100;
5998 DWORD time = GetTickCount() + diff;
5999
6000 while (diff > 0)
6001 {
6002 if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
6003 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
6004 diff = time - GetTickCount();
6005 }
6006 }
6007
6008 static void test_oneclickactivate(void)
6009 {
6010 TRACKMOUSEEVENT track;
6011 char item1[] = "item1";
6012 LVITEMA item;
6013 HWND hwnd, fg;
6014 RECT rect;
6015 INT r;
6016 POINT orig_pos;
6017
6018 hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo", WS_VISIBLE|WS_CHILD|LVS_LIST,
6019 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
6020 ok(hwnd != NULL, "failed to create listview window\n");
6021 r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_ONECLICKACTIVATE);
6022 ok(r == 0, "should return zero\n");
6023
6024 SetForegroundWindow(hwndparent);
6025 flush_events();
6026 fg = GetForegroundWindow();
6027 if (fg != hwndparent)
6028 {
6029 skip("Window is not in the foreground. Skipping oneclickactivate tests.\n");
6030 DestroyWindow(hwnd);
6031 return;
6032 }
6033
6034 item.mask = LVIF_TEXT;
6035 item.iItem = 0;
6036 item.iSubItem = 0;
6037 item.iImage = 0;
6038 item.pszText = item1;
6039 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
6040 ok(r == 0, "should not fail\n");
6041
6042 GetWindowRect(hwnd, &rect);
6043 GetCursorPos(&orig_pos);
6044 SetCursorPos(rect.left+5, rect.top+5);
6045 flush_events();
6046 r = SendMessageA(hwnd, WM_MOUSEMOVE, MAKELONG(1, 1), 0);
6047 expect(0, r);
6048
6049 track.cbSize = sizeof(track);
6050 track.dwFlags = TME_QUERY;
6051 p_TrackMouseEvent(&track);
6052 ok(track.hwndTrack == hwnd, "hwndTrack != hwnd\n");
6053 ok(track.dwFlags == TME_LEAVE, "dwFlags = %x\n", track.dwFlags);
6054
6055 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
6056 expect(0, r);
6057 r = SendMessageA(hwnd, WM_MOUSEHOVER, MAKELONG(1, 1), 0);
6058 expect(0, r);
6059 r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
6060 expect(1, r);
6061
6062 DestroyWindow(hwnd);
6063 SetCursorPos(orig_pos.x, orig_pos.y);
6064 }
6065
6066 static void test_callback_mask(void)
6067 {
6068 LVITEMA item;
6069 DWORD mask;
6070 HWND hwnd;
6071 BOOL ret;
6072
6073 hwnd = create_listview_control(LVS_REPORT);
6074
6075 ret = SendMessageA(hwnd, LVM_SETCALLBACKMASK, ~0u, 0);
6076 ok(ret, "got %d\n", ret);
6077
6078 ret = SendMessageA(hwnd, LVM_SETCALLBACKMASK, ~0u, 1);
6079 ok(ret, "got %d\n", ret);
6080
6081 mask = SendMessageA(hwnd, LVM_GETCALLBACKMASK, 0, 0);
6082 ok(mask == ~0u, "got 0x%08x\n", mask);
6083
6084 DestroyWindow(hwnd);
6085
6086 /* LVS_OWNERDATA, mask LVIS_FOCUSED */
6087 hwnd = create_listview_control(LVS_REPORT | LVS_OWNERDATA);
6088
6089 mask = SendMessageA(hwnd, LVM_GETCALLBACKMASK, 0, 0);
6090 ok(mask == 0, "Unexpected callback mask %#x.\n", mask);
6091
6092 ret = SendMessageA(hwnd, LVM_SETCALLBACKMASK, LVIS_FOCUSED, 0);
6093 ok(ret, "Failed to set callback mask, %d\n", ret);
6094
6095 mask = SendMessageA(hwnd, LVM_GETCALLBACKMASK, 0, 0);
6096 ok(mask == LVIS_FOCUSED, "Unexpected callback mask %#x.\n", mask);
6097
6098 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
6099 ok(ret, "Failed to set item count.\n");
6100
6101 ret = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
6102 ok(ret == -1, "Unexpected selection mark, %d\n", ret);
6103
6104 item.stateMask = LVIS_FOCUSED;
6105 item.state = LVIS_FOCUSED;
6106 ret = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
6107 ok(ret, "Failed to set item state.\n");
6108
6109 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6110
6111 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6112 todo_wine
6113 ok(ret == 0, "Unexpected focused item, ret %d\n", ret);
6114
6115 ret = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
6116 todo_wine
6117 ok(ret == 0, "Unexpected selection mark, %d\n", ret);
6118
6119 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 0, 0);
6120 ok(ret, "Failed to set item count.\n");
6121
6122 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6123 ok(ret == -1, "Unexpected focused item, ret %d\n", ret);
6124
6125 ret = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
6126 ok(ret == -1, "Unexpected selection mark, %d\n", ret);
6127
6128 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
6129 ok(ret, "Failed to set item count.\n");
6130
6131 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6132 ok(ret == -1, "Unexpected focused item, ret %d\n", ret);
6133
6134 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent seq, owner data/focus 1", FALSE);
6135
6136 /* LVS_OWNDERDATA, empty mask */
6137 ret = SendMessageA(hwnd, LVM_SETCALLBACKMASK, 0, 0);
6138 ok(ret, "Failed to set callback mask, %d\n", ret);
6139
6140 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
6141 ok(ret, "Failed to set item count.\n");
6142
6143 ret = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
6144 ok(ret == -1, "Unexpected selection mark, %d\n", ret);
6145
6146 item.stateMask = LVIS_FOCUSED;
6147 item.state = LVIS_FOCUSED;
6148 ret = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
6149 ok(ret, "Failed to set item state.\n");
6150
6151 ret = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
6152 ok(ret == 0, "Unexpected selection mark, %d\n", ret);
6153
6154 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6155
6156 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6157 ok(ret == 0, "Unexpected focused item, ret %d\n", ret);
6158
6159 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 0, 0);
6160 ok(ret, "Failed to set item count.\n");
6161
6162 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6163 ok(ret == -1, "Unexpected focused item, ret %d\n", ret);
6164
6165 ret = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
6166 todo_wine
6167 ok(ret == -1, "Unexpected selection mark, %d\n", ret);
6168
6169 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
6170 ok(ret, "Failed to set item count.\n");
6171
6172 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6173 ok(ret == -1, "Unexpected focused item, ret %d\n", ret);
6174
6175 ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent seq, owner data/focus 2", FALSE);
6176
6177 /* 2 items, focus on index 0, reduce to 1 item. */
6178 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6179
6180 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 2, 0);
6181 ok(ret, "Failed to set item count.\n");
6182
6183 ret = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
6184 ok(ret, "Failed to set item state.\n");
6185
6186 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6187 ok(ret == 0, "Unexpected focused item, ret %d\n", ret);
6188
6189 ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
6190 ok(ret, "Failed to set item count.\n");
6191
6192 ret = SendMessageA(hwnd, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
6193 ok(ret == 0, "Unexpected focused item, ret %d\n", ret);
6194
6195 ok_sequence(sequences, PARENT_SEQ_INDEX, parent_focus_change_ownerdata_seq,
6196 "parent seq, owner data/focus 3", TRUE);
6197
6198 DestroyWindow(hwnd);
6199 }
6200
6201 static void test_state_image(void)
6202 {
6203 static const DWORD styles[] =
6204 {
6205 LVS_ICON,
6206 LVS_REPORT,
6207 LVS_SMALLICON,
6208 LVS_LIST,
6209 };
6210 int i;
6211
6212 for (i = 0; i < ARRAY_SIZE(styles); i++)
6213 {
6214 static char text[] = "Item";
6215 static char subtext[] = "Subitem";
6216 char buff[16];
6217 LVITEMA item;
6218 HWND hwnd;
6219 int r;
6220
6221 hwnd = create_listview_control(styles[i]);
6222
6223 insert_column(hwnd, 0);
6224 insert_column(hwnd, 1);
6225
6226 item.mask = LVIF_TEXT | LVIF_PARAM;
6227 item.iItem = 0;
6228 item.iSubItem = 0;
6229 item.pszText = text;
6230 item.lParam = 123456;
6231 r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
6232 ok(r == 0, "Failed to insert an item.\n");
6233
6234 item.mask = LVIF_STATE;
6235 item.state = INDEXTOSTATEIMAGEMASK(1) | LVIS_SELECTED | LVIS_FOCUSED;
6236 item.stateMask = LVIS_STATEIMAGEMASK | LVIS_SELECTED | LVIS_FOCUSED;
6237 item.iItem = 0;
6238 item.iSubItem = 0;
6239 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
6240 ok(r, "Failed to set item state.\n");
6241
6242 item.mask = LVIF_TEXT;
6243 item.iItem = 0;
6244 item.iSubItem = 1;
6245 item.pszText = subtext;
6246 r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
6247 ok(r, "Failed to set subitem text.\n");
6248
6249 item.mask = LVIF_STATE | LVIF_PARAM;
6250 item.stateMask = ~0u;
6251 item.state = 0;
6252 item.iItem = 0;
6253 item.iSubItem = 0;
6254 item.lParam = 0;
6255 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
6256 ok(r, "Failed to get item state.\n");
6257 ok(item.state == (INDEXTOSTATEIMAGEMASK(1) | LVIS_SELECTED | LVIS_FOCUSED),
6258 "Unexpected item state %#x.\n", item.state);
6259 ok(item.lParam == 123456, "Unexpected lParam %ld.\n", item.lParam);
6260
6261 item.mask = 0;
6262 item.stateMask = ~0u;
6263 item.state = INDEXTOSTATEIMAGEMASK(2);
6264 item.iItem = 0;
6265 item.iSubItem = 1;
6266 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
6267 ok(r, "Failed to get subitem state.\n");
6268 ok(item.state == INDEXTOSTATEIMAGEMASK(2), "Unexpected state %#x.\n", item.state);
6269
6270 item.mask = LVIF_STATE | LVIF_PARAM;
6271 item.stateMask = ~0u;
6272 item.state = INDEXTOSTATEIMAGEMASK(2);
6273 item.iItem = 0;
6274 item.iSubItem = 1;
6275 item.lParam = 0;
6276 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
6277 ok(r, "Failed to get subitem state.\n");
6278 ok(item.state == 0, "Unexpected state %#x.\n", item.state);
6279 ok(item.lParam == 123456, "Unexpected lParam %ld.\n", item.lParam);
6280
6281 item.mask = LVIF_STATE;
6282 item.stateMask = LVIS_FOCUSED;
6283 item.state = 0;
6284 item.iItem = 0;
6285 item.iSubItem = 1;
6286 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
6287 ok(r, "Failed to get subitem state.\n");
6288 ok(item.state == 0, "Unexpected state %#x.\n", item.state);
6289
6290 item.mask = LVIF_STATE;
6291 item.stateMask = ~0u;
6292 item.state = INDEXTOSTATEIMAGEMASK(2);
6293 item.iItem = 0;
6294 item.iSubItem = 2;
6295 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
6296 ok(r, "Failed to get subitem state.\n");
6297 todo_wine
6298 ok(item.state == 0, "Unexpected state %#x.\n", item.state);
6299
6300 item.mask = LVIF_TEXT;
6301 item.iItem = 0;
6302 item.iSubItem = 1;
6303 item.pszText = buff;
6304 item.cchTextMax = sizeof(buff);
6305 r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
6306 ok(r, "Failed to get subitem text %d.\n", r);
6307 ok(!strcmp(buff, subtext), "Unexpected subitem text %s.\n", buff);
6308
6309 DestroyWindow(hwnd);
6310 }
6311 }
6312
6313 static void test_LVSCW_AUTOSIZE(void)
6314 {
6315 int width, width2;
6316 HWND hwnd;
6317 BOOL ret;
6318
6319 hwnd = create_listview_control(LVS_REPORT);
6320 ok(hwnd != NULL, "failed to create a listview window\n");
6321
6322 insert_column(hwnd, 0);
6323 insert_column(hwnd, 1);
6324 insert_item(hwnd, 0);
6325
6326 ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, LVSCW_AUTOSIZE);
6327 ok(ret, "Failed to set column width.\n");
6328
6329 width = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
6330 ok(width > 0, "Unexpected column width %d.\n", width);
6331
6332 /* Turn on checkboxes. */
6333 ret = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
6334 ok(ret == 0, "Unexpected previous extended style.\n");
6335
6336 ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, LVSCW_AUTOSIZE);
6337 ok(ret, "Failed to set column width.\n");
6338
6339 width2 = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
6340 ok(width2 > 0, "Unexpected column width %d.\n", width2);
6341 ok(width2 > width, "Expected increased column width.\n");
6342
6343 /* Turn off checkboxes. */
6344 ret = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, 0);
6345 ok(ret == LVS_EX_CHECKBOXES, "Unexpected previous extended style.\n");
6346
6347 ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, LVSCW_AUTOSIZE);
6348 ok(ret, "Failed to set column width.\n");
6349
6350 width = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
6351 ok(width > 0, "Unexpected column width %d.\n", width2);
6352 ok(width2 > width, "Expected reduced column width.\n");
6353
6354 DestroyWindow(hwnd);
6355 }
6356
6357 static void test_LVN_ENDLABELEDIT(void)
6358 {
6359 WCHAR text[] = {'l','a','l','a',0};
6360 HWND hwnd, hwndedit;
6361 LVITEMW item = {0};
6362 DWORD ret;
6363
6364 hwnd = create_listview_control(LVS_REPORT | LVS_EDITLABELS);
6365
6366 insert_column(hwnd, 0);
6367
6368 item.mask = LVIF_TEXT;
6369 item.pszText = text;
6370 SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
6371
6372 /* Test normal editing */
6373 SetFocus(hwnd);
6374 hwndedit = (HWND)SendMessageW(hwnd, LVM_EDITLABELW, 0, 0);
6375 ok(hwndedit != NULL, "Failed to get edit control.\n");
6376
6377 ret = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)"test");
6378 ok(ret, "Failed to set edit text.\n");
6379
6380 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6381
6382 ret = SendMessageA(hwndedit, WM_KEYDOWN, VK_RETURN, 0);
6383 ok_sequence(sequences, PARENT_SEQ_INDEX, listview_end_label_edit, "Label edit", FALSE);
6384
6385 /* Test editing with kill focus */
6386 SetFocus(hwnd);
6387 hwndedit = (HWND)SendMessageW(hwnd, LVM_EDITLABELW, 0, 0);
6388 ok(hwndedit != NULL, "Failed to get edit control.\n");
6389
6390 ret = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)"test2");
6391 ok(ret, "Failed to set edit text.\n");
6392
6393 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6394
6395 g_WM_KILLFOCUS_on_LVN_ENDLABELEDIT = TRUE;
6396 ret = SendMessageA(hwndedit, WM_KEYDOWN, VK_RETURN, 0);
6397 g_WM_KILLFOCUS_on_LVN_ENDLABELEDIT = FALSE;
6398
6399 ok_sequence(sequences, PARENT_SEQ_INDEX, listview_end_label_edit_kill_focus,
6400 "Label edit, kill focus", FALSE);
6401 ok(GetFocus() == hwnd, "Unexpected focused window.\n");
6402
6403 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6404
6405 DestroyWindow(hwnd);
6406 }
6407
6408 static LRESULT CALLBACK create_item_height_wndproc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
6409 {
6410 if (msg == WM_CREATE)
6411 return 0;
6412
6413 return CallWindowProcA(listviewWndProc, hwnd, msg, wParam, lParam);
6414 }
6415
6416 static void test_LVM_GETCOUNTPERPAGE(void)
6417 {
6418 static const DWORD styles[] = { LVS_ICON, LVS_LIST, LVS_REPORT, LVS_SMALLICON };
6419 unsigned int i, j;
6420 WNDCLASSEXA cls;
6421 ATOM class;
6422 HWND hwnd;
6423 BOOL ret;
6424
6425 cls.cbSize = sizeof(WNDCLASSEXA);
6426 ret = GetClassInfoExA(GetModuleHandleA(NULL), WC_LISTVIEWA, &cls);
6427 ok(ret, "Failed to get class info.\n");
6428 listviewWndProc = cls.lpfnWndProc;
6429 cls.lpfnWndProc = create_item_height_wndproc;
6430 cls.lpszClassName = "CountPerPageClass";
6431 class = RegisterClassExA(&cls);
6432 ok(class, "Failed to register class.\n");
6433
6434 for (i = 0; i < ARRAY_SIZE(styles); i++)
6435 {
6436 static char text[] = "item text";
6437 LVITEMA item = { 0 };
6438 UINT count, count2;
6439
6440 hwnd = create_listview_control(styles[i]);
6441 ok(hwnd != NULL, "Failed to create listview window.\n");
6442
6443 count = SendMessageA(hwnd, LVM_GETCOUNTPERPAGE, 0, 0);
6444 if (styles[i] == LVS_LIST || styles[i] == LVS_REPORT)
6445 ok(count > 0 || broken(styles[i] == LVS_LIST && count == 0), "%u: unexpected count %u.\n", i, count);
6446 else
6447 ok(count == 0, "%u: unexpected count %u.\n", i, count);
6448
6449 for (j = 0; j < 10; j++)
6450 {
6451 item.mask = LVIF_TEXT;
6452 item.pszText = text;
6453 SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
6454 }
6455
6456 count2 = SendMessageA(hwnd, LVM_GETCOUNTPERPAGE, 0, 0);
6457 if (styles[i] == LVS_LIST || styles[i] == LVS_REPORT)
6458 ok(count == count2, "%u: unexpected count %u.\n", i, count2);
6459 else
6460 ok(count2 == 10, "%u: unexpected count %u.\n", i, count2);
6461
6462 DestroyWindow(hwnd);
6463
6464 hwnd = CreateWindowA("CountPerPageClass", "Test", WS_VISIBLE | styles[i], 0, 0, 100, 100, NULL, NULL,
6465 GetModuleHandleA(NULL), 0);
6466 ok(hwnd != NULL, "Failed to create a window.\n");
6467
6468 count = SendMessageA(hwnd, LVM_GETCOUNTPERPAGE, 0, 0);
6469 ok(count == 0, "%u: unexpected count %u.\n", i, count);
6470
6471 DestroyWindow(hwnd);
6472 }
6473
6474 ret = UnregisterClassA("CountPerPageClass", NULL);
6475 ok(ret, "Failed to unregister test class.\n");
6476 }
6477
6478 START_TEST(listview)
6479 {
6480 ULONG_PTR ctx_cookie;
6481 HANDLE hCtx;
6482
6483 init_functions();
6484
6485 init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
6486
6487 hwndparent = create_parent_window(FALSE);
6488 flush_sequences(sequences, NUM_MSG_SEQUENCES);
6489
6490 g_is_below_5 = is_below_comctl_5();
6491
6492 test_header_notification();
6493 test_header_notification2();
6494 test_images();
6495 test_checkboxes();
6496 test_items();
6497 test_create(FALSE);
6498 test_redraw();
6499 test_customdraw();
6500 test_icon_spacing();
6501 test_color();
6502 test_item_count();
6503 test_item_position();
6504 test_columns();
6505 test_getorigin();
6506 test_multiselect();
6507 test_getitemrect();
6508 test_subitem_rect();
6509 test_sorting();
6510 test_ownerdata();
6511 test_norecompute();
6512 test_nosortheader();
6513 test_setredraw();
6514 test_hittest();
6515 test_getviewrect();
6516 test_getitemposition();
6517 test_columnscreation();
6518 test_editbox();
6519 test_notifyformat();
6520 test_indentation();
6521 test_getitemspacing();
6522 test_getcolumnwidth();
6523 test_approximate_viewrect();
6524 test_finditem();
6525 test_hover();
6526 test_destroynotify();
6527 test_createdragimage();
6528 test_dispinfo();
6529 test_LVM_SETITEMTEXT();
6530 test_LVM_REDRAWITEMS();
6531 test_imagelists();
6532 test_deleteitem();
6533 test_insertitem();
6534 test_header_proc();
6535 test_oneclickactivate();
6536 test_callback_mask();
6537 test_state_image();
6538 test_LVSCW_AUTOSIZE();
6539 test_LVN_ENDLABELEDIT();
6540 test_LVM_GETCOUNTPERPAGE();
6541
6542 if (!load_v6_module(&ctx_cookie, &hCtx))
6543 {
6544 DestroyWindow(hwndparent);
6545 return;
6546 }
6547
6548 init_functions();
6549
6550 /* comctl32 version 6 tests start here */
6551 test_get_set_view();
6552 test_canceleditlabel();
6553 test_mapidindex();
6554 test_scrollnotify();
6555 test_LVS_EX_TRANSPARENTBKGND();
6556 test_LVS_EX_HEADERINALLVIEWS();
6557 test_deleteitem();
6558 test_multiselect();
6559 test_insertitem();
6560 test_header_proc();
6561 test_images();
6562 test_checkboxes();
6563 test_items();
6564 test_create(TRUE);
6565 test_color();
6566 test_columns();
6567 test_sorting();
6568 test_ownerdata();
6569 test_norecompute();
6570 test_nosortheader();
6571 test_columnscreation();
6572 test_indentation();
6573 test_finditem();
6574 test_hover();
6575 test_destroynotify();
6576 test_createdragimage();
6577 test_dispinfo();
6578 test_LVM_SETITEMTEXT();
6579 test_LVM_REDRAWITEMS();
6580 test_oneclickactivate();
6581 test_state_image();
6582 test_LVSCW_AUTOSIZE();
6583 test_LVN_ENDLABELEDIT();
6584 test_LVM_GETCOUNTPERPAGE();
6585
6586 unload_v6_module(ctx_cookie, hCtx);
6587
6588 DestroyWindow(hwndparent);
6589 }
A free Windows-compatible Operating System