1 /* Unit tests for treeview.
3 * Copyright 2005 Krzysztof Foltman
4 * Copyright 2007 Christopher James Peterson
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
32 #include "wine/test.h"
36 static const char *TEST_CALLBACK_TEXT
= "callback_text";
38 static TVITEMA g_item_expanding
, g_item_expanded
;
39 static BOOL g_get_from_expand
;
40 static BOOL g_get_rect_in_expand
;
41 static BOOL g_disp_A_to_W
;
42 static BOOL g_disp_set_stateimage
;
43 static BOOL g_beginedit_alter_text
;
45 #define NUM_MSG_SEQUENCES 2
46 #define TREEVIEW_SEQ_INDEX 0
47 #define PARENT_SEQ_INDEX 1
49 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
51 static struct msg_sequence
*sequences
[NUM_MSG_SEQUENCES
];
52 static struct msg_sequence
*item_sequence
[1];
54 static const struct message FillRootSeq
[] = {
55 { TVM_INSERTITEM
, sent
},
56 { TVM_INSERTITEM
, sent
},
60 static const struct message rootnone_select_seq
[] = {
61 { TVM_SELECTITEM
, sent
|wparam
, 9 },
62 { TVM_SELECTITEM
, sent
|wparam
, 9 },
63 { TVM_SELECTITEM
, sent
|wparam
, 9 },
64 { TVM_SELECTITEM
, sent
|wparam
, 9 },
65 { TVM_SELECTITEM
, sent
|wparam
, 9 },
66 { TVM_SELECTITEM
, sent
|wparam
, 9 },
70 static const struct message rootchild_select_seq
[] = {
71 { TVM_SELECTITEM
, sent
|wparam
, 9 },
72 { TVM_SELECTITEM
, sent
|wparam
, 9 },
73 { TVM_SELECTITEM
, sent
|wparam
, 9 },
74 { TVM_SELECTITEM
, sent
|wparam
, 9 },
75 { TVM_SELECTITEM
, sent
|wparam
, 9 },
76 { TVM_SELECTITEM
, sent
|wparam
, 9 },
80 static const struct message getitemtext_seq
[] = {
81 { TVM_INSERTITEMA
, sent
},
82 { TVM_GETITEMA
, sent
},
83 { TVM_DELETEITEM
, sent
},
87 static const struct message focus_seq
[] = {
88 { TVM_INSERTITEM
, sent
},
89 { TVM_INSERTITEM
, sent
},
90 { TVM_SELECTITEM
, sent
|wparam
, 9 },
91 /* The following end up out of order in wine */
92 { WM_WINDOWPOSCHANGING
, sent
|defwinproc
},
93 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
, TRUE
},
94 { WM_WINDOWPOSCHANGED
, sent
|defwinproc
},
95 { WM_SIZE
, sent
|defwinproc
},
96 { WM_WINDOWPOSCHANGING
, sent
|defwinproc
|optional
},
97 { WM_NCCALCSIZE
, sent
|wparam
|defwinproc
|optional
, TRUE
},
98 { WM_WINDOWPOSCHANGED
, sent
|defwinproc
|optional
},
99 { WM_SIZE
, sent
|defwinproc
|optional
},
100 { WM_PAINT
, sent
|defwinproc
},
101 { WM_NCPAINT
, sent
|wparam
|defwinproc
, 1 },
102 { WM_ERASEBKGND
, sent
|defwinproc
},
103 { TVM_EDITLABELA
, sent
},
104 { WM_COMMAND
, sent
|wparam
|defwinproc
, MAKEWPARAM(0, EN_UPDATE
) },
105 { WM_COMMAND
, sent
|wparam
|defwinproc
, MAKEWPARAM(0, EN_CHANGE
) },
106 { WM_PARENTNOTIFY
, sent
|wparam
|defwinproc
, MAKEWPARAM(WM_CREATE
, 0) },
107 { WM_KILLFOCUS
, sent
|defwinproc
},
108 { WM_PAINT
, sent
|defwinproc
},
109 { WM_IME_SETCONTEXT
, sent
|defwinproc
|optional
},
110 { WM_COMMAND
, sent
|wparam
|defwinproc
, MAKEWPARAM(0, EN_SETFOCUS
) },
111 { WM_ERASEBKGND
, sent
|defwinproc
|optional
},
112 { WM_CTLCOLOREDIT
, sent
|defwinproc
|optional
},
113 { WM_CTLCOLOREDIT
, sent
|defwinproc
|optional
},
117 static const struct message test_get_set_bkcolor_seq
[] = {
118 { TVM_GETBKCOLOR
, sent
|wparam
|lparam
, 0, 0 },
119 { TVM_SETBKCOLOR
, sent
|wparam
|lparam
, 0, 0 },
120 { TVM_GETBKCOLOR
, sent
|wparam
|lparam
, 0, 0 },
121 { TVM_SETBKCOLOR
, sent
|wparam
|lparam
, 0, 0x00ffffff },
122 { TVM_GETBKCOLOR
, sent
|wparam
|lparam
, 0, 0 },
123 { TVM_SETBKCOLOR
, sent
|wparam
|lparam
, 0, -1 },
127 static const struct message test_get_set_imagelist_seq
[] = {
128 { TVM_SETIMAGELIST
, sent
|wparam
|lparam
, 0, 0 },
129 { TVM_GETIMAGELIST
, sent
|wparam
|lparam
, 0, 0 },
133 static const struct message test_get_set_indent_seq
[] = {
134 { TVM_SETINDENT
, sent
|wparam
|lparam
, 0, 0 },
135 { TVM_GETINDENT
, sent
|wparam
|lparam
, 0, 0 },
136 /* The actual amount to indent is dependent on the system for this message */
137 { TVM_SETINDENT
, sent
},
138 { TVM_GETINDENT
, sent
|wparam
|lparam
, 0, 0 },
142 static const struct message test_get_set_insertmarkcolor_seq
[] = {
143 { TVM_SETINSERTMARKCOLOR
, sent
|wparam
|lparam
, 0, 0 },
144 { TVM_GETINSERTMARKCOLOR
, sent
|wparam
|lparam
, 0, 0 },
148 static const struct message test_get_set_item_seq
[] = {
149 { TVM_GETITEMA
, sent
},
150 { TVM_SETITEMA
, sent
},
151 { TVM_GETITEMA
, sent
},
152 { TVM_SETITEMA
, sent
},
156 static const struct message test_get_set_itemheight_seq
[] = {
157 { TVM_GETITEMHEIGHT
, sent
|wparam
|lparam
, 0, 0 },
158 { TVM_SETITEMHEIGHT
, sent
|wparam
|lparam
, -1, 0 },
159 { TVM_GETITEMHEIGHT
, sent
|wparam
|lparam
, 0, 0 },
160 { TVM_SETITEMHEIGHT
, sent
|lparam
, 0xcccccccc, 0 },
161 { TVM_GETITEMHEIGHT
, sent
|wparam
|lparam
|optional
, 0, 0 },
162 { TVM_SETITEMHEIGHT
, sent
|wparam
|lparam
|optional
, 9, 0 },
163 { TVM_GETITEMHEIGHT
, sent
|wparam
|lparam
, 0, 0 },
167 static const struct message test_get_set_scrolltime_seq
[] = {
168 { TVM_SETSCROLLTIME
, sent
|wparam
|lparam
, 20, 0 },
169 { TVM_GETSCROLLTIME
, sent
|wparam
|lparam
, 0, 0 },
173 static const struct message test_get_set_textcolor_seq
[] = {
174 { TVM_GETTEXTCOLOR
, sent
|wparam
|lparam
, 0, 0 },
175 { TVM_SETTEXTCOLOR
, sent
|wparam
|lparam
, 0, 0 },
176 { TVM_GETTEXTCOLOR
, sent
|wparam
|lparam
, 0, 0 },
177 { TVM_SETTEXTCOLOR
, sent
|wparam
|lparam
, 0, RGB(255, 255, 255) },
178 { TVM_GETTEXTCOLOR
, sent
|wparam
|lparam
, 0, 0 },
179 { TVM_SETTEXTCOLOR
, sent
|wparam
|lparam
, 0, CLR_NONE
},
183 static const struct message test_get_set_tooltips_seq
[] = {
184 { WM_KILLFOCUS
, sent
},
185 { WM_IME_SETCONTEXT
, sent
|optional
},
186 { WM_IME_NOTIFY
, sent
|optional
},
187 { TVM_SETTOOLTIPS
, sent
|wparam
|lparam
, 0, 0 },
188 { TVM_GETTOOLTIPS
, sent
|wparam
|lparam
, 0, 0 },
192 static const struct message test_get_set_unicodeformat_seq
[] = {
193 { TVM_SETUNICODEFORMAT
, sent
|wparam
|lparam
, TRUE
, 0 },
194 { TVM_GETUNICODEFORMAT
, sent
|wparam
|lparam
, 0, 0 },
195 { TVM_SETUNICODEFORMAT
, sent
|wparam
|lparam
, 0, 0 },
196 { TVM_GETUNICODEFORMAT
, sent
|wparam
|lparam
, 0, 0 },
197 { TVM_SETUNICODEFORMAT
, sent
|wparam
|lparam
, 0, 0 },
201 static const struct message parent_expand_seq
[] = {
202 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_ITEMEXPANDINGA
},
203 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_ITEMEXPANDEDA
},
207 static const struct message parent_expand_kb_seq
[] = {
208 { WM_NOTIFY
, sent
|id
|optional
, 0, 0, TVN_KEYDOWN
},
209 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_ITEMEXPANDINGA
},
210 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_ITEMEXPANDEDA
},
211 { WM_CHANGEUISTATE
, sent
|optional
},
215 static const struct message parent_expand_empty_kb_seq
[] = {
216 { WM_NOTIFY
, sent
|id
|optional
, 0, 0, TVN_KEYDOWN
},
217 { WM_CHANGEUISTATE
, sent
|optional
},
221 static const struct message parent_singleexpand_seq
[] = {
222 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_SELCHANGINGA
},
223 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_SELCHANGEDA
},
224 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_SINGLEEXPAND
},
225 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_ITEMEXPANDINGA
},
226 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_ITEMEXPANDEDA
},
230 static const struct message parent_get_dispinfo_seq
[] = {
231 { WM_NOTIFY
, sent
|id
, 0, 0, TVN_GETDISPINFOA
},
235 static const struct message empty_seq
[] = {
239 static HWND hMainWnd
;
241 static HTREEITEM hRoot
, hChild
;
244 static char sequence
[256];
246 static void Clear(void)
252 static void AddItem(char ch
)
254 sequence
[pos
++] = ch
;
255 sequence
[pos
] = '\0';
258 static void IdentifyItem(HTREEITEM hItem
)
260 if (hItem
== hRoot
) {
264 if (hItem
== hChild
) {
275 /* This function hooks in and records all messages to the treeview control */
276 static LRESULT WINAPI
TreeviewWndProc(HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
278 static LONG defwndproc_counter
= 0;
281 WNDPROC lpOldProc
= (WNDPROC
)GetWindowLongPtrA(hwnd
, GWLP_USERDATA
);
283 msg
.message
= message
;
284 msg
.flags
= sent
|wparam
|lparam
;
285 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
288 add_message(sequences
, TREEVIEW_SEQ_INDEX
, &msg
);
290 defwndproc_counter
++;
291 ret
= CallWindowProcA(lpOldProc
, hwnd
, message
, wParam
, lParam
);
292 defwndproc_counter
--;
297 static HWND
create_treeview_control(DWORD style
)
302 hTree
= CreateWindowExA(WS_EX_CLIENTEDGE
, WC_TREEVIEWA
, NULL
, WS_CHILD
|WS_VISIBLE
|
303 TVS_LINESATROOT
|TVS_HASLINES
|TVS_HASBUTTONS
|TVS_EDITLABELS
|style
,
304 0, 0, 120, 100, hMainWnd
, (HMENU
)100, GetModuleHandleA(0), 0);
308 /* Record the old WNDPROC so we can call it after recording the messages */
309 pOldWndProc
= (WNDPROC
)SetWindowLongPtrA(hTree
, GWLP_WNDPROC
, (LONG_PTR
)TreeviewWndProc
);
310 SetWindowLongPtrA(hTree
, GWLP_USERDATA
, (LONG_PTR
)pOldWndProc
);
315 static void fill_tree(HWND hTree
)
318 static CHAR root
[] = "Root",
321 ins
.hParent
= TVI_ROOT
;
322 ins
.hInsertAfter
= TVI_ROOT
;
323 U(ins
).item
.mask
= TVIF_TEXT
;
324 U(ins
).item
.pszText
= root
;
325 hRoot
= TreeView_InsertItem(hTree
, &ins
);
328 ins
.hInsertAfter
= TVI_FIRST
;
329 U(ins
).item
.mask
= TVIF_TEXT
;
330 U(ins
).item
.pszText
= child
;
331 hChild
= TreeView_InsertItem(hTree
, &ins
);
334 static void test_fillroot(void)
339 hTree
= create_treeview_control(0);
341 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
351 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, FillRootSeq
, "FillRoot", FALSE
);
352 ok(!strcmp(sequence
, "AB."), "Item creation\n");
354 /* UMLPad 1.15 depends on this being not -1 (I_IMAGECALLBACK) */
356 tvi
.mask
= TVIF_IMAGE
| TVIF_SELECTEDIMAGE
;
357 SendMessage( hTree
, TVM_GETITEMA
, 0, (LPARAM
)&tvi
);
358 ok(tvi
.iImage
== 0, "tvi.iImage=%d\n", tvi
.iImage
);
359 ok(tvi
.iSelectedImage
== 0, "tvi.iSelectedImage=%d\n", tvi
.iSelectedImage
);
361 DestroyWindow(hTree
);
364 static void test_callback(void)
367 HTREEITEM hItem1
, hItem2
;
370 CHAR test_string
[] = "Test_string";
371 static const CHAR test2A
[] = "TEST2";
376 hTree
= create_treeview_control(0);
378 ret
= TreeView_DeleteAllItems(hTree
);
380 ins
.hParent
= TVI_ROOT
;
381 ins
.hInsertAfter
= TVI_ROOT
;
382 U(ins
).item
.mask
= TVIF_TEXT
;
383 U(ins
).item
.pszText
= LPSTR_TEXTCALLBACK
;
384 hRoot
= TreeView_InsertItem(hTree
, &ins
);
388 tvi
.mask
= TVIF_TEXT
;
390 tvi
.cchTextMax
= sizeof(buf
)/sizeof(buf
[0]);
391 ret
= TreeView_GetItem(hTree
, &tvi
);
393 ok(strcmp(tvi
.pszText
, TEST_CALLBACK_TEXT
) == 0, "Callback item text mismatch %s vs %s\n",
394 tvi
.pszText
, TEST_CALLBACK_TEXT
);
397 ins
.hInsertAfter
= TVI_FIRST
;
398 U(ins
).item
.mask
= TVIF_TEXT
;
399 U(ins
).item
.pszText
= test_string
;
400 hItem1
= TreeView_InsertItem(hTree
, &ins
);
404 ret
= TreeView_GetItem(hTree
, &tvi
);
406 ok(strcmp(tvi
.pszText
, test_string
) == 0, "Item text mismatch %s vs %s\n",
407 tvi
.pszText
, test_string
);
409 /* undocumented: pszText of NULL also means LPSTR_CALLBACK: */
411 ret
= TreeView_SetItem(hTree
, &tvi
);
414 ret
= TreeView_GetItem(hTree
, &tvi
);
416 ok(strcmp(tvi
.pszText
, TEST_CALLBACK_TEXT
) == 0, "Item text mismatch %s vs %s\n",
417 tvi
.pszText
, TEST_CALLBACK_TEXT
);
419 U(ins
).item
.pszText
= NULL
;
420 hItem2
= TreeView_InsertItem(hTree
, &ins
);
423 memset(buf
, 0, sizeof(buf
));
424 ret
= TreeView_GetItem(hTree
, &tvi
);
426 ok(strcmp(tvi
.pszText
, TEST_CALLBACK_TEXT
) == 0, "Item text mismatch %s vs %s\n",
427 tvi
.pszText
, TEST_CALLBACK_TEXT
);
429 /* notification handler changed A->W */
430 g_disp_A_to_W
= TRUE
;
432 memset(buf
, 0, sizeof(buf
));
433 ret
= TreeView_GetItem(hTree
, &tvi
);
435 ok(strcmp(tvi
.pszText
, test2A
) == 0, "got %s, expected %s\n",
436 tvi
.pszText
, test2A
);
437 g_disp_A_to_W
= FALSE
;
439 /* handler changes state image index */
440 SetWindowLongA(hTree
, GWL_STYLE
, GetWindowLongA(hTree
, GWL_STYLE
) | TVS_CHECKBOXES
);
442 /* clear selection, handler will set selected state */
443 ret
= SendMessageA(hTree
, TVM_SELECTITEM
, TVGN_CARET
, 0);
446 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
449 tvi
.mask
= TVIF_STATE
;
450 tvi
.state
= TVIS_SELECTED
;
451 ret
= TreeView_GetItem(hTree
, &tvi
);
453 ok(tvi
.state
== INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", tvi
.state
);
455 ok_sequence(sequences
, PARENT_SEQ_INDEX
, empty_seq
,
456 "no TVN_GETDISPINFO for a state seq", FALSE
);
459 tvi
.mask
= TVIF_IMAGE
| TVIF_STATE
;
460 tvi
.state
= TVIS_FOCUSED
;
461 tvi
.stateMask
= TVIS_FOCUSED
;
462 tvi
.iImage
= I_IMAGECALLBACK
;
463 ret
= TreeView_SetItem(hTree
, &tvi
);
466 /* ask for item image index through callback - state is also set with state image index */
467 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
470 tvi
.mask
= TVIF_IMAGE
;
472 ret
= TreeView_GetItem(hTree
, &tvi
);
474 ok(tvi
.state
== (INDEXTOSTATEIMAGEMASK(1) | TVIS_FOCUSED
), "got 0x%x\n", tvi
.state
);
476 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_get_dispinfo_seq
,
477 "callback for state/overlay image index, noop seq", FALSE
);
479 /* ask for image again and overwrite state to some value in handler */
480 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
482 g_disp_set_stateimage
= TRUE
;
484 tvi
.mask
= TVIF_IMAGE
;
485 tvi
.state
= INDEXTOSTATEIMAGEMASK(1);
487 ret
= TreeView_GetItem(hTree
, &tvi
);
489 /* handler sets TVIS_SELECTED as well */
490 ok(tvi
.state
== (TVIS_FOCUSED
| TVIS_SELECTED
| INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(3)), "got 0x%x\n", tvi
.state
);
491 g_disp_set_stateimage
= FALSE
;
493 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_get_dispinfo_seq
,
494 "callback for state/overlay image index seq", FALSE
);
496 DestroyWindow(hTree
);
499 static void test_select(void)
504 hTree
= create_treeview_control(0);
507 /* root-none select tests */
508 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
509 r
= TreeView_SelectItem(hTree
, NULL
);
513 r
= TreeView_SelectItem(hTree
, hRoot
);
516 r
= TreeView_SelectItem(hTree
, hRoot
);
519 r
= TreeView_SelectItem(hTree
, NULL
);
522 r
= TreeView_SelectItem(hTree
, NULL
);
525 r
= TreeView_SelectItem(hTree
, hRoot
);
528 ok(!strcmp(sequence
, "1(nR)nR23(Rn)Rn45(nR)nR."), "root-none select test\n");
529 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, rootnone_select_seq
,
530 "root-none select seq", FALSE
);
532 /* root-child select tests */
533 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
534 r
= TreeView_SelectItem(hTree
, NULL
);
539 r
= TreeView_SelectItem(hTree
, hRoot
);
542 r
= TreeView_SelectItem(hTree
, hRoot
);
545 r
= TreeView_SelectItem(hTree
, hChild
);
548 r
= TreeView_SelectItem(hTree
, hChild
);
551 r
= TreeView_SelectItem(hTree
, hRoot
);
554 ok(!strcmp(sequence
, "1(nR)nR23(RC)RC45(CR)CR."), "root-child select test\n");
555 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, rootchild_select_seq
,
556 "root-child select seq", FALSE
);
558 DestroyWindow(hTree
);
561 static void test_getitemtext(void)
568 CHAR szBuffer
[80] = "Blah";
569 int nBufferSize
= sizeof(szBuffer
)/sizeof(CHAR
);
571 hTree
= create_treeview_control(0);
574 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
576 /* add an item without TVIF_TEXT mask and pszText == NULL */
578 ins
.hInsertAfter
= TVI_ROOT
;
579 U(ins
).item
.mask
= 0;
580 U(ins
).item
.pszText
= NULL
;
581 U(ins
).item
.cchTextMax
= 0;
582 hChild
= TreeView_InsertItem(hTree
, &ins
);
585 /* retrieve it with TVIF_TEXT mask */
587 tvi
.mask
= TVIF_TEXT
;
588 tvi
.cchTextMax
= nBufferSize
;
589 tvi
.pszText
= szBuffer
;
591 SendMessageA( hTree
, TVM_GETITEMA
, 0, (LPARAM
)&tvi
);
592 ok(!strcmp(szBuffer
, ""), "szBuffer=\"%s\", expected \"\"\n", szBuffer
);
593 ok(SendMessageA(hTree
, TVM_DELETEITEM
, 0, (LPARAM
)hChild
), "DeleteItem failed\n");
594 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, getitemtext_seq
, "get item text seq", FALSE
);
596 DestroyWindow(hTree
);
599 static void test_focus(void)
602 static CHAR child1
[] = "Edit",
603 child2
[] = "A really long string";
604 HTREEITEM hChild1
, hChild2
;
608 hTree
= create_treeview_control(0);
611 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
613 /* This test verifies that when a label is being edited, scrolling
614 * the treeview does not cause the label to lose focus. To test
615 * this, first some additional entries are added to generate
619 ins
.hInsertAfter
= hChild
;
620 U(ins
).item
.mask
= TVIF_TEXT
;
621 U(ins
).item
.pszText
= child1
;
622 hChild1
= TreeView_InsertItem(hTree
, &ins
);
624 ins
.hInsertAfter
= hChild1
;
625 U(ins
).item
.mask
= TVIF_TEXT
;
626 U(ins
).item
.pszText
= child2
;
627 hChild2
= TreeView_InsertItem(hTree
, &ins
);
630 ShowWindow(hMainWnd
,SW_SHOW
);
631 SendMessageA(hTree
, TVM_SELECTITEM
, TVGN_CARET
, (LPARAM
)hChild
);
632 hEdit
= TreeView_EditLabel(hTree
, hChild
);
633 ScrollWindowEx(hTree
, -10, 0, NULL
, NULL
, NULL
, NULL
, SW_SCROLLCHILDREN
);
634 ok(GetFocus() == hEdit
, "Edit control should have focus\n");
635 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, focus_seq
, "focus test", TRUE
);
637 DestroyWindow(hTree
);
640 static void test_get_set_bkcolor(void)
642 COLORREF crColor
= RGB(0,0,0);
645 hTree
= create_treeview_control(0);
648 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
650 /* If the value is -1, the control is using the system color for the background color. */
651 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETBKCOLOR
, 0, 0 );
652 ok(crColor
== ~0u, "Default background color reported as 0x%.8x\n", crColor
);
654 /* Test for black background */
655 SendMessage( hTree
, TVM_SETBKCOLOR
, 0, RGB(0,0,0) );
656 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETBKCOLOR
, 0, 0 );
657 ok(crColor
== RGB(0,0,0), "Black background color reported as 0x%.8x\n", crColor
);
659 /* Test for white background */
660 SendMessage( hTree
, TVM_SETBKCOLOR
, 0, RGB(255,255,255) );
661 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETBKCOLOR
, 0, 0 );
662 ok(crColor
== RGB(255,255,255), "White background color reported as 0x%.8x\n", crColor
);
664 /* Reset the default background */
665 SendMessage( hTree
, TVM_SETBKCOLOR
, 0, -1 );
667 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_bkcolor_seq
,
668 "test get set bkcolor", FALSE
);
670 DestroyWindow(hTree
);
673 static void test_get_set_imagelist(void)
678 hTree
= create_treeview_control(0);
681 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
683 /* Test a NULL HIMAGELIST */
684 SendMessage( hTree
, TVM_SETIMAGELIST
, TVSIL_NORMAL
, 0 );
685 himl
= (HIMAGELIST
)SendMessage( hTree
, TVM_GETIMAGELIST
, TVSIL_NORMAL
, 0 );
686 ok(himl
== NULL
, "NULL image list, reported as %p, expected 0.\n", himl
);
688 /* TODO: Test an actual image list */
690 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_imagelist_seq
,
691 "test get imagelist", FALSE
);
693 DestroyWindow(hTree
);
696 static void test_get_set_indent(void)
699 int ulMinIndent
= -1;
700 int ulMoreThanTwiceMin
= -1;
703 hTree
= create_treeview_control(0);
706 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
708 /* Finding the minimum indent */
709 SendMessage( hTree
, TVM_SETINDENT
, 0, 0 );
710 ulMinIndent
= (int)SendMessage( hTree
, TVM_GETINDENT
, 0, 0 );
712 /* Checking an indent that is more than twice the default indent */
713 ulMoreThanTwiceMin
= 2*ulMinIndent
+1;
714 SendMessage( hTree
, TVM_SETINDENT
, ulMoreThanTwiceMin
, 0 );
715 ulIndent
= (DWORD
)SendMessage( hTree
, TVM_GETINDENT
, 0, 0 );
716 ok(ulIndent
== ulMoreThanTwiceMin
, "Indent reported as %d, expected %d\n", ulIndent
, ulMoreThanTwiceMin
);
718 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_indent_seq
,
719 "test get set indent", FALSE
);
721 DestroyWindow(hTree
);
724 static void test_get_set_insertmark(void)
726 COLORREF crColor
= RGB(0,0,0);
729 hTree
= create_treeview_control(0);
732 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
734 SendMessage( hTree
, TVM_SETINSERTMARKCOLOR
, 0, crColor
);
735 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETINSERTMARKCOLOR
, 0, 0 );
736 ok(crColor
== RGB(0,0,0), "Insert mark color reported as 0x%.8x, expected 0x00000000\n", crColor
);
738 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_insertmarkcolor_seq
,
739 "test get set insertmark color", FALSE
);
741 DestroyWindow(hTree
);
744 static void test_get_set_item(void)
746 TVITEMA tviRoot
= {0};
747 int nBufferSize
= 80;
748 char szBuffer
[80] = {0};
752 hTree
= create_treeview_control(0);
755 tviRoot
.hItem
= hRoot
;
756 tviRoot
.mask
= TVIF_STATE
;
757 tviRoot
.state
= TVIS_FOCUSED
;
758 tviRoot
.stateMask
= TVIS_FOCUSED
;
759 ret
= SendMessage( hTree
, TVM_SETITEMA
, 0, (LPARAM
)&tviRoot
);
762 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
764 /* Test the root item, state is set even when not requested */
765 tviRoot
.hItem
= hRoot
;
766 tviRoot
.mask
= TVIF_TEXT
;
768 tviRoot
.stateMask
= 0;
769 tviRoot
.cchTextMax
= nBufferSize
;
770 tviRoot
.pszText
= szBuffer
;
771 ret
= SendMessage( hTree
, TVM_GETITEMA
, 0, (LPARAM
)&tviRoot
);
773 ok(!strcmp("Root", szBuffer
), "GetItem: szBuffer=\"%s\", expected \"Root\"\n", szBuffer
);
774 ok(tviRoot
.state
== TVIS_FOCUSED
, "got 0x%0x\n", tviRoot
.state
);
776 /* Change the root text */
777 strncpy(szBuffer
, "Testing123", nBufferSize
);
778 ret
= SendMessage( hTree
, TVM_SETITEMA
, 0, (LPARAM
)&tviRoot
);
780 memset(szBuffer
, 0, nBufferSize
);
781 ret
= SendMessage( hTree
, TVM_GETITEMA
, 0, (LPARAM
)&tviRoot
);
783 ok(!strcmp("Testing123", szBuffer
), "GetItem: szBuffer=\"%s\", expected \"Testing123\"\n", szBuffer
);
785 /* Reset the root text */
786 memset(szBuffer
, 0, nBufferSize
);
787 strncpy(szBuffer
, "Root", nBufferSize
);
788 ret
= SendMessage( hTree
, TVM_SETITEMA
, 0, (LPARAM
)&tviRoot
);
791 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_item_seq
,
792 "test get set item", FALSE
);
794 DestroyWindow(hTree
);
797 static void test_get_set_itemheight(void)
803 hTree
= create_treeview_control(0);
806 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
808 /* Assuming default height to begin with */
809 ulOldHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
811 /* Explicitly setting and getting the default height */
812 SendMessage( hTree
, TVM_SETITEMHEIGHT
, -1, 0 );
813 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
814 ok(ulNewHeight
== ulOldHeight
, "Default height not set properly, reported %d, expected %d\n", ulNewHeight
, ulOldHeight
);
816 /* Explicitly setting and getting the height of twice the normal */
817 SendMessage( hTree
, TVM_SETITEMHEIGHT
, 2*ulOldHeight
, 0 );
818 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
819 ok(ulNewHeight
== 2*ulOldHeight
, "New height not set properly, reported %d, expected %d\n", ulNewHeight
, 2*ulOldHeight
);
821 /* Assuming tree doesn't have TVS_NONEVENHEIGHT set, so a set of 9 will round down to 8 */
822 SendMessage( hTree
, TVM_SETITEMHEIGHT
, 9, 0 );
823 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
824 ok(ulNewHeight
== 8, "Uneven height not set properly, reported %d, expected %d\n", ulNewHeight
, 8);
826 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_itemheight_seq
,
827 "test get set item height", FALSE
);
829 /* without TVS_NONEVENHEIGHT */
830 SetWindowLong(hTree
, GWL_STYLE
, GetWindowLong(hTree
, GWL_STYLE
) & ~TVS_NONEVENHEIGHT
);
832 ulOldHeight
= SendMessage( hTree
, TVM_SETITEMHEIGHT
, 3, 0);
833 ok(ulOldHeight
== 8, "got %d, expected %d\n", ulOldHeight
, 8);
834 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
835 ok(ulNewHeight
== 2, "got %d, expected %d\n", ulNewHeight
, 2);
837 ulOldHeight
= SendMessage( hTree
, TVM_SETITEMHEIGHT
, 4, 0);
838 ok(ulOldHeight
== 2, "got %d, expected %d\n", ulOldHeight
, 2);
839 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
840 ok(ulNewHeight
== 4, "got %d, expected %d\n", ulNewHeight
, 4);
842 /* with TVS_NONEVENHEIGHT */
843 SetWindowLong(hTree
, GWL_STYLE
, GetWindowLong(hTree
, GWL_STYLE
) | TVS_NONEVENHEIGHT
);
845 ulOldHeight
= SendMessage( hTree
, TVM_SETITEMHEIGHT
, 3, 0);
846 ok(ulOldHeight
== 4, "got %d, expected %d\n", ulOldHeight
, 4);
847 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
848 ok(ulNewHeight
== 3, "got %d, expected %d\n", ulNewHeight
, 3);
850 ulOldHeight
= SendMessage( hTree
, TVM_SETITEMHEIGHT
, 10, 0);
851 ok(ulOldHeight
== 3, "got %d, expected %d\n", ulOldHeight
, 3);
852 ulNewHeight
= (int) SendMessage( hTree
, TVM_GETITEMHEIGHT
, 0, 0 );
853 ok(ulNewHeight
== 10, "got %d, expected %d\n", ulNewHeight
, 10);
855 DestroyWindow(hTree
);
858 static void test_get_set_scrolltime(void)
860 int ulExpectedTime
= 20;
864 hTree
= create_treeview_control(0);
867 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
869 SendMessage( hTree
, TVM_SETSCROLLTIME
, ulExpectedTime
, 0 );
870 ulTime
= (int)SendMessage( hTree
, TVM_GETSCROLLTIME
, 0, 0 );
871 ok(ulTime
== ulExpectedTime
, "Scroll time reported as %d, expected %d\n", ulTime
, ulExpectedTime
);
873 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_scrolltime_seq
,
874 "test get set scroll time", FALSE
);
876 DestroyWindow(hTree
);
879 static void test_get_set_textcolor(void)
881 /* If the value is -1, the control is using the system color for the text color. */
882 COLORREF crColor
= RGB(0,0,0);
885 hTree
= create_treeview_control(0);
888 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
890 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETTEXTCOLOR
, 0, 0 );
891 ok(crColor
== ~0u, "Default text color reported as 0x%.8x\n", crColor
);
893 /* Test for black text */
894 SendMessage( hTree
, TVM_SETTEXTCOLOR
, 0, RGB(0,0,0) );
895 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETTEXTCOLOR
, 0, 0 );
896 ok(crColor
== RGB(0,0,0), "Black text color reported as 0x%.8x\n", crColor
);
898 /* Test for white text */
899 SendMessage( hTree
, TVM_SETTEXTCOLOR
, 0, RGB(255,255,255) );
900 crColor
= (COLORREF
)SendMessage( hTree
, TVM_GETTEXTCOLOR
, 0, 0 );
901 ok(crColor
== RGB(255,255,255), "White text color reported as 0x%.8x\n", crColor
);
903 /* Reset the default text color */
904 SendMessage( hTree
, TVM_SETTEXTCOLOR
, 0, CLR_NONE
);
906 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_textcolor_seq
,
907 "test get set text color", FALSE
);
909 DestroyWindow(hTree
);
912 static void test_get_set_tooltips(void)
914 HWND hwndLastToolTip
= NULL
;
918 hTree
= create_treeview_control(0);
921 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
923 /* show even WS_POPUP treeview don't send NM_TOOLTIPSCREATED */
924 hPopupTreeView
= CreateWindow(WC_TREEVIEW
, NULL
, WS_POPUP
|WS_VISIBLE
, 0, 0, 100, 100, hMainWnd
, NULL
, NULL
, NULL
);
925 DestroyWindow(hPopupTreeView
);
927 /* Testing setting a NULL ToolTip */
928 SendMessage( hTree
, TVM_SETTOOLTIPS
, 0, 0 );
929 hwndLastToolTip
= (HWND
)SendMessage( hTree
, TVM_GETTOOLTIPS
, 0, 0 );
930 ok(hwndLastToolTip
== NULL
, "NULL tool tip, reported as 0x%p, expected 0.\n", hwndLastToolTip
);
932 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_tooltips_seq
,
933 "test get set tooltips", TRUE
);
935 /* TODO: Add a test of an actual tooltip */
936 DestroyWindow(hTree
);
939 static void test_get_set_unicodeformat(void)
941 BOOL bPreviousSetting
= 0;
942 BOOL bNewSetting
= 0;
945 hTree
= create_treeview_control(0);
948 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
951 bPreviousSetting
= (BOOL
)SendMessage( hTree
, TVM_SETUNICODEFORMAT
, 1, 0 );
952 bNewSetting
= (BOOL
)SendMessage( hTree
, TVM_GETUNICODEFORMAT
, 0, 0 );
953 ok(bNewSetting
== 1, "Unicode setting did not work.\n");
956 SendMessage( hTree
, TVM_SETUNICODEFORMAT
, 0, 0 );
957 bNewSetting
= (BOOL
)SendMessage( hTree
, TVM_GETUNICODEFORMAT
, 0, 0 );
958 ok(bNewSetting
== 0, "ANSI setting did not work.\n");
960 /* Revert to original setting */
961 SendMessage( hTree
, TVM_SETUNICODEFORMAT
, bPreviousSetting
, 0 );
963 ok_sequence(sequences
, TREEVIEW_SEQ_INDEX
, test_get_set_unicodeformat_seq
,
964 "test get set unicode format", FALSE
);
966 DestroyWindow(hTree
);
969 static LRESULT CALLBACK
parent_wnd_proc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
971 static LONG defwndproc_counter
= 0;
975 HTREEITEM visibleItem
;
977 msg
.message
= message
;
978 msg
.flags
= sent
|wparam
|lparam
;
979 if (defwndproc_counter
) msg
.flags
|= defwinproc
;
982 if (message
== WM_NOTIFY
&& lParam
) msg
.id
= ((NMHDR
*)lParam
)->code
;
984 /* log system messages, except for painting */
985 if (message
< WM_USER
&&
986 message
!= WM_PAINT
&&
987 message
!= WM_ERASEBKGND
&&
988 message
!= WM_NCPAINT
&&
989 message
!= WM_NCHITTEST
&&
990 message
!= WM_GETTEXT
&&
991 message
!= WM_GETICON
&&
992 message
!= WM_DEVICECHANGE
)
994 trace("parent: %p, %04x, %08lx, %08lx\n", hWnd
, message
, wParam
, lParam
);
995 add_message(sequences
, PARENT_SEQ_INDEX
, &msg
);
1001 NMHDR
*pHdr
= (NMHDR
*)lParam
;
1003 ok(pHdr
->code
!= NM_TOOLTIPSCREATED
, "Treeview should not send NM_TOOLTIPSCREATED\n");
1004 if (pHdr
->idFrom
== 100)
1006 NMTREEVIEWA
*pTreeView
= (LPNMTREEVIEWA
) lParam
;
1009 case TVN_SELCHANGINGA
:
1011 IdentifyItem(pTreeView
->itemOld
.hItem
);
1012 IdentifyItem(pTreeView
->itemNew
.hItem
);
1014 case TVN_SELCHANGEDA
:
1016 IdentifyItem(pTreeView
->itemOld
.hItem
);
1017 IdentifyItem(pTreeView
->itemNew
.hItem
);
1019 case TVN_GETDISPINFOA
: {
1020 NMTVDISPINFOA
*disp
= (NMTVDISPINFOA
*)lParam
;
1021 if (disp
->item
.mask
& TVIF_TEXT
) {
1022 lstrcpyn(disp
->item
.pszText
, TEST_CALLBACK_TEXT
, disp
->item
.cchTextMax
);
1025 if (g_disp_A_to_W
&& (disp
->item
.mask
& TVIF_TEXT
)) {
1026 static const WCHAR testW
[] = {'T','E','S','T','2',0};
1028 disp
->hdr
.code
= TVN_GETDISPINFOW
;
1029 memcpy(disp
->item
.pszText
, testW
, sizeof(testW
));
1032 if (g_disp_set_stateimage
)
1034 ok(disp
->item
.mask
== TVIF_IMAGE
, "got %x\n", disp
->item
.mask
);
1035 /* both masks set here are necessary to change state bits */
1036 disp
->item
.mask
|= TVIF_STATE
;
1037 disp
->item
.state
= TVIS_SELECTED
| INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(3);
1038 disp
->item
.stateMask
= TVIS_SELECTED
| TVIS_OVERLAYMASK
| TVIS_STATEIMAGEMASK
;
1043 case TVN_BEGINLABELEDIT
:
1045 if (g_beginedit_alter_text
)
1047 static const char* textA
= "<edittextaltered>";
1050 edit
= (HWND
)SendMessageA(pHdr
->hwndFrom
, TVM_GETEDITCONTROL
, 0, 0);
1051 ok(IsWindow(edit
), "failed to get edit handle\n");
1052 SetWindowTextA(edit
, textA
);
1058 case TVN_ENDLABELEDIT
: return TRUE
;
1059 case TVN_ITEMEXPANDINGA
:
1060 ok(pTreeView
->itemNew
.mask
==
1061 (TVIF_HANDLE
| TVIF_SELECTEDIMAGE
| TVIF_IMAGE
| TVIF_PARAM
| TVIF_STATE
),
1062 "got wrong mask %x\n", pTreeView
->itemNew
.mask
);
1063 ok((pTreeView
->itemNew
.state
& TVIS_EXPANDED
) == 0,
1064 "got wrong state %x\n", pTreeView
->itemNew
.state
);
1065 ok(pTreeView
->itemOld
.mask
== 0,
1066 "got wrong mask %x\n", pTreeView
->itemOld
.mask
);
1068 if (g_get_from_expand
)
1070 g_item_expanding
.mask
= TVIF_STATE
;
1071 g_item_expanding
.hItem
= hRoot
;
1072 ret
= SendMessageA(pHdr
->hwndFrom
, TVM_GETITEMA
, 0, (LPARAM
)&g_item_expanding
);
1073 ok(ret
== TRUE
, "got %lu\n", ret
);
1076 case TVN_ITEMEXPANDEDA
:
1077 ok(pTreeView
->itemNew
.mask
& TVIF_STATE
, "got wrong mask %x\n", pTreeView
->itemNew
.mask
);
1078 ok(pTreeView
->itemNew
.state
& (TVIS_EXPANDED
|TVIS_EXPANDEDONCE
),
1079 "got wrong mask %x\n", pTreeView
->itemNew
.mask
);
1080 ok(pTreeView
->itemOld
.mask
== 0,
1081 "got wrong mask %x\n", pTreeView
->itemOld
.mask
);
1083 if (g_get_from_expand
)
1085 g_item_expanded
.mask
= TVIF_STATE
;
1086 g_item_expanded
.hItem
= hRoot
;
1087 ret
= SendMessageA(pHdr
->hwndFrom
, TVM_GETITEMA
, 0, (LPARAM
)&g_item_expanded
);
1088 ok(ret
== TRUE
, "got %lu\n", ret
);
1090 if (g_get_rect_in_expand
)
1092 visibleItem
= TreeView_GetNextItem(pHdr
->hwndFrom
, NULL
, TVGN_FIRSTVISIBLE
);
1093 ok(pTreeView
->itemNew
.hItem
== visibleItem
, "expanded item == first visible item\n");
1094 *(HTREEITEM
*)&rect
= visibleItem
;
1095 ok(SendMessage(pHdr
->hwndFrom
, TVM_GETITEMRECT
, TRUE
, (LPARAM
)&rect
), "Failed to get rect for first visible item.\n");
1096 visibleItem
= TreeView_GetNextItem(pHdr
->hwndFrom
, visibleItem
, TVGN_NEXTVISIBLE
);
1097 *(HTREEITEM
*)&rect
= visibleItem
;
1098 ok(visibleItem
!= NULL
, "There must be a visible item after the first visisble item.\n");
1099 ok(SendMessage(pHdr
->hwndFrom
, TVM_GETITEMRECT
, TRUE
, (LPARAM
)&rect
), "Failed to get rect for second visible item.\n");
1102 case TVN_DELETEITEMA
:
1104 struct message item
;
1106 ok(pTreeView
->itemNew
.mask
== 0, "got wrong mask 0x%x\n", pTreeView
->itemNew
.mask
);
1108 ok(pTreeView
->itemOld
.mask
== (TVIF_HANDLE
| TVIF_PARAM
), "got wrong mask 0x%x\n", pTreeView
->itemOld
.mask
);
1109 ok(pTreeView
->itemOld
.hItem
!= NULL
, "got %p\n", pTreeView
->itemOld
.hItem
);
1111 memset(&item
, 0, sizeof(item
));
1112 item
.lParam
= (LPARAM
)pTreeView
->itemOld
.hItem
;
1113 add_message(item_sequence
, 0, &item
);
1127 defwndproc_counter
++;
1128 ret
= DefWindowProcA(hWnd
, message
, wParam
, lParam
);
1129 defwndproc_counter
--;
1134 static void test_expandinvisible(void)
1136 static CHAR nodeText
[][5] = {"0", "1", "2", "3", "4"};
1137 TVINSERTSTRUCTA ins
;
1144 hTree
= create_treeview_control(0);
1146 /* The test builds the following tree and expands node 1, while node 0 is collapsed.
1156 ret
= TreeView_DeleteAllItems(hTree
);
1157 ok(ret
== TRUE
, "ret\n");
1158 ins
.hParent
= TVI_ROOT
;
1159 ins
.hInsertAfter
= TVI_ROOT
;
1160 U(ins
).item
.mask
= TVIF_TEXT
;
1161 U(ins
).item
.pszText
= nodeText
[0];
1162 node
[0] = TreeView_InsertItem(hTree
, &ins
);
1165 ins
.hInsertAfter
= TVI_LAST
;
1166 U(ins
).item
.mask
= TVIF_TEXT
;
1167 ins
.hParent
= node
[0];
1169 U(ins
).item
.pszText
= nodeText
[1];
1170 node
[1] = TreeView_InsertItem(hTree
, &ins
);
1172 U(ins
).item
.pszText
= nodeText
[4];
1173 node
[4] = TreeView_InsertItem(hTree
, &ins
);
1176 ins
.hParent
= node
[1];
1178 U(ins
).item
.pszText
= nodeText
[2];
1179 node
[2] = TreeView_InsertItem(hTree
, &ins
);
1181 U(ins
).item
.pszText
= nodeText
[3];
1182 node
[3] = TreeView_InsertItem(hTree
, &ins
);
1186 nodeVisible
= TreeView_GetItemRect(hTree
, node
[1], &dummyRect
, FALSE
);
1187 ok(!nodeVisible
, "Node 1 should not be visible.\n");
1188 nodeVisible
= TreeView_GetItemRect(hTree
, node
[2], &dummyRect
, FALSE
);
1189 ok(!nodeVisible
, "Node 2 should not be visible.\n");
1190 nodeVisible
= TreeView_GetItemRect(hTree
, node
[3], &dummyRect
, FALSE
);
1191 ok(!nodeVisible
, "Node 3 should not be visible.\n");
1192 nodeVisible
= TreeView_GetItemRect(hTree
, node
[4], &dummyRect
, FALSE
);
1193 ok(!nodeVisible
, "Node 4 should not be visible.\n");
1195 ok(TreeView_Expand(hTree
, node
[1], TVE_EXPAND
), "Expand of node 1 failed.\n");
1197 nodeVisible
= TreeView_GetItemRect(hTree
, node
[1], &dummyRect
, FALSE
);
1198 ok(!nodeVisible
, "Node 1 should not be visible.\n");
1199 nodeVisible
= TreeView_GetItemRect(hTree
, node
[2], &dummyRect
, FALSE
);
1200 ok(!nodeVisible
, "Node 2 should not be visible.\n");
1201 nodeVisible
= TreeView_GetItemRect(hTree
, node
[3], &dummyRect
, FALSE
);
1202 ok(!nodeVisible
, "Node 3 should not be visible.\n");
1203 nodeVisible
= TreeView_GetItemRect(hTree
, node
[4], &dummyRect
, FALSE
);
1204 ok(!nodeVisible
, "Node 4 should not be visible.\n");
1206 DestroyWindow(hTree
);
1209 static void test_itemedit(void)
1217 hTree
= create_treeview_control(0);
1220 /* try with null item */
1221 edit
= (HWND
)SendMessage(hTree
, TVM_EDITLABELA
, 0, 0);
1222 ok(!IsWindow(edit
), "Expected valid handle\n");
1225 edit
= (HWND
)SendMessage(hTree
, TVM_EDITLABELA
, 0, (LPARAM
)hRoot
);
1226 ok(IsWindow(edit
), "Expected valid handle\n");
1227 /* item shouldn't be selected automatically after TVM_EDITLABEL */
1228 r
= SendMessage(hTree
, TVM_GETITEMSTATE
, (WPARAM
)hRoot
, TVIS_SELECTED
);
1230 /* try to cancel with wrong edit handle */
1231 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), 0);
1233 ok(IsWindow(edit
), "Expected edit control to be valid\n");
1234 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), (LPARAM
)edit
);
1236 ok(!IsWindow(edit
), "Expected edit control to be destroyed\n");
1237 /* try to cancel without creating edit */
1238 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), 0);
1241 /* try to cancel with wrong (not null) handle */
1242 edit
= (HWND
)SendMessage(hTree
, TVM_EDITLABELA
, 0, (LPARAM
)hRoot
);
1243 ok(IsWindow(edit
), "Expected valid handle\n");
1244 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), (LPARAM
)hTree
);
1246 ok(IsWindow(edit
), "Expected edit control to be valid\n");
1247 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), (LPARAM
)edit
);
1250 /* remove selection after starting edit */
1251 r
= TreeView_SelectItem(hTree
, hRoot
);
1253 edit
= (HWND
)SendMessage(hTree
, TVM_EDITLABELA
, 0, (LPARAM
)hRoot
);
1254 ok(IsWindow(edit
), "Expected valid handle\n");
1255 r
= TreeView_SelectItem(hTree
, NULL
);
1259 r
= SendMessage(edit
, WM_SETTEXT
, 0, (LPARAM
)buffA
);
1261 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), (LPARAM
)edit
);
1263 ok(!IsWindow(edit
), "Expected edit control to be destroyed\n");
1264 /* check that text is saved */
1265 item
.mask
= TVIF_TEXT
;
1267 item
.pszText
= buffA
;
1268 item
.cchTextMax
= sizeof(buffA
)/sizeof(CHAR
);
1269 r
= SendMessage(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1271 ok(!strcmp("x", buffA
), "Expected item text to change\n");
1273 /* try A/W messages */
1274 edit
= (HWND
)SendMessageA(hTree
, TVM_EDITLABELA
, 0, (LPARAM
)hRoot
);
1275 ok(IsWindow(edit
), "Expected valid handle\n");
1276 ok(IsWindowUnicode(edit
), "got ansi window\n");
1277 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), (LPARAM
)edit
);
1279 ok(!IsWindow(edit
), "expected invalid handle\n");
1281 edit
= (HWND
)SendMessageA(hTree
, TVM_EDITLABELW
, 0, (LPARAM
)hRoot
);
1282 ok(IsWindow(edit
), "Expected valid handle\n");
1283 ok(IsWindowUnicode(edit
), "got ansi window\n");
1284 r
= SendMessage(hTree
, WM_COMMAND
, MAKEWPARAM(0, EN_KILLFOCUS
), (LPARAM
)edit
);
1287 /* alter text during TVM_BEGINLABELEDIT, check that it's preserved */
1288 strcpy(buffA
, "<root>");
1290 item
.mask
= TVIF_TEXT
;
1292 item
.pszText
= buffA
;
1293 item
.cchTextMax
= 0;
1294 r
= SendMessage(hTree
, TVM_SETITEMA
, 0, (LPARAM
)&item
);
1297 g_beginedit_alter_text
= TRUE
;
1298 edit
= (HWND
)SendMessageA(hTree
, TVM_EDITLABELA
, 0, (LPARAM
)hRoot
);
1299 ok(IsWindow(edit
), "Expected valid handle\n");
1300 g_beginedit_alter_text
= FALSE
;
1302 GetWindowTextA(edit
, buffA
, sizeof(buffA
)/sizeof(CHAR
));
1303 ok(!strcmp(buffA
, "<edittextaltered>"), "got string %s\n", buffA
);
1305 DestroyWindow(hTree
);
1308 static void test_treeview_classinfo(void)
1312 memset(&cls
, 0, sizeof(cls
));
1313 GetClassInfo(GetModuleHandleA("comctl32.dll"), WC_TREEVIEWA
, &cls
);
1314 ok(cls
.hbrBackground
== NULL
, "Expected NULL background brush, got %p\n", cls
.hbrBackground
);
1315 ok(cls
.style
== (CS_GLOBALCLASS
| CS_DBLCLKS
), "Expected got %x\n", cls
.style
);
1316 expect(0, cls
.cbClsExtra
);
1319 static void test_get_linecolor(void)
1324 hTree
= create_treeview_control(0);
1326 /* newly created control has default color */
1327 clr
= (COLORREF
)SendMessage(hTree
, TVM_GETLINECOLOR
, 0, 0);
1329 win_skip("TVM_GETLINECOLOR is not supported on comctl32 < 5.80\n");
1331 expect(CLR_DEFAULT
, clr
);
1333 DestroyWindow(hTree
);
1336 static void test_get_insertmarkcolor(void)
1341 hTree
= create_treeview_control(0);
1343 /* newly created control has default color */
1344 clr
= (COLORREF
)SendMessage(hTree
, TVM_GETINSERTMARKCOLOR
, 0, 0);
1346 win_skip("TVM_GETINSERTMARKCOLOR is not supported on comctl32 < 5.80\n");
1348 expect(CLR_DEFAULT
, clr
);
1350 DestroyWindow(hTree
);
1353 static void test_expandnotify(void)
1359 hTree
= create_treeview_control(0);
1363 item
.mask
= TVIF_STATE
;
1365 item
.state
= TVIS_EXPANDED
;
1366 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1368 ok((item
.state
& TVIS_EXPANDED
) == 0, "expected collapsed\n");
1370 /* preselect root node here */
1371 ret
= SendMessageA(hTree
, TVM_SELECTITEM
, TVGN_CARET
, (LPARAM
)hRoot
);
1374 g_get_from_expand
= TRUE
;
1376 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1377 g_item_expanding
.state
= 0xdeadbeef;
1378 g_item_expanded
.state
= 0xdeadbeef;
1379 ret
= SendMessageA(hTree
, TVM_EXPAND
, TVE_EXPAND
, (LPARAM
)hRoot
);
1381 ok(g_item_expanding
.state
== TVIS_SELECTED
, "got state on TVN_ITEMEXPANDING 0x%08x\n",
1382 g_item_expanding
.state
);
1383 ok(g_item_expanded
.state
== (TVIS_SELECTED
|TVIS_EXPANDED
), "got state on TVN_ITEMEXPANDED 0x%08x\n",
1384 g_item_expanded
.state
);
1385 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_expand_seq
, "expand notifications", FALSE
);
1386 g_get_from_expand
= FALSE
;
1388 /* check that it's expanded */
1389 item
.state
= TVIS_EXPANDED
;
1390 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1392 ok((item
.state
& TVIS_EXPANDED
) == TVIS_EXPANDED
, "expected expanded\n");
1395 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1396 ret
= SendMessageA(hTree
, TVM_EXPAND
, TVE_COLLAPSE
, (LPARAM
)hRoot
);
1398 item
.state
= TVIS_EXPANDED
;
1399 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1401 ok((item
.state
& TVIS_EXPANDED
) == 0, "expected collapsed\n");
1402 /* all further collapse/expand attempts won't produce any notifications,
1403 the only way is to reset with all children removed */
1404 ok_sequence(sequences
, PARENT_SEQ_INDEX
, empty_seq
, "collapse after expand notifications", FALSE
);
1406 /* try to toggle child that doesn't have children itself */
1407 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1408 ret
= SendMessageA(hTree
, TVM_EXPAND
, TVE_TOGGLE
, (LPARAM
)hChild
);
1410 ok_sequence(sequences
, PARENT_SEQ_INDEX
, empty_seq
, "toggle node without children", FALSE
);
1412 DestroyWindow(hTree
);
1414 /* test TVM_GETITEMRECT inside TVN_ITEMEXPANDED notification */
1415 hTree
= create_treeview_control(0);
1417 g_get_rect_in_expand
= TRUE
;
1418 ret
= TreeView_Select(hTree
, hChild
, TVGN_CARET
);
1420 g_get_rect_in_expand
= FALSE
;
1422 DestroyWindow(hTree
);
1424 /* TVE_TOGGLE acts as any other TVM_EXPAND */
1425 hTree
= create_treeview_control(0);
1428 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1429 ret
= SendMessageA(hTree
, TVM_EXPAND
, TVE_TOGGLE
, (LPARAM
)hRoot
);
1431 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_expand_seq
, "toggle node (expand)", FALSE
);
1433 /* toggle again - no notifications */
1434 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1435 ret
= SendMessageA(hTree
, TVM_EXPAND
, TVE_TOGGLE
, (LPARAM
)hRoot
);
1437 ok_sequence(sequences
, PARENT_SEQ_INDEX
, empty_seq
, "toggle node (collapse)", FALSE
);
1439 DestroyWindow(hTree
);
1441 /* some keyboard events are also translated to expand */
1442 hTree
= create_treeview_control(0);
1445 /* preselect root node here */
1446 ret
= SendMessageA(hTree
, TVM_SELECTITEM
, TVGN_CARET
, (LPARAM
)hRoot
);
1449 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1450 ret
= SendMessageA(hTree
, WM_KEYDOWN
, VK_ADD
, 0);
1452 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_expand_kb_seq
, "expand node", FALSE
);
1455 ret
= SendMessageA(hTree
, WM_KEYDOWN
, VK_RIGHT
, 0);
1458 /* try to expand child that doesn't have children itself */
1459 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1460 ret
= SendMessageA(hTree
, WM_KEYDOWN
, VK_ADD
, 0);
1462 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_expand_empty_kb_seq
, "expand node with no children", TRUE
);
1464 DestroyWindow(hTree
);
1467 static void test_expandedimage(void)
1473 hTree
= create_treeview_control(0);
1476 item
.mask
= TVIF_EXPANDEDIMAGE
;
1477 item
.iExpandedImage
= 1;
1479 ret
= SendMessageA(hTree
, TVM_SETITEMA
, 0, (LPARAM
)&item
);
1480 ok(ret
, "got %d\n", ret
);
1482 item
.mask
= TVIF_EXPANDEDIMAGE
;
1483 item
.iExpandedImage
= -1;
1485 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1486 ok(ret
, "got %d\n", ret
);
1488 if (item
.iExpandedImage
!= 1)
1490 win_skip("TVIF_EXPANDEDIMAGE not supported\n");
1491 DestroyWindow(hTree
);
1495 /* test for default iExpandedImage value */
1496 item
.mask
= TVIF_EXPANDEDIMAGE
;
1497 item
.iExpandedImage
= -1;
1498 item
.hItem
= hChild
;
1499 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1500 ok(ret
, "got %d\n", ret
);
1501 ok(item
.iExpandedImage
== (WORD
)I_IMAGENONE
, "got %d\n", item
.iExpandedImage
);
1503 DestroyWindow(hTree
);
1506 static void test_TVS_SINGLEEXPAND(void)
1511 hTree
= create_treeview_control(0);
1512 SetWindowLongA(hTree
, GWL_STYLE
, GetWindowLong(hTree
, GWL_STYLE
) | TVS_SINGLEEXPAND
);
1513 /* to avoid painting related notifications */
1514 ShowWindow(hTree
, SW_HIDE
);
1517 flush_sequences(sequences
, NUM_MSG_SEQUENCES
);
1518 ret
= SendMessageA(hTree
, TVM_SELECTITEM
, TVGN_CARET
, (LPARAM
)hRoot
);
1519 ok(ret
, "got %d\n", ret
);
1520 ok_sequence(sequences
, PARENT_SEQ_INDEX
, parent_singleexpand_seq
, "singleexpand notifications", FALSE
);
1522 /* a workaround for NT4 that sends expand notifications when nothing is about to expand */
1523 ret
= SendMessageA(hTree
, TVM_DELETEITEM
, 0, (LPARAM
)hRoot
);
1524 ok(ret
, "got %d\n", ret
);
1526 ret
= SendMessageA(hTree
, TVM_SELECTITEM
, TVGN_CARET
, 0);
1527 ok(ret
, "got %d\n", ret
);
1529 DestroyWindow(hTree
);
1532 static void test_WM_PAINT(void)
1540 hTree
= create_treeview_control(0);
1542 clr
= SendMessageA(hTree
, TVM_SETBKCOLOR
, 0, RGB(255, 0, 0));
1543 ok(clr
== ~0u, "got %d, expected -1\n", clr
);
1545 hdc
= GetDC(hMainWnd
);
1547 GetClientRect(hMainWnd
, &rc
);
1548 FillRect(hdc
, &rc
, GetStockObject(BLACK_BRUSH
));
1550 clr
= GetPixel(hdc
, 1, 1);
1551 ok(clr
== RGB(0, 0, 0), "got 0x%x\n", clr
);
1553 ret
= SendMessageA(hTree
, WM_PAINT
, (WPARAM
)hdc
, 0);
1554 ok(ret
== 0, "got %d\n", ret
);
1556 clr
= GetPixel(hdc
, 1, 1);
1557 ok(clr
== RGB(255, 0, 0) || broken(clr
== RGB(0, 0, 0)) /* win98 */,
1560 ReleaseDC(hMainWnd
, hdc
);
1562 DestroyWindow(hTree
);
1565 static void test_delete_items(void)
1567 const struct message
*msg
;
1571 hTree
= create_treeview_control(0);
1574 /* check delete order */
1575 flush_sequences(item_sequence
, 1);
1576 ret
= SendMessage(hTree
, TVM_DELETEITEM
, 0, 0);
1577 ok(ret
== TRUE
, "got %d\n", ret
);
1579 msg
= item_sequence
[0]->sequence
;
1580 ok(item_sequence
[0]->count
== 2, "expected 2 items, got %d\n", item_sequence
[0]->count
);
1582 if (item_sequence
[0]->count
== 2)
1584 ok(msg
[0].lParam
== (LPARAM
)hChild
, "expected %p, got 0x%lx\n", hChild
, msg
[0].lParam
);
1585 ok(msg
[1].lParam
== (LPARAM
)hRoot
, "expected %p, got 0x%lx\n", hRoot
, msg
[1].lParam
);
1588 ret
= SendMessageA(hTree
, TVM_GETCOUNT
, 0, 0);
1589 ok(ret
== 0, "got %d\n", ret
);
1591 DestroyWindow(hTree
);
1596 HTREEITEM parent
; /* for root value of parent field is unidetified */
1597 HTREEITEM nextsibling
;
1598 HTREEITEM firstchild
;
1601 static void _check_item(HTREEITEM item
, HTREEITEM parent
, HTREEITEM nextsibling
, HTREEITEM firstchild
, int line
)
1603 struct _ITEM_DATA
*data
= (struct _ITEM_DATA
*)item
;
1605 ok_(__FILE__
, line
)(data
->parent
== parent
, "parent %p, got %p\n", parent
, data
->parent
);
1606 ok_(__FILE__
, line
)(data
->nextsibling
== nextsibling
, "sibling %p, got %p\n", nextsibling
, data
->nextsibling
);
1607 ok_(__FILE__
, line
)(data
->firstchild
== firstchild
, "firstchild %p, got %p\n", firstchild
, data
->firstchild
);
1610 #define check_item(a, b, c, d) _check_item(a, b, c, d, __LINE__)
1612 static void test_htreeitem_layout(void)
1614 TVINSERTSTRUCTA ins
;
1615 HTREEITEM item1
, item2
;
1618 hTree
= create_treeview_control(0);
1621 /* root has some special pointer in parent field */
1622 check_item(hRoot
, ((struct _ITEM_DATA
*)hRoot
)->parent
, 0, hChild
);
1623 check_item(hChild
, hRoot
, 0, 0);
1625 ins
.hParent
= hChild
;
1626 ins
.hInsertAfter
= TVI_FIRST
;
1627 U(ins
).item
.mask
= 0;
1628 item1
= TreeView_InsertItem(hTree
, &ins
);
1630 check_item(item1
, hChild
, 0, 0);
1632 ins
.hParent
= hRoot
;
1633 ins
.hInsertAfter
= TVI_FIRST
;
1634 U(ins
).item
.mask
= 0;
1635 item2
= TreeView_InsertItem(hTree
, &ins
);
1637 check_item(item2
, hRoot
, hChild
, 0);
1639 SendMessage(hTree
, TVM_DELETEITEM
, 0, (LPARAM
)hChild
);
1641 /* without children now */
1642 check_item(hRoot
, ((struct _ITEM_DATA
*)hRoot
)->parent
, 0, item2
);
1644 DestroyWindow(hTree
);
1647 static void test_TVS_CHECKBOXES(void)
1649 HIMAGELIST himl
, himl2
;
1654 hTree
= create_treeview_control(0);
1657 himl
= (HIMAGELIST
)SendMessageA(hTree
, TVM_GETIMAGELIST
, TVSIL_STATE
, 0);
1658 ok(himl
== NULL
, "got %p\n", himl
);
1661 item
.mask
= TVIF_STATE
;
1662 item
.state
= INDEXTOSTATEIMAGEMASK(1);
1663 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1664 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1666 ok(item
.state
== 0, "got 0x%x\n", item
.state
);
1668 /* set some index for a child */
1669 item
.hItem
= hChild
;
1670 item
.mask
= TVIF_STATE
;
1671 item
.state
= INDEXTOSTATEIMAGEMASK(4);
1672 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1673 ret
= SendMessageA(hTree
, TVM_SETITEMA
, 0, (LPARAM
)&item
);
1676 /* enabling check boxes set all items to 1 state image index */
1677 SetWindowLongA(hTree
, GWL_STYLE
, GetWindowLongA(hTree
, GWL_STYLE
) | TVS_CHECKBOXES
);
1678 himl
= (HIMAGELIST
)SendMessageA(hTree
, TVM_GETIMAGELIST
, TVSIL_STATE
, 0);
1679 ok(himl
!= NULL
, "got %p\n", himl
);
1681 himl2
= (HIMAGELIST
)SendMessageA(hTree
, TVM_GETIMAGELIST
, TVSIL_STATE
, 0);
1682 ok(himl2
!= NULL
, "got %p\n", himl2
);
1683 ok(himl2
== himl
, "got %p, expected %p\n", himl2
, himl
);
1686 item
.mask
= TVIF_STATE
;
1688 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1689 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1691 ok(item
.state
== INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item
.state
);
1693 item
.hItem
= hChild
;
1694 item
.mask
= TVIF_STATE
;
1696 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1697 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1699 ok(item
.state
== INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item
.state
);
1701 /* create another control and check its checkbox list */
1702 hTree2
= create_treeview_control(0);
1705 /* set some index for a child */
1706 item
.hItem
= hChild
;
1707 item
.mask
= TVIF_STATE
;
1708 item
.state
= INDEXTOSTATEIMAGEMASK(4);
1709 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1710 ret
= SendMessageA(hTree2
, TVM_SETITEMA
, 0, (LPARAM
)&item
);
1713 /* enabling check boxes set all items to 1 state image index */
1714 SetWindowLongA(hTree2
, GWL_STYLE
, GetWindowLongA(hTree
, GWL_STYLE
) | TVS_CHECKBOXES
);
1715 himl2
= (HIMAGELIST
)SendMessageA(hTree2
, TVM_GETIMAGELIST
, TVSIL_STATE
, 0);
1716 ok(himl2
!= NULL
, "got %p\n", himl2
);
1717 ok(himl
!= himl2
, "got %p, expected %p\n", himl2
, himl
);
1719 DestroyWindow(hTree2
);
1720 DestroyWindow(hTree
);
1722 /* the same, but initially created with TVS_CHECKBOXES */
1723 hTree
= create_treeview_control(0);
1725 himl
= (HIMAGELIST
)SendMessageA(hTree
, TVM_GETIMAGELIST
, TVSIL_STATE
, 0);
1726 ok(himl
== NULL
, "got %p\n", himl
);
1727 DestroyWindow(hTree
);
1729 hTree
= create_treeview_control(TVS_CHECKBOXES
);
1731 himl
= (HIMAGELIST
)SendMessageA(hTree
, TVM_GETIMAGELIST
, TVSIL_STATE
, 0);
1732 todo_wine
ok(himl
== NULL
, "got %p\n", himl
);
1735 item
.mask
= TVIF_STATE
;
1737 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1738 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1740 ok(item
.state
== INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item
.state
);
1742 item
.hItem
= hChild
;
1743 item
.mask
= TVIF_STATE
;
1745 item
.stateMask
= TVIS_STATEIMAGEMASK
;
1746 ret
= SendMessageA(hTree
, TVM_GETITEMA
, 0, (LPARAM
)&item
);
1748 ok(item
.state
== INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item
.state
);
1750 DestroyWindow(hTree
);
1753 static void test_TVM_GETNEXTITEM(void)
1758 hTree
= create_treeview_control(0);
1761 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_ROOT
, 0);
1762 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1764 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_ROOT
, (LPARAM
)TVI_ROOT
);
1765 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1767 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_ROOT
, (LPARAM
)hRoot
);
1768 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1770 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_ROOT
, (LPARAM
)hChild
);
1771 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1773 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_CHILD
, 0);
1774 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1776 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_CHILD
, (LPARAM
)hRoot
);
1777 ok(item
== hChild
, "got %p, expected %p\n", item
, hChild
);
1779 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_CHILD
, (LPARAM
)TVI_ROOT
);
1780 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1782 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_PARENT
, 0);
1783 ok(item
== NULL
, "got %p\n", item
);
1785 item
= (HTREEITEM
)SendMessageA(hTree
, TVM_GETNEXTITEM
, TVGN_PARENT
, (LPARAM
)hChild
);
1786 ok(item
== hRoot
, "got %p, expected %p\n", item
, hRoot
);
1788 DestroyWindow(hTree
);
1791 START_TEST(treeview
)
1794 BOOL (WINAPI
*pInitCommonControlsEx
)(const INITCOMMONCONTROLSEX
*);
1798 ULONG_PTR ctx_cookie
;
1802 hComctl32
= GetModuleHandleA("comctl32.dll");
1803 pInitCommonControlsEx
= (void*)GetProcAddress(hComctl32
, "InitCommonControlsEx");
1804 if (pInitCommonControlsEx
)
1806 INITCOMMONCONTROLSEX iccex
;
1807 iccex
.dwSize
= sizeof(iccex
);
1808 iccex
.dwICC
= ICC_TREEVIEW_CLASSES
;
1809 pInitCommonControlsEx(&iccex
);
1812 InitCommonControls();
1814 init_msg_sequences(sequences
, NUM_MSG_SEQUENCES
);
1815 init_msg_sequences(item_sequence
, 1);
1817 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
1820 wc
.hInstance
= GetModuleHandleA(NULL
);
1822 wc
.hCursor
= LoadCursorA(NULL
, IDC_IBEAM
);
1823 wc
.hbrBackground
= GetSysColorBrush(COLOR_WINDOW
);
1824 wc
.lpszMenuName
= NULL
;
1825 wc
.lpszClassName
= "MyTestWnd";
1826 wc
.lpfnWndProc
= parent_wnd_proc
;
1827 RegisterClassA(&wc
);
1829 hMainWnd
= CreateWindowExA(0, "MyTestWnd", "Blah", WS_OVERLAPPEDWINDOW
,
1830 CW_USEDEFAULT
, CW_USEDEFAULT
, 130, 105, NULL
, NULL
, GetModuleHandleA(NULL
), 0);
1832 ok(hMainWnd
!= NULL
, "Failed to create parent window. Tests aborted.\n");
1833 if (!hMainWnd
) return;
1839 test_get_set_bkcolor();
1840 test_get_set_imagelist();
1841 test_get_set_indent();
1842 test_get_set_insertmark();
1843 test_get_set_item();
1844 test_get_set_itemheight();
1845 test_get_set_scrolltime();
1846 test_get_set_textcolor();
1847 test_get_linecolor();
1848 test_get_insertmarkcolor();
1849 test_get_set_tooltips();
1850 test_get_set_unicodeformat();
1852 test_expandinvisible();
1854 test_treeview_classinfo();
1855 test_expandnotify();
1856 test_TVS_SINGLEEXPAND();
1858 test_delete_items();
1859 test_htreeitem_layout();
1860 test_TVS_CHECKBOXES();
1861 test_TVM_GETNEXTITEM();
1863 if (!load_v6_module(&ctx_cookie
, &hCtx
))
1865 DestroyWindow(hMainWnd
);
1869 /* this is a XP SP3 failure workaround */
1870 hwnd
= CreateWindowExA(0, WC_TREEVIEW
, "foo",
1871 WS_CHILD
| WS_BORDER
| WS_VISIBLE
,
1873 hMainWnd
, NULL
, GetModuleHandleA(NULL
), NULL
);
1874 if (!IsWindow(hwnd
))
1876 win_skip("FIXME: failed to create TreeView window.\n");
1877 unload_v6_module(ctx_cookie
, hCtx
);
1878 DestroyWindow(hMainWnd
);
1882 DestroyWindow(hwnd
);
1884 /* comctl32 version 6 tests start here */
1885 test_expandedimage();
1886 test_htreeitem_layout();
1888 unload_v6_module(ctx_cookie
, hCtx
);
1890 PostMessageA(hMainWnd
, WM_CLOSE
, 0, 0);
1891 while(GetMessageA(&msg
, 0, 0, 0))
1893 TranslateMessage(&msg
);
1894 DispatchMessageA(&msg
);