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

   1 /* Unit tests for treeview.
   2  *
   3  * Copyright 2005 Krzysztof Foltman
   4  * Copyright 2007 Christopher James Peterson
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winnls.h"
  29 #include "winreg.h"
  30 #include "commctrl.h"
  31
  32 #include "wine/test.h"
  33 #include "v6util.h"
  34 #include "msg.h"
  35
  36 static const char *TEST_CALLBACK_TEXT = "callback_text";
  37
  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
  44 #define NUM_MSG_SEQUENCES   2
  45 #define TREEVIEW_SEQ_INDEX  0
  46 #define PARENT_SEQ_INDEX    1
  47
  48 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  49
  50 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
  51 static struct msg_sequence *item_sequence[1];
  52
  53 static const struct message FillRootSeq[] = {
  54     { TVM_INSERTITEM, sent },
  55     { TVM_INSERTITEM, sent },
  56     { 0 }
  57 };
  58
  59 static const struct message rootnone_select_seq[] = {
  60     { TVM_SELECTITEM, sent|wparam, 9 },
  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     { 0 }
  67 };
  68
  69 static const struct message rootchild_select_seq[] = {
  70     { TVM_SELECTITEM, sent|wparam, 9 },
  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     { 0 }
  77 };
  78
  79 static const struct message getitemtext_seq[] = {
  80     { TVM_INSERTITEMA, sent },
  81     { TVM_GETITEMA, sent },
  82     { TVM_DELETEITEM, sent },
  83     { 0 }
  84 };
  85
  86 static const struct message focus_seq[] = {
  87     { TVM_INSERTITEM, sent },
  88     { TVM_INSERTITEM, sent },
  89     { TVM_SELECTITEM, sent|wparam, 9 },
  90     /* The following end up out of order in wine */
  91     { WM_WINDOWPOSCHANGING, sent|defwinproc },
  92     { WM_NCCALCSIZE, sent|wparam|defwinproc, TRUE },
  93     { WM_WINDOWPOSCHANGED, sent|defwinproc },
  94     { WM_SIZE, sent|defwinproc },
  95     { WM_WINDOWPOSCHANGING, sent|defwinproc|optional },
  96     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, TRUE },
  97     { WM_WINDOWPOSCHANGED, sent|defwinproc|optional },
  98     { WM_SIZE, sent|defwinproc|optional },
  99     { WM_PAINT, sent|defwinproc },
 100     { WM_NCPAINT, sent|wparam|defwinproc, 1 },
 101     { WM_ERASEBKGND, sent|defwinproc },
 102     { TVM_EDITLABEL, sent },
 103     { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(0, EN_UPDATE) },
 104     { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(0, EN_CHANGE) },
 105     { WM_PARENTNOTIFY, sent|wparam|defwinproc, MAKEWPARAM(WM_CREATE, 0) },
 106     { WM_KILLFOCUS, sent|defwinproc },
 107     { WM_PAINT, sent|defwinproc },
 108     { WM_IME_SETCONTEXT, sent|defwinproc|optional },
 109     { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(0, EN_SETFOCUS) },
 110     { WM_ERASEBKGND, sent|defwinproc|optional },
 111     { WM_CTLCOLOREDIT, sent|defwinproc|optional },
 112     { WM_CTLCOLOREDIT, sent|defwinproc|optional },
 113     { 0 }
 114 };
 115
 116 static const struct message test_get_set_bkcolor_seq[] = {
 117     { TVM_GETBKCOLOR, sent|wparam|lparam, 0, 0 },
 118     { TVM_SETBKCOLOR, sent|wparam|lparam, 0, 0 },
 119     { TVM_GETBKCOLOR, sent|wparam|lparam, 0, 0 },
 120     { TVM_SETBKCOLOR, sent|wparam|lparam, 0, 0x00ffffff },
 121     { TVM_GETBKCOLOR, sent|wparam|lparam, 0, 0 },
 122     { TVM_SETBKCOLOR, sent|wparam|lparam, 0, -1 },
 123     { 0 }
 124 };
 125
 126 static const struct message test_get_set_imagelist_seq[] = {
 127     { TVM_SETIMAGELIST, sent|wparam|lparam, 0, 0 },
 128     { TVM_GETIMAGELIST, sent|wparam|lparam, 0, 0 },
 129     { 0 }
 130 };
 131
 132 static const struct message test_get_set_indent_seq[] = {
 133     { TVM_SETINDENT, sent|wparam|lparam, 0, 0 },
 134     { TVM_GETINDENT, sent|wparam|lparam, 0, 0 },
 135     /* The actual amount to indent is dependent on the system for this message */
 136     { TVM_SETINDENT, sent },
 137     { TVM_GETINDENT, sent|wparam|lparam, 0, 0 },
 138     { 0 }
 139 };
 140
 141 static const struct message test_get_set_insertmarkcolor_seq[] = {
 142     { TVM_SETINSERTMARKCOLOR, sent|wparam|lparam, 0, 0 },
 143     { TVM_GETINSERTMARKCOLOR, sent|wparam|lparam, 0, 0 },
 144     { 0 }
 145 };
 146
 147 static const struct message test_get_set_item_seq[] = {
 148     { TVM_GETITEMA, sent },
 149     { TVM_SETITEMA, sent },
 150     { TVM_GETITEMA, sent },
 151     { TVM_SETITEMA, sent },
 152     { 0 }
 153 };
 154
 155 static const struct message test_get_set_itemheight_seq[] = {
 156     { TVM_GETITEMHEIGHT, sent|wparam|lparam, 0, 0 },
 157     { TVM_SETITEMHEIGHT, sent|wparam|lparam, -1, 0 },
 158     { TVM_GETITEMHEIGHT, sent|wparam|lparam, 0, 0 },
 159     { TVM_SETITEMHEIGHT, sent|lparam, 0xcccccccc, 0 },
 160     { TVM_GETITEMHEIGHT, sent|wparam|lparam|optional, 0, 0 },
 161     { TVM_SETITEMHEIGHT, sent|wparam|lparam|optional, 9, 0 },
 162     { TVM_GETITEMHEIGHT, sent|wparam|lparam, 0, 0 },
 163     { 0 }
 164 };
 165
 166 static const struct message test_get_set_scrolltime_seq[] = {
 167     { TVM_SETSCROLLTIME, sent|wparam|lparam, 20, 0 },
 168     { TVM_GETSCROLLTIME, sent|wparam|lparam, 0, 0 },
 169     { 0 }
 170 };
 171
 172 static const struct message test_get_set_textcolor_seq[] = {
 173     { TVM_GETTEXTCOLOR, sent|wparam|lparam, 0, 0 },
 174     { TVM_SETTEXTCOLOR, sent|wparam|lparam, 0, 0 },
 175     { TVM_GETTEXTCOLOR, sent|wparam|lparam, 0, 0 },
 176     { TVM_SETTEXTCOLOR, sent|wparam|lparam, 0, RGB(255, 255, 255) },
 177     { TVM_GETTEXTCOLOR, sent|wparam|lparam, 0, 0 },
 178     { TVM_SETTEXTCOLOR, sent|wparam|lparam, 0, CLR_NONE },
 179     { 0 }
 180 };
 181
 182 static const struct message test_get_set_tooltips_seq[] = {
 183     { WM_KILLFOCUS,    sent },
 184     { WM_IME_SETCONTEXT, sent|optional },
 185     { WM_IME_NOTIFY, sent|optional },
 186     { TVM_SETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 187     { TVM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 188     { 0 }
 189 };
 190
 191 static const struct message test_get_set_unicodeformat_seq[] = {
 192     { TVM_SETUNICODEFORMAT, sent|wparam|lparam, TRUE, 0 },
 193     { TVM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 194     { TVM_SETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 195     { TVM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 196     { TVM_SETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 197     { 0 }
 198 };
 199
 200 static const struct message parent_expand_seq[] = {
 201     { WM_NOTIFY, sent|id, 0, 0, TVN_ITEMEXPANDINGA },
 202     { WM_NOTIFY, sent|id, 0, 0, TVN_ITEMEXPANDEDA },
 203     { 0 }
 204 };
 205
 206 static const struct message parent_singleexpand_seq[] = {
 207     { WM_NOTIFY, sent|id, 0, 0, TVN_SELCHANGINGA },
 208     { WM_NOTIFY, sent|id, 0, 0, TVN_SELCHANGEDA },
 209     { WM_NOTIFY, sent|id, 0, 0, TVN_SINGLEEXPAND },
 210     { WM_NOTIFY, sent|id, 0, 0, TVN_ITEMEXPANDINGA },
 211     { WM_NOTIFY, sent|id, 0, 0, TVN_ITEMEXPANDEDA },
 212     { 0 }
 213 };
 214
 215 static const struct message parent_get_dispinfo_seq[] = {
 216     { WM_NOTIFY, sent|id, 0, 0, TVN_GETDISPINFOA },
 217     { 0 }
 218 };
 219
 220 static const struct message empty_seq[] = {
 221     { 0 }
 222 };
 223
 224 static HWND hMainWnd;
 225
 226 static HTREEITEM hRoot, hChild;
 227
 228 static int pos = 0;
 229 static char sequence[256];
 230
 231 static void Clear(void)
 232 {
 233     pos = 0;
 234     sequence[0] = '\0';
 235 }
 236
 237 static void AddItem(char ch)
 238 {
 239     sequence[pos++] = ch;
 240     sequence[pos] = '\0';
 241 }
 242
 243 static void IdentifyItem(HTREEITEM hItem)
 244 {
 245     if (hItem == hRoot) {
 246         AddItem('R');
 247         return;
 248     }
 249     if (hItem == hChild) {
 250         AddItem('C');
 251         return;
 252     }
 253     if (hItem == NULL) {
 254         AddItem('n');
 255         return;
 256     }
 257     AddItem('?');
 258 }
 259
 260 /* This function hooks in and records all messages to the treeview control */
 261 static LRESULT WINAPI TreeviewWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 262 {
 263     static LONG defwndproc_counter = 0;
 264     LRESULT ret;
 265     struct message msg;
 266     WNDPROC lpOldProc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 267
 268     msg.message = message;
 269     msg.flags = sent|wparam|lparam;
 270     if (defwndproc_counter) msg.flags |= defwinproc;
 271     msg.wParam = wParam;
 272     msg.lParam = lParam;
 273     add_message(sequences, TREEVIEW_SEQ_INDEX, &msg);
 274
 275     defwndproc_counter++;
 276     ret = CallWindowProcA(lpOldProc, hwnd, message, wParam, lParam);
 277     defwndproc_counter--;
 278
 279     return ret;
 280 }
 281
 282 static HWND create_treeview_control(DWORD style)
 283 {
 284     WNDPROC pOldWndProc;
 285     HWND hTree;
 286
 287     hTree = CreateWindowExA(WS_EX_CLIENTEDGE, WC_TREEVIEWA, NULL, WS_CHILD|WS_VISIBLE|
 288             TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS|TVS_EDITLABELS|style,
 289             0, 0, 120, 100, hMainWnd, (HMENU)100, GetModuleHandleA(0), 0);
 290
 291     SetFocus(hTree);
 292
 293     /* Record the old WNDPROC so we can call it after recording the messages */
 294     pOldWndProc = (WNDPROC)SetWindowLongPtrA(hTree, GWLP_WNDPROC, (LONG_PTR)TreeviewWndProc);
 295     SetWindowLongPtrA(hTree, GWLP_USERDATA, (LONG_PTR)pOldWndProc);
 296
 297     return hTree;
 298 }
 299
 300 static void fill_tree(HWND hTree)
 301 {
 302     TVINSERTSTRUCTA ins;
 303     static CHAR root[]  = "Root",
 304                 child[] = "Child";
 305
 306     ins.hParent = TVI_ROOT;
 307     ins.hInsertAfter = TVI_ROOT;
 308     U(ins).item.mask = TVIF_TEXT;
 309     U(ins).item.pszText = root;
 310     hRoot = TreeView_InsertItem(hTree, &ins);
 311
 312     ins.hParent = hRoot;
 313     ins.hInsertAfter = TVI_FIRST;
 314     U(ins).item.mask = TVIF_TEXT;
 315     U(ins).item.pszText = child;
 316     hChild = TreeView_InsertItem(hTree, &ins);
 317 }
 318
 319 static void test_fillroot(void)
 320 {
 321     TVITEMA tvi;
 322     HWND hTree;
 323
 324     hTree = create_treeview_control(0);
 325
 326     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 327
 328     fill_tree(hTree);
 329
 330     Clear();
 331     AddItem('A');
 332     assert(hRoot);
 333     AddItem('B');
 334     assert(hChild);
 335     AddItem('.');
 336     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, FillRootSeq, "FillRoot", FALSE);
 337     ok(!strcmp(sequence, "AB."), "Item creation\n");
 338
 339     /* UMLPad 1.15 depends on this being not -1 (I_IMAGECALLBACK) */
 340     tvi.hItem = hRoot;
 341     tvi.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE;
 342     SendMessage( hTree, TVM_GETITEMA, 0, (LPARAM)&tvi );
 343     ok(tvi.iImage == 0, "tvi.iImage=%d\n", tvi.iImage);
 344     ok(tvi.iSelectedImage == 0, "tvi.iSelectedImage=%d\n", tvi.iSelectedImage);
 345
 346     DestroyWindow(hTree);
 347 }
 348
 349 static void test_callback(void)
 350 {
 351     HTREEITEM hRoot;
 352     HTREEITEM hItem1, hItem2;
 353     TVINSERTSTRUCTA ins;
 354     TVITEMA tvi;
 355     CHAR test_string[] = "Test_string";
 356     static const CHAR test2A[] = "TEST2";
 357     CHAR buf[128];
 358     HWND hTree;
 359     DWORD ret;
 360
 361     hTree = create_treeview_control(0);
 362
 363     ret = TreeView_DeleteAllItems(hTree);
 364     expect(TRUE, ret);
 365     ins.hParent = TVI_ROOT;
 366     ins.hInsertAfter = TVI_ROOT;
 367     U(ins).item.mask = TVIF_TEXT;
 368     U(ins).item.pszText = LPSTR_TEXTCALLBACK;
 369     hRoot = TreeView_InsertItem(hTree, &ins);
 370     assert(hRoot);
 371
 372     tvi.hItem = hRoot;
 373     tvi.mask = TVIF_TEXT;
 374     tvi.pszText = buf;
 375     tvi.cchTextMax = sizeof(buf)/sizeof(buf[0]);
 376     ret = TreeView_GetItem(hTree, &tvi);
 377     expect(TRUE, ret);
 378     ok(strcmp(tvi.pszText, TEST_CALLBACK_TEXT) == 0, "Callback item text mismatch %s vs %s\n",
 379         tvi.pszText, TEST_CALLBACK_TEXT);
 380
 381     ins.hParent = hRoot;
 382     ins.hInsertAfter = TVI_FIRST;
 383     U(ins).item.mask = TVIF_TEXT;
 384     U(ins).item.pszText = test_string;
 385     hItem1 = TreeView_InsertItem(hTree, &ins);
 386     assert(hItem1);
 387
 388     tvi.hItem = hItem1;
 389     ret = TreeView_GetItem(hTree, &tvi);
 390     expect(TRUE, ret);
 391     ok(strcmp(tvi.pszText, test_string) == 0, "Item text mismatch %s vs %s\n",
 392         tvi.pszText, test_string);
 393
 394     /* undocumented: pszText of NULL also means LPSTR_CALLBACK: */
 395     tvi.pszText = NULL;
 396     ret = TreeView_SetItem(hTree, &tvi);
 397     expect(TRUE, ret);
 398     tvi.pszText = buf;
 399     ret = TreeView_GetItem(hTree, &tvi);
 400     expect(TRUE, ret);
 401     ok(strcmp(tvi.pszText, TEST_CALLBACK_TEXT) == 0, "Item text mismatch %s vs %s\n",
 402         tvi.pszText, TEST_CALLBACK_TEXT);
 403
 404     U(ins).item.pszText = NULL;
 405     hItem2 = TreeView_InsertItem(hTree, &ins);
 406     assert(hItem2);
 407     tvi.hItem = hItem2;
 408     memset(buf, 0, sizeof(buf));
 409     ret = TreeView_GetItem(hTree, &tvi);
 410     expect(TRUE, ret);
 411     ok(strcmp(tvi.pszText, TEST_CALLBACK_TEXT) == 0, "Item text mismatch %s vs %s\n",
 412         tvi.pszText, TEST_CALLBACK_TEXT);
 413
 414     /* notification handler changed A->W */
 415     g_disp_A_to_W = TRUE;
 416     tvi.hItem = hItem2;
 417     memset(buf, 0, sizeof(buf));
 418     ret = TreeView_GetItem(hTree, &tvi);
 419     expect(TRUE, ret);
 420     ok(strcmp(tvi.pszText, test2A) == 0, "got %s, expected %s\n",
 421         tvi.pszText, test2A);
 422     g_disp_A_to_W = FALSE;
 423
 424     /* handler changes state image index */
 425     SetWindowLongA(hTree, GWL_STYLE, GetWindowLongA(hTree, GWL_STYLE) | TVS_CHECKBOXES);
 426
 427     /* clear selection, handler will set selected state */
 428     ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, 0);
 429     expect(TRUE, ret);
 430
 431     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 432
 433     tvi.hItem = hRoot;
 434     tvi.mask = TVIF_STATE;
 435     tvi.state = TVIS_SELECTED;
 436     ret = TreeView_GetItem(hTree, &tvi);
 437     expect(TRUE, ret);
 438     ok(tvi.state == INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", tvi.state);
 439
 440     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
 441                 "no TVN_GETDISPINFO for a state seq", FALSE);
 442
 443     tvi.hItem     = hRoot;
 444     tvi.mask      = TVIF_IMAGE | TVIF_STATE;
 445     tvi.state     = TVIS_FOCUSED;
 446     tvi.stateMask = TVIS_FOCUSED;
 447     tvi.iImage    = I_IMAGECALLBACK;
 448     ret = TreeView_SetItem(hTree, &tvi);
 449     expect(TRUE, ret);
 450
 451     /* ask for item image index through callback - state is also set with state image index */
 452     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 453
 454     tvi.hItem = hRoot;
 455     tvi.mask = TVIF_IMAGE;
 456     tvi.state = 0;
 457     ret = TreeView_GetItem(hTree, &tvi);
 458     expect(TRUE, ret);
 459     ok(tvi.state == (INDEXTOSTATEIMAGEMASK(1) | TVIS_FOCUSED), "got 0x%x\n", tvi.state);
 460
 461     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_get_dispinfo_seq,
 462                 "callback for state/overlay image index, noop seq", FALSE);
 463
 464     /* ask for image again and overwrite state to some value in handler */
 465     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 466
 467     g_disp_set_stateimage = TRUE;
 468     tvi.hItem = hRoot;
 469     tvi.mask = TVIF_IMAGE;
 470     tvi.state = INDEXTOSTATEIMAGEMASK(1);
 471     tvi.stateMask = 0;
 472     ret = TreeView_GetItem(hTree, &tvi);
 473     expect(TRUE, ret);
 474     /* handler sets TVIS_SELECTED as well */
 475     ok(tvi.state == (TVIS_FOCUSED | TVIS_SELECTED | INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(3)), "got 0x%x\n", tvi.state);
 476     g_disp_set_stateimage = FALSE;
 477
 478     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_get_dispinfo_seq,
 479                 "callback for state/overlay image index seq", FALSE);
 480
 481     DestroyWindow(hTree);
 482 }
 483
 484 static void test_select(void)
 485 {
 486     BOOL r;
 487     HWND hTree;
 488
 489     hTree = create_treeview_control(0);
 490     fill_tree(hTree);
 491
 492     /* root-none select tests */
 493     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 494     r = TreeView_SelectItem(hTree, NULL);
 495     expect(TRUE, r);
 496     Clear();
 497     AddItem('1');
 498     r = TreeView_SelectItem(hTree, hRoot);
 499     expect(TRUE, r);
 500     AddItem('2');
 501     r = TreeView_SelectItem(hTree, hRoot);
 502     expect(TRUE, r);
 503     AddItem('3');
 504     r = TreeView_SelectItem(hTree, NULL);
 505     expect(TRUE, r);
 506     AddItem('4');
 507     r = TreeView_SelectItem(hTree, NULL);
 508     expect(TRUE, r);
 509     AddItem('5');
 510     r = TreeView_SelectItem(hTree, hRoot);
 511     expect(TRUE, r);
 512     AddItem('.');
 513     ok(!strcmp(sequence, "1(nR)nR23(Rn)Rn45(nR)nR."), "root-none select test\n");
 514     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, rootnone_select_seq,
 515                 "root-none select seq", FALSE);
 516
 517     /* root-child select tests */
 518     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 519     r = TreeView_SelectItem(hTree, NULL);
 520     expect(TRUE, r);
 521
 522     Clear();
 523     AddItem('1');
 524     r = TreeView_SelectItem(hTree, hRoot);
 525     expect(TRUE, r);
 526     AddItem('2');
 527     r = TreeView_SelectItem(hTree, hRoot);
 528     expect(TRUE, r);
 529     AddItem('3');
 530     r = TreeView_SelectItem(hTree, hChild);
 531     expect(TRUE, r);
 532     AddItem('4');
 533     r = TreeView_SelectItem(hTree, hChild);
 534     expect(TRUE, r);
 535     AddItem('5');
 536     r = TreeView_SelectItem(hTree, hRoot);
 537     expect(TRUE, r);
 538     AddItem('.');
 539     ok(!strcmp(sequence, "1(nR)nR23(RC)RC45(CR)CR."), "root-child select test\n");
 540     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, rootchild_select_seq,
 541                 "root-child select seq", FALSE);
 542
 543     DestroyWindow(hTree);
 544 }
 545
 546 static void test_getitemtext(void)
 547 {
 548     TVINSERTSTRUCTA ins;
 549     HTREEITEM hChild;
 550     TVITEMA tvi;
 551     HWND hTree;
 552
 553     CHAR szBuffer[80] = "Blah";
 554     int nBufferSize = sizeof(szBuffer)/sizeof(CHAR);
 555
 556     hTree = create_treeview_control(0);
 557     fill_tree(hTree);
 558
 559     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 560
 561     /* add an item without TVIF_TEXT mask and pszText == NULL */
 562     ins.hParent = hRoot;
 563     ins.hInsertAfter = TVI_ROOT;
 564     U(ins).item.mask = 0;
 565     U(ins).item.pszText = NULL;
 566     U(ins).item.cchTextMax = 0;
 567     hChild = TreeView_InsertItem(hTree, &ins);
 568     assert(hChild);
 569
 570     /* retrieve it with TVIF_TEXT mask */
 571     tvi.hItem = hChild;
 572     tvi.mask = TVIF_TEXT;
 573     tvi.cchTextMax = nBufferSize;
 574     tvi.pszText = szBuffer;
 575
 576     SendMessageA( hTree, TVM_GETITEMA, 0, (LPARAM)&tvi );
 577     ok(!strcmp(szBuffer, ""), "szBuffer=\"%s\", expected \"\"\n", szBuffer);
 578     ok(SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hChild), "DeleteItem failed\n");
 579     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, getitemtext_seq, "get item text seq", FALSE);
 580
 581     DestroyWindow(hTree);
 582 }
 583
 584 static void test_focus(void)
 585 {
 586     TVINSERTSTRUCTA ins;
 587     static CHAR child1[]  = "Edit",
 588                 child2[]  = "A really long string";
 589     HTREEITEM hChild1, hChild2;
 590     HWND hTree;
 591     HWND hEdit;
 592
 593     hTree = create_treeview_control(0);
 594     fill_tree(hTree);
 595
 596     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 597
 598     /* This test verifies that when a label is being edited, scrolling
 599      * the treeview does not cause the label to lose focus. To test
 600      * this, first some additional entries are added to generate
 601      * scrollbars.
 602      */
 603     ins.hParent = hRoot;
 604     ins.hInsertAfter = hChild;
 605     U(ins).item.mask = TVIF_TEXT;
 606     U(ins).item.pszText = child1;
 607     hChild1 = TreeView_InsertItem(hTree, &ins);
 608     assert(hChild1);
 609     ins.hInsertAfter = hChild1;
 610     U(ins).item.mask = TVIF_TEXT;
 611     U(ins).item.pszText = child2;
 612     hChild2 = TreeView_InsertItem(hTree, &ins);
 613     assert(hChild2);
 614
 615     ShowWindow(hMainWnd,SW_SHOW);
 616     SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hChild);
 617     hEdit = TreeView_EditLabel(hTree, hChild);
 618     ScrollWindowEx(hTree, -10, 0, NULL, NULL, NULL, NULL, SW_SCROLLCHILDREN);
 619     ok(GetFocus() == hEdit, "Edit control should have focus\n");
 620     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, focus_seq, "focus test", TRUE);
 621
 622     DestroyWindow(hTree);
 623 }
 624
 625 static void test_get_set_bkcolor(void)
 626 {
 627     COLORREF crColor = RGB(0,0,0);
 628     HWND hTree;
 629
 630     hTree = create_treeview_control(0);
 631     fill_tree(hTree);
 632
 633     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 634
 635     /* If the value is -1, the control is using the system color for the background color. */
 636     crColor = (COLORREF)SendMessage( hTree, TVM_GETBKCOLOR, 0, 0 );
 637     ok(crColor == ~0u, "Default background color reported as 0x%.8x\n", crColor);
 638
 639     /* Test for black background */
 640     SendMessage( hTree, TVM_SETBKCOLOR, 0, RGB(0,0,0) );
 641     crColor = (COLORREF)SendMessage( hTree, TVM_GETBKCOLOR, 0, 0 );
 642     ok(crColor == RGB(0,0,0), "Black background color reported as 0x%.8x\n", crColor);
 643
 644     /* Test for white background */
 645     SendMessage( hTree, TVM_SETBKCOLOR, 0, RGB(255,255,255) );
 646     crColor = (COLORREF)SendMessage( hTree, TVM_GETBKCOLOR, 0, 0 );
 647     ok(crColor == RGB(255,255,255), "White background color reported as 0x%.8x\n", crColor);
 648
 649     /* Reset the default background */
 650     SendMessage( hTree, TVM_SETBKCOLOR, 0, -1 );
 651
 652     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_bkcolor_seq,
 653         "test get set bkcolor", FALSE);
 654
 655     DestroyWindow(hTree);
 656 }
 657
 658 static void test_get_set_imagelist(void)
 659 {
 660     HIMAGELIST hImageList = NULL;
 661     HWND hTree;
 662
 663     hTree = create_treeview_control(0);
 664     fill_tree(hTree);
 665
 666     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 667
 668     /* Test a NULL HIMAGELIST */
 669     SendMessage( hTree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)hImageList );
 670     hImageList = (HIMAGELIST)SendMessage( hTree, TVM_GETIMAGELIST, TVSIL_NORMAL, 0 );
 671     ok(hImageList == NULL, "NULL image list, reported as 0x%p, expected 0.\n", hImageList);
 672
 673     /* TODO: Test an actual image list */
 674
 675     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_imagelist_seq,
 676         "test get imagelist", FALSE);
 677
 678     DestroyWindow(hTree);
 679 }
 680
 681 static void test_get_set_indent(void)
 682 {
 683     int ulIndent = -1;
 684     int ulMinIndent = -1;
 685     int ulMoreThanTwiceMin = -1;
 686     HWND hTree;
 687
 688     hTree = create_treeview_control(0);
 689     fill_tree(hTree);
 690
 691     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 692
 693     /* Finding the minimum indent */
 694     SendMessage( hTree, TVM_SETINDENT, 0, 0 );
 695     ulMinIndent = (int)SendMessage( hTree, TVM_GETINDENT, 0, 0 );
 696
 697     /* Checking an indent that is more than twice the default indent */
 698     ulMoreThanTwiceMin = 2*ulMinIndent+1;
 699     SendMessage( hTree, TVM_SETINDENT, ulMoreThanTwiceMin, 0 );
 700     ulIndent = (DWORD)SendMessage( hTree, TVM_GETINDENT, 0, 0 );
 701     ok(ulIndent == ulMoreThanTwiceMin, "Indent reported as %d, expected %d\n", ulIndent, ulMoreThanTwiceMin);
 702
 703     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_indent_seq,
 704         "test get set indent", FALSE);
 705
 706     DestroyWindow(hTree);
 707 }
 708
 709 static void test_get_set_insertmark(void)
 710 {
 711     COLORREF crColor = RGB(0,0,0);
 712     HWND hTree;
 713
 714     hTree = create_treeview_control(0);
 715     fill_tree(hTree);
 716
 717     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 718
 719     SendMessage( hTree, TVM_SETINSERTMARKCOLOR, 0, crColor );
 720     crColor = (COLORREF)SendMessage( hTree, TVM_GETINSERTMARKCOLOR, 0, 0 );
 721     ok(crColor == RGB(0,0,0), "Insert mark color reported as 0x%.8x, expected 0x00000000\n", crColor);
 722
 723     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_insertmarkcolor_seq,
 724         "test get set insertmark color", FALSE);
 725
 726     DestroyWindow(hTree);
 727 }
 728
 729 static void test_get_set_item(void)
 730 {
 731     TVITEMA tviRoot = {0};
 732     int nBufferSize = 80;
 733     char szBuffer[80] = {0};
 734     DWORD ret;
 735     HWND hTree;
 736
 737     hTree = create_treeview_control(0);
 738     fill_tree(hTree);
 739
 740     tviRoot.hItem = hRoot;
 741     tviRoot.mask  = TVIF_STATE;
 742     tviRoot.state = TVIS_FOCUSED;
 743     tviRoot.stateMask = TVIS_FOCUSED;
 744     ret = SendMessage( hTree, TVM_SETITEMA, 0, (LPARAM)&tviRoot );
 745     expect(TRUE, ret);
 746
 747     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 748
 749     /* Test the root item, state is set even when not requested */
 750     tviRoot.hItem = hRoot;
 751     tviRoot.mask = TVIF_TEXT;
 752     tviRoot.state = 0;
 753     tviRoot.stateMask = 0;
 754     tviRoot.cchTextMax = nBufferSize;
 755     tviRoot.pszText = szBuffer;
 756     ret = SendMessage( hTree, TVM_GETITEMA, 0, (LPARAM)&tviRoot );
 757     expect(TRUE, ret);
 758     ok(!strcmp("Root", szBuffer), "GetItem: szBuffer=\"%s\", expected \"Root\"\n", szBuffer);
 759     ok(tviRoot.state == TVIS_FOCUSED, "got 0x%0x\n", tviRoot.state);
 760
 761     /* Change the root text */
 762     strncpy(szBuffer, "Testing123", nBufferSize);
 763     ret = SendMessage( hTree, TVM_SETITEMA, 0, (LPARAM)&tviRoot );
 764     expect(TRUE, ret);
 765     memset(szBuffer, 0, nBufferSize);
 766     ret = SendMessage( hTree, TVM_GETITEMA, 0, (LPARAM)&tviRoot );
 767     expect(TRUE, ret);
 768     ok(!strcmp("Testing123", szBuffer), "GetItem: szBuffer=\"%s\", expected \"Testing123\"\n", szBuffer);
 769
 770     /* Reset the root text */
 771     memset(szBuffer, 0, nBufferSize);
 772     strncpy(szBuffer, "Root", nBufferSize);
 773     ret = SendMessage( hTree, TVM_SETITEMA, 0, (LPARAM)&tviRoot );
 774     expect(TRUE, ret);
 775
 776     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_item_seq,
 777         "test get set item", FALSE);
 778
 779     DestroyWindow(hTree);
 780 }
 781
 782 static void test_get_set_itemheight(void)
 783 {
 784     int ulOldHeight = 0;
 785     int ulNewHeight = 0;
 786     HWND hTree;
 787
 788     hTree = create_treeview_control(0);
 789     fill_tree(hTree);
 790
 791     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 792
 793     /* Assuming default height to begin with */
 794     ulOldHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 795
 796     /* Explicitly setting and getting the default height */
 797     SendMessage( hTree, TVM_SETITEMHEIGHT, -1, 0 );
 798     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 799     ok(ulNewHeight == ulOldHeight, "Default height not set properly, reported %d, expected %d\n", ulNewHeight, ulOldHeight);
 800
 801     /* Explicitly setting and getting the height of twice the normal */
 802     SendMessage( hTree, TVM_SETITEMHEIGHT, 2*ulOldHeight, 0 );
 803     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 804     ok(ulNewHeight == 2*ulOldHeight, "New height not set properly, reported %d, expected %d\n", ulNewHeight, 2*ulOldHeight);
 805
 806     /* Assuming tree doesn't have TVS_NONEVENHEIGHT set, so a set of 9 will round down to 8 */
 807     SendMessage( hTree, TVM_SETITEMHEIGHT, 9, 0 );
 808     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 809     ok(ulNewHeight == 8, "Uneven height not set properly, reported %d, expected %d\n", ulNewHeight, 8);
 810
 811     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_itemheight_seq,
 812         "test get set item height", FALSE);
 813
 814     /* without TVS_NONEVENHEIGHT */
 815     SetWindowLong(hTree, GWL_STYLE, GetWindowLong(hTree, GWL_STYLE) & ~TVS_NONEVENHEIGHT);
 816     /* odd value */
 817     ulOldHeight = SendMessage( hTree, TVM_SETITEMHEIGHT, 3, 0);
 818     ok(ulOldHeight == 8, "got %d, expected %d\n", ulOldHeight, 8);
 819     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 820     ok(ulNewHeight == 2, "got %d, expected %d\n", ulNewHeight, 2);
 821
 822     ulOldHeight = SendMessage( hTree, TVM_SETITEMHEIGHT, 4, 0);
 823     ok(ulOldHeight == 2, "got %d, expected %d\n", ulOldHeight, 2);
 824     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 825     ok(ulNewHeight == 4, "got %d, expected %d\n", ulNewHeight, 4);
 826
 827     /* with TVS_NONEVENHEIGHT */
 828     SetWindowLong(hTree, GWL_STYLE, GetWindowLong(hTree, GWL_STYLE) | TVS_NONEVENHEIGHT);
 829     /* odd value */
 830     ulOldHeight = SendMessage( hTree, TVM_SETITEMHEIGHT, 3, 0);
 831     ok(ulOldHeight == 4, "got %d, expected %d\n", ulOldHeight, 4);
 832     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 833     ok(ulNewHeight == 3, "got %d, expected %d\n", ulNewHeight, 3);
 834     /* even value */
 835     ulOldHeight = SendMessage( hTree, TVM_SETITEMHEIGHT, 10, 0);
 836     ok(ulOldHeight == 3, "got %d, expected %d\n", ulOldHeight, 3);
 837     ulNewHeight = (int) SendMessage( hTree, TVM_GETITEMHEIGHT, 0, 0 );
 838     ok(ulNewHeight == 10, "got %d, expected %d\n", ulNewHeight, 10);
 839
 840     DestroyWindow(hTree);
 841 }
 842
 843 static void test_get_set_scrolltime(void)
 844 {
 845     int ulExpectedTime = 20;
 846     int ulTime = 0;
 847     HWND hTree;
 848
 849     hTree = create_treeview_control(0);
 850     fill_tree(hTree);
 851
 852     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 853
 854     SendMessage( hTree, TVM_SETSCROLLTIME, ulExpectedTime, 0 );
 855     ulTime = (int)SendMessage( hTree, TVM_GETSCROLLTIME, 0, 0 );
 856     ok(ulTime == ulExpectedTime, "Scroll time reported as %d, expected %d\n", ulTime, ulExpectedTime);
 857
 858     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_scrolltime_seq,
 859         "test get set scroll time", FALSE);
 860
 861     DestroyWindow(hTree);
 862 }
 863
 864 static void test_get_set_textcolor(void)
 865 {
 866     /* If the value is -1, the control is using the system color for the text color. */
 867     COLORREF crColor = RGB(0,0,0);
 868     HWND hTree;
 869
 870     hTree = create_treeview_control(0);
 871     fill_tree(hTree);
 872
 873     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 874
 875     crColor = (COLORREF)SendMessage( hTree, TVM_GETTEXTCOLOR, 0, 0 );
 876     ok(crColor == ~0u, "Default text color reported as 0x%.8x\n", crColor);
 877
 878     /* Test for black text */
 879     SendMessage( hTree, TVM_SETTEXTCOLOR, 0, RGB(0,0,0) );
 880     crColor = (COLORREF)SendMessage( hTree, TVM_GETTEXTCOLOR, 0, 0 );
 881     ok(crColor == RGB(0,0,0), "Black text color reported as 0x%.8x\n", crColor);
 882
 883     /* Test for white text */
 884     SendMessage( hTree, TVM_SETTEXTCOLOR, 0, RGB(255,255,255) );
 885     crColor = (COLORREF)SendMessage( hTree, TVM_GETTEXTCOLOR, 0, 0 );
 886     ok(crColor == RGB(255,255,255), "White text color reported as 0x%.8x\n", crColor);
 887
 888     /* Reset the default text color */
 889     SendMessage( hTree, TVM_SETTEXTCOLOR, 0, CLR_NONE );
 890
 891     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_textcolor_seq,
 892         "test get set text color", FALSE);
 893
 894     DestroyWindow(hTree);
 895 }
 896
 897 static void test_get_set_tooltips(void)
 898 {
 899     HWND hwndLastToolTip = NULL;
 900     HWND hPopupTreeView;
 901     HWND hTree;
 902
 903     hTree = create_treeview_control(0);
 904     fill_tree(hTree);
 905
 906     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 907
 908     /* show even WS_POPUP treeview don't send NM_TOOLTIPSCREATED */
 909     hPopupTreeView = CreateWindow(WC_TREEVIEW, NULL, WS_POPUP|WS_VISIBLE, 0, 0, 100, 100, hMainWnd, NULL, NULL, NULL);
 910     DestroyWindow(hPopupTreeView);
 911
 912     /* Testing setting a NULL ToolTip */
 913     SendMessage( hTree, TVM_SETTOOLTIPS, 0, 0 );
 914     hwndLastToolTip = (HWND)SendMessage( hTree, TVM_GETTOOLTIPS, 0, 0 );
 915     ok(hwndLastToolTip == NULL, "NULL tool tip, reported as 0x%p, expected 0.\n", hwndLastToolTip);
 916
 917     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_tooltips_seq,
 918         "test get set tooltips", TRUE);
 919
 920     /* TODO: Add a test of an actual tooltip */
 921     DestroyWindow(hTree);
 922 }
 923
 924 static void test_get_set_unicodeformat(void)
 925 {
 926     BOOL bPreviousSetting = 0;
 927     BOOL bNewSetting = 0;
 928     HWND hTree;
 929
 930     hTree = create_treeview_control(0);
 931     fill_tree(hTree);
 932
 933     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 934
 935     /* Set to Unicode */
 936     bPreviousSetting = (BOOL)SendMessage( hTree, TVM_SETUNICODEFORMAT, 1, 0 );
 937     bNewSetting = (BOOL)SendMessage( hTree, TVM_GETUNICODEFORMAT, 0, 0 );
 938     ok(bNewSetting == 1, "Unicode setting did not work.\n");
 939
 940     /* Set to ANSI */
 941     SendMessage( hTree, TVM_SETUNICODEFORMAT, 0, 0 );
 942     bNewSetting = (BOOL)SendMessage( hTree, TVM_GETUNICODEFORMAT, 0, 0 );
 943     ok(bNewSetting == 0, "ANSI setting did not work.\n");
 944
 945     /* Revert to original setting */
 946     SendMessage( hTree, TVM_SETUNICODEFORMAT, bPreviousSetting, 0 );
 947
 948     ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_unicodeformat_seq,
 949         "test get set unicode format", FALSE);
 950
 951     DestroyWindow(hTree);
 952 }
 953
 954 static LRESULT CALLBACK parent_wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 955 {
 956     static LONG defwndproc_counter = 0;
 957     struct message msg;
 958     LRESULT ret;
 959     RECT rect;
 960     HTREEITEM visibleItem;
 961
 962     msg.message = message;
 963     msg.flags = sent|wparam|lparam;
 964     if (defwndproc_counter) msg.flags |= defwinproc;
 965     msg.wParam = wParam;
 966     msg.lParam = lParam;
 967     if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;
 968
 969     /* log system messages, except for painting */
 970     if (message < WM_USER &&
 971         message != WM_PAINT &&
 972         message != WM_ERASEBKGND &&
 973         message != WM_NCPAINT &&
 974         message != WM_NCHITTEST &&
 975         message != WM_GETTEXT &&
 976         message != WM_GETICON &&
 977         message != WM_DEVICECHANGE)
 978     {
 979         trace("parent: %p, %04x, %08lx, %08lx\n", hWnd, message, wParam, lParam);
 980         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 981     }
 982
 983     switch(message) {
 984     case WM_NOTIFY:
 985     {
 986         NMHDR *pHdr = (NMHDR *)lParam;
 987
 988         ok(pHdr->code != NM_TOOLTIPSCREATED, "Treeview should not send NM_TOOLTIPSCREATED\n");
 989         if (pHdr->idFrom == 100)
 990         {
 991             NMTREEVIEWA *pTreeView = (LPNMTREEVIEWA) lParam;
 992             switch(pHdr->code)
 993             {
 994             case TVN_SELCHANGINGA:
 995                 AddItem('(');
 996                 IdentifyItem(pTreeView->itemOld.hItem);
 997                 IdentifyItem(pTreeView->itemNew.hItem);
 998                 break;
 999             case TVN_SELCHANGEDA:
1000                 AddItem(')');
1001                 IdentifyItem(pTreeView->itemOld.hItem);
1002                 IdentifyItem(pTreeView->itemNew.hItem);
1003                 break;
1004             case TVN_GETDISPINFOA: {
1005                 NMTVDISPINFOA *disp = (NMTVDISPINFOA *)lParam;
1006                 if (disp->item.mask & TVIF_TEXT) {
1007                     lstrcpyn(disp->item.pszText, TEST_CALLBACK_TEXT, disp->item.cchTextMax);
1008                 }
1009
1010                 if (g_disp_A_to_W && (disp->item.mask & TVIF_TEXT)) {
1011                     static const WCHAR testW[] = {'T','E','S','T','2',0};
1012
1013                     disp->hdr.code = TVN_GETDISPINFOW;
1014                     memcpy(disp->item.pszText, testW, sizeof(testW));
1015                 }
1016
1017                 if (g_disp_set_stateimage)
1018                 {
1019                     ok(disp->item.mask == TVIF_IMAGE, "got %x\n", disp->item.mask);
1020                     /* both masks set here are necessary to change state bits */
1021                     disp->item.mask |= TVIF_STATE;
1022                     disp->item.state = TVIS_SELECTED | INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(3);
1023                     disp->item.stateMask = TVIS_SELECTED | TVIS_OVERLAYMASK | TVIS_STATEIMAGEMASK;
1024                 }
1025
1026                 break;
1027               }
1028             case TVN_ENDLABELEDIT: return TRUE;
1029             case TVN_ITEMEXPANDINGA:
1030                 ok(pTreeView->itemNew.mask ==
1031                    (TVIF_HANDLE | TVIF_SELECTEDIMAGE | TVIF_IMAGE | TVIF_PARAM | TVIF_STATE),
1032                    "got wrong mask %x\n", pTreeView->itemNew.mask);
1033                 ok((pTreeView->itemNew.state & TVIS_EXPANDED) == 0,
1034                    "got wrong state %x\n", pTreeView->itemNew.state);
1035                 ok(pTreeView->itemOld.mask == 0,
1036                    "got wrong mask %x\n", pTreeView->itemOld.mask);
1037
1038                 if (g_get_from_expand)
1039                 {
1040                   g_item_expanding.mask = TVIF_STATE;
1041                   g_item_expanding.hItem = hRoot;
1042                   ret = SendMessageA(pHdr->hwndFrom, TVM_GETITEMA, 0, (LPARAM)&g_item_expanding);
1043                   ok(ret == TRUE, "got %lu\n", ret);
1044                 }
1045                 break;
1046             case TVN_ITEMEXPANDEDA:
1047                 ok(pTreeView->itemNew.mask & TVIF_STATE, "got wrong mask %x\n", pTreeView->itemNew.mask);
1048                 ok(pTreeView->itemNew.state & (TVIS_EXPANDED|TVIS_EXPANDEDONCE),
1049                    "got wrong mask %x\n", pTreeView->itemNew.mask);
1050                 ok(pTreeView->itemOld.mask == 0,
1051                    "got wrong mask %x\n", pTreeView->itemOld.mask);
1052
1053                 if (g_get_from_expand)
1054                 {
1055                   g_item_expanded.mask = TVIF_STATE;
1056                   g_item_expanded.hItem = hRoot;
1057                   ret = SendMessageA(pHdr->hwndFrom, TVM_GETITEMA, 0, (LPARAM)&g_item_expanded);
1058                   ok(ret == TRUE, "got %lu\n", ret);
1059                 }
1060                 if (g_get_rect_in_expand)
1061                 {
1062                   visibleItem = TreeView_GetNextItem(pHdr->hwndFrom, NULL, TVGN_FIRSTVISIBLE);
1063                   ok(pTreeView->itemNew.hItem == visibleItem, "expanded item == first visible item\n");
1064                   *(HTREEITEM*)&rect = visibleItem;
1065                   ok(SendMessage(pHdr->hwndFrom, TVM_GETITEMRECT, TRUE, (LPARAM)&rect), "Failed to get rect for first visible item.\n");
1066                   visibleItem = TreeView_GetNextItem(pHdr->hwndFrom, visibleItem, TVGN_NEXTVISIBLE);
1067                   *(HTREEITEM*)&rect = visibleItem;
1068                   ok(visibleItem != NULL, "There must be a visible item after the first visisble item.\n");
1069                   ok(SendMessage(pHdr->hwndFrom, TVM_GETITEMRECT, TRUE, (LPARAM)&rect), "Failed to get rect for second visible item.\n");
1070                 }
1071                 break;
1072             case TVN_DELETEITEMA:
1073             {
1074                 struct message item;
1075
1076                 ok(pTreeView->itemNew.mask == 0, "got wrong mask 0x%x\n", pTreeView->itemNew.mask);
1077
1078                 ok(pTreeView->itemOld.mask == (TVIF_HANDLE | TVIF_PARAM), "got wrong mask 0x%x\n", pTreeView->itemOld.mask);
1079                 ok(pTreeView->itemOld.hItem != NULL, "got %p\n", pTreeView->itemOld.hItem);
1080
1081                 memset(&item, 0, sizeof(item));
1082                 item.lParam = (LPARAM)pTreeView->itemOld.hItem;
1083                 add_message(item_sequence, 0, &item);
1084
1085                 break;
1086             }
1087             }
1088         }
1089         break;
1090     }
1091
1092     case WM_DESTROY:
1093         PostQuitMessage(0);
1094         break;
1095     }
1096
1097     defwndproc_counter++;
1098     ret = DefWindowProcA(hWnd, message, wParam, lParam);
1099     defwndproc_counter--;
1100
1101     return ret;
1102 }
1103
1104 static void test_expandinvisible(void)
1105 {
1106     static CHAR nodeText[][5] = {"0", "1", "2", "3", "4"};
1107     TVINSERTSTRUCTA ins;
1108     HTREEITEM node[5];
1109     RECT dummyRect;
1110     BOOL nodeVisible;
1111     LRESULT ret;
1112     HWND hTree;
1113
1114     hTree = create_treeview_control(0);
1115
1116     /* The test builds the following tree and expands then node 1, while node 0 is collapsed.
1117      *
1118      * 0
1119      * |- 1
1120      * |  |- 2
1121      * |  |- 3
1122      * |- 4
1123      *
1124      */
1125
1126     ret = TreeView_DeleteAllItems(hTree);
1127     ok(ret == TRUE, "ret\n");
1128     ins.hParent = TVI_ROOT;
1129     ins.hInsertAfter = TVI_ROOT;
1130     U(ins).item.mask = TVIF_TEXT;
1131     U(ins).item.pszText = nodeText[0];
1132     node[0] = TreeView_InsertItem(hTree, &ins);
1133     assert(node[0]);
1134
1135     ins.hInsertAfter = TVI_LAST;
1136     U(ins).item.mask = TVIF_TEXT;
1137     ins.hParent = node[0];
1138
1139     U(ins).item.pszText = nodeText[1];
1140     node[1] = TreeView_InsertItem(hTree, &ins);
1141     assert(node[1]);
1142     U(ins).item.pszText = nodeText[4];
1143     node[4] = TreeView_InsertItem(hTree, &ins);
1144     assert(node[4]);
1145
1146     ins.hParent = node[1];
1147
1148     U(ins).item.pszText = nodeText[2];
1149     node[2] = TreeView_InsertItem(hTree, &ins);
1150     assert(node[2]);
1151     U(ins).item.pszText = nodeText[3];
1152     node[3] = TreeView_InsertItem(hTree, &ins);
1153     assert(node[3]);
1154
1155
1156     nodeVisible = TreeView_GetItemRect(hTree, node[1], &dummyRect, FALSE);
1157     ok(!nodeVisible, "Node 1 should not be visible.\n");
1158     nodeVisible = TreeView_GetItemRect(hTree, node[2], &dummyRect, FALSE);
1159     ok(!nodeVisible, "Node 2 should not be visible.\n");
1160     nodeVisible = TreeView_GetItemRect(hTree, node[3], &dummyRect, FALSE);
1161     ok(!nodeVisible, "Node 3 should not be visible.\n");
1162     nodeVisible = TreeView_GetItemRect(hTree, node[4], &dummyRect, FALSE);
1163     ok(!nodeVisible, "Node 4 should not be visible.\n");
1164
1165     ok(TreeView_Expand(hTree, node[1], TVE_EXPAND), "Expand of node 1 failed.\n");
1166
1167     nodeVisible = TreeView_GetItemRect(hTree, node[1], &dummyRect, FALSE);
1168     ok(!nodeVisible, "Node 1 should not be visible.\n");
1169     nodeVisible = TreeView_GetItemRect(hTree, node[2], &dummyRect, FALSE);
1170     ok(!nodeVisible, "Node 2 should not be visible.\n");
1171     nodeVisible = TreeView_GetItemRect(hTree, node[3], &dummyRect, FALSE);
1172     ok(!nodeVisible, "Node 3 should not be visible.\n");
1173     nodeVisible = TreeView_GetItemRect(hTree, node[4], &dummyRect, FALSE);
1174     ok(!nodeVisible, "Node 4 should not be visible.\n");
1175
1176     DestroyWindow(hTree);
1177 }
1178
1179 static void test_itemedit(void)
1180 {
1181     DWORD r;
1182     HWND edit;
1183     TVITEMA item;
1184     CHAR buff[2];
1185     HWND hTree;
1186
1187     hTree = create_treeview_control(0);
1188     fill_tree(hTree);
1189
1190     /* try with null item */
1191     edit = (HWND)SendMessage(hTree, TVM_EDITLABEL, 0, 0);
1192     ok(!IsWindow(edit), "Expected valid handle\n");
1193
1194     /* trigger edit */
1195     edit = (HWND)SendMessage(hTree, TVM_EDITLABEL, 0, (LPARAM)hRoot);
1196     ok(IsWindow(edit), "Expected valid handle\n");
1197     /* item shouldn't be selected automatically after TVM_EDITLABEL */
1198     r = SendMessage(hTree, TVM_GETITEMSTATE, (WPARAM)hRoot, TVIS_SELECTED);
1199     expect(0, r);
1200     /* try to cancel with wrong edit handle */
1201     r = SendMessage(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), 0);
1202     expect(0, r);
1203     ok(IsWindow(edit), "Expected edit control to be valid\n");
1204     r = SendMessage(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
1205     expect(0, r);
1206     ok(!IsWindow(edit), "Expected edit control to be destroyed\n");
1207     /* try to cancel without creating edit */
1208     r = SendMessage(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), 0);
1209     expect(0, r);
1210
1211     /* try to cancel with wrong (not null) handle */
1212     edit = (HWND)SendMessage(hTree, TVM_EDITLABEL, 0, (LPARAM)hRoot);
1213     ok(IsWindow(edit), "Expected valid handle\n");
1214     r = SendMessage(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hTree);
1215     expect(0, r);
1216     ok(IsWindow(edit), "Expected edit control to be valid\n");
1217     r = SendMessage(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
1218     expect(0, r);
1219
1220     /* remove selection after starting edit */
1221     r = TreeView_SelectItem(hTree, hRoot);
1222     expect(TRUE, r);
1223     edit = (HWND)SendMessage(hTree, TVM_EDITLABEL, 0, (LPARAM)hRoot);
1224     ok(IsWindow(edit), "Expected valid handle\n");
1225     r = TreeView_SelectItem(hTree, NULL);
1226     expect(TRUE, r);
1227     /* alter text */
1228     strcpy(buff, "x");
1229     r = SendMessage(edit, WM_SETTEXT, 0, (LPARAM)buff);
1230     expect(TRUE, r);
1231     r = SendMessage(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
1232     expect(0, r);
1233     ok(!IsWindow(edit), "Expected edit control to be destroyed\n");
1234     /* check that text is saved */
1235     item.mask = TVIF_TEXT;
1236     item.hItem = hRoot;
1237     item.pszText = buff;
1238     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
1239     r = SendMessage(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1240     expect(TRUE, r);
1241     ok(!strcmp("x", buff), "Expected item text to change\n");
1242
1243     DestroyWindow(hTree);
1244 }
1245
1246 static void test_treeview_classinfo(void)
1247 {
1248     WNDCLASSA cls;
1249
1250     memset(&cls, 0, sizeof(cls));
1251     GetClassInfo(GetModuleHandleA("comctl32.dll"), WC_TREEVIEWA, &cls);
1252     ok(cls.hbrBackground == NULL, "Expected NULL background brush, got %p\n", cls.hbrBackground);
1253     ok(cls.style == (CS_GLOBALCLASS | CS_DBLCLKS), "Expected got %x\n", cls.style);
1254     expect(0, cls.cbClsExtra);
1255 }
1256
1257 static void test_get_linecolor(void)
1258 {
1259     COLORREF clr;
1260     HWND hTree;
1261
1262     hTree = create_treeview_control(0);
1263
1264     /* newly created control has default color */
1265     clr = (COLORREF)SendMessage(hTree, TVM_GETLINECOLOR, 0, 0);
1266     if (clr == 0)
1267         win_skip("TVM_GETLINECOLOR is not supported on comctl32 < 5.80\n");
1268     else
1269         expect(CLR_DEFAULT, clr);
1270
1271     DestroyWindow(hTree);
1272 }
1273
1274 static void test_get_insertmarkcolor(void)
1275 {
1276     COLORREF clr;
1277     HWND hTree;
1278
1279     hTree = create_treeview_control(0);
1280
1281     /* newly created control has default color */
1282     clr = (COLORREF)SendMessage(hTree, TVM_GETINSERTMARKCOLOR, 0, 0);
1283     if (clr == 0)
1284         win_skip("TVM_GETINSERTMARKCOLOR is not supported on comctl32 < 5.80\n");
1285     else
1286         expect(CLR_DEFAULT, clr);
1287
1288     DestroyWindow(hTree);
1289 }
1290
1291 static void test_expandnotify(void)
1292 {
1293     HWND hTree;
1294     BOOL ret;
1295     TVITEMA item;
1296
1297     hTree = create_treeview_control(0);
1298     fill_tree(hTree);
1299
1300     item.hItem = hRoot;
1301     item.mask = TVIF_STATE;
1302
1303     item.state = TVIS_EXPANDED;
1304     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1305     expect(TRUE, ret);
1306     ok((item.state & TVIS_EXPANDED) == 0, "expected collapsed\n");
1307
1308     /* preselect root node here */
1309     ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hRoot);
1310     expect(TRUE, ret);
1311
1312     g_get_from_expand = TRUE;
1313     /* expand */
1314     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1315     g_item_expanding.state = 0xdeadbeef;
1316     g_item_expanded.state = 0xdeadbeef;
1317     ret = SendMessageA(hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)hRoot);
1318     expect(TRUE, ret);
1319     ok(g_item_expanding.state == TVIS_SELECTED, "got state on TVN_ITEMEXPANDING 0x%08x\n",
1320        g_item_expanding.state);
1321     ok(g_item_expanded.state == (TVIS_SELECTED|TVIS_EXPANDED), "got state on TVN_ITEMEXPANDED 0x%08x\n",
1322        g_item_expanded.state);
1323     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_seq, "expand notifications", FALSE);
1324     g_get_from_expand = FALSE;
1325
1326     /* check that it's expanded */
1327     item.state = TVIS_EXPANDED;
1328     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1329     expect(TRUE, ret);
1330     ok((item.state & TVIS_EXPANDED) == TVIS_EXPANDED, "expected expanded\n");
1331
1332     /* collapse */
1333     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1334     ret = SendMessageA(hTree, TVM_EXPAND, TVE_COLLAPSE, (LPARAM)hRoot);
1335     expect(TRUE, ret);
1336     item.state = TVIS_EXPANDED;
1337     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1338     expect(TRUE, ret);
1339     ok((item.state & TVIS_EXPANDED) == 0, "expected collapsed\n");
1340     /* all next collapse/expand attempts won't produce any notifications,
1341        the only way is to reset with all children removed */
1342     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "collapse after expand notifications", FALSE);
1343
1344     /* try to toggle child that doesn't have children itself */
1345     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1346     ret = SendMessageA(hTree, TVM_EXPAND, TVE_TOGGLE, (LPARAM)hChild);
1347     expect(FALSE, ret);
1348     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "toggle node without children", FALSE);
1349
1350     DestroyWindow(hTree);
1351
1352     /* test TVM_GETITEMRECT inside TVN_ITEMEXPANDED notification */
1353     hTree = create_treeview_control(0);
1354     fill_tree(hTree);
1355     g_get_rect_in_expand = TRUE;
1356     ret = TreeView_Select(hTree, hChild, TVGN_CARET);
1357     expect(TRUE, ret);
1358     g_get_rect_in_expand = FALSE;
1359
1360     DestroyWindow(hTree);
1361
1362     /* TVE_TOGGLE acts as any other TVM_EXPAND */
1363     hTree = create_treeview_control(0);
1364     fill_tree(hTree);
1365
1366     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1367     ret = SendMessageA(hTree, TVM_EXPAND, TVE_TOGGLE, (LPARAM)hRoot);
1368     expect(TRUE, ret);
1369     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_seq, "toggle node (expand)", FALSE);
1370
1371     /* toggle again - no notifications */
1372     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1373     ret = SendMessageA(hTree, TVM_EXPAND, TVE_TOGGLE, (LPARAM)hRoot);
1374     expect(TRUE, ret);
1375     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "toggle node (collapse)", FALSE);
1376
1377     DestroyWindow(hTree);
1378 }
1379
1380 static void test_expandedimage(void)
1381 {
1382     TVITEMEXA item;
1383     HWND hTree;
1384     BOOL ret;
1385
1386     hTree = create_treeview_control(0);
1387     fill_tree(hTree);
1388
1389     item.mask = TVIF_EXPANDEDIMAGE;
1390     item.iExpandedImage = 1;
1391     item.hItem = hRoot;
1392     ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&item);
1393     ok(ret, "got %d\n", ret);
1394
1395     item.mask = TVIF_EXPANDEDIMAGE;
1396     item.iExpandedImage = -1;
1397     item.hItem = hRoot;
1398     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1399     ok(ret, "got %d\n", ret);
1400
1401     if (item.iExpandedImage != 1)
1402     {
1403         win_skip("TVIF_EXPANDEDIMAGE not supported\n");
1404         DestroyWindow(hTree);
1405         return;
1406     }
1407
1408     /* test for default iExpandedImage value */
1409     item.mask = TVIF_EXPANDEDIMAGE;
1410     item.iExpandedImage = -1;
1411     item.hItem = hChild;
1412     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1413     ok(ret, "got %d\n", ret);
1414     ok(item.iExpandedImage == (WORD)I_IMAGENONE, "got %d\n", item.iExpandedImage);
1415
1416     DestroyWindow(hTree);
1417 }
1418
1419 static void test_TVS_SINGLEEXPAND(void)
1420 {
1421     HWND hTree;
1422     BOOL ret;
1423
1424     hTree = create_treeview_control(0);
1425     SetWindowLongA(hTree, GWL_STYLE, GetWindowLong(hTree, GWL_STYLE) | TVS_SINGLEEXPAND);
1426     /* to avoid paiting related notifications */
1427     ShowWindow(hTree, SW_HIDE);
1428     fill_tree(hTree);
1429
1430     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1431     ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hRoot);
1432     ok(ret, "got %d\n", ret);
1433     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_singleexpand_seq, "singleexpand notifications", FALSE);
1434
1435     /* a workaround for NT4 that sends expanding notification when nothing is about to expand */
1436     ret = SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hRoot);
1437     ok(ret, "got %d\n", ret);
1438     fill_tree(hTree);
1439     ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, 0);
1440     ok(ret, "got %d\n", ret);
1441
1442     DestroyWindow(hTree);
1443 }
1444
1445 static void test_WM_PAINT(void)
1446 {
1447     HWND hTree;
1448     COLORREF clr;
1449     LONG ret;
1450     RECT rc;
1451     HDC hdc;
1452
1453     hTree = create_treeview_control(0);
1454
1455     clr = SendMessageA(hTree, TVM_SETBKCOLOR, 0, RGB(255, 0, 0));
1456     ok(clr == ~0u, "got %d, expected -1\n", clr);
1457
1458     hdc = GetDC(hMainWnd);
1459
1460     GetClientRect(hMainWnd, &rc);
1461     FillRect(hdc, &rc, GetStockObject(BLACK_BRUSH));
1462
1463     clr = GetPixel(hdc, 1, 1);
1464     ok(clr == RGB(0, 0, 0), "got 0x%x\n", clr);
1465
1466     ret = SendMessageA(hTree, WM_PAINT, (WPARAM)hdc, 0);
1467     ok(ret == 0, "got %d\n", ret);
1468
1469     clr = GetPixel(hdc, 1, 1);
1470     ok(clr == RGB(255, 0, 0) || broken(clr == RGB(0, 0, 0)) /* win98 */,
1471         "got 0x%x\n", clr);
1472
1473     ReleaseDC(hMainWnd, hdc);
1474
1475     DestroyWindow(hTree);
1476 }
1477
1478 static void test_delete_items(void)
1479 {
1480     const struct message *msg;
1481     HWND hTree;
1482     INT ret;
1483
1484     hTree = create_treeview_control(0);
1485     fill_tree(hTree);
1486
1487     /* check delete order */
1488     flush_sequences(item_sequence, 1);
1489     ret = SendMessage(hTree, TVM_DELETEITEM, 0, 0);
1490     ok(ret == TRUE, "got %d\n", ret);
1491
1492     msg = item_sequence[0]->sequence;
1493     ok(item_sequence[0]->count == 2, "expected 2 items, got %d\n", item_sequence[0]->count);
1494
1495     if (item_sequence[0]->count == 2)
1496     {
1497       ok(msg[0].lParam == (LPARAM)hChild, "expected %p, got 0x%lx\n", hChild, msg[0].lParam);
1498       ok(msg[1].lParam == (LPARAM)hRoot, "expected %p, got 0x%lx\n", hRoot, msg[1].lParam);
1499     }
1500
1501     ret = SendMessageA(hTree, TVM_GETCOUNT, 0, 0);
1502     ok(ret == 0, "got %d\n", ret);
1503
1504     DestroyWindow(hTree);
1505 }
1506
1507 struct _ITEM_DATA
1508 {
1509     HTREEITEM  parent; /* for root value of parent field is unidetified */
1510     HTREEITEM  nextsibling;
1511     HTREEITEM  firstchild;
1512 };
1513
1514 static void _check_item(HTREEITEM item, HTREEITEM parent, HTREEITEM nextsibling, HTREEITEM firstchild, int line)
1515 {
1516     struct _ITEM_DATA *data = (struct _ITEM_DATA*)item;
1517
1518     ok_(__FILE__, line)(data->parent == parent, "parent %p, got %p\n", parent, data->parent);
1519     ok_(__FILE__, line)(data->nextsibling == nextsibling, "sibling %p, got %p\n", nextsibling, data->nextsibling);
1520     ok_(__FILE__, line)(data->firstchild == firstchild, "firstchild %p, got %p\n", firstchild, data->firstchild);
1521 }
1522
1523 #define check_item(a, b, c, d) _check_item(a, b, c, d, __LINE__)
1524
1525 static void test_htreeitem_layout(void)
1526 {
1527     TVINSERTSTRUCTA ins;
1528     HTREEITEM item1, item2;
1529     HWND hTree;
1530
1531     hTree = create_treeview_control(0);
1532     fill_tree(hTree);
1533
1534     /* root has some special pointer in parent field */
1535     check_item(hRoot, ((struct _ITEM_DATA*)hRoot)->parent, 0, hChild);
1536     check_item(hChild, hRoot, 0, 0);
1537
1538     ins.hParent = hChild;
1539     ins.hInsertAfter = TVI_FIRST;
1540     U(ins).item.mask = 0;
1541     item1 = TreeView_InsertItem(hTree, &ins);
1542
1543     check_item(item1, hChild, 0, 0);
1544
1545     ins.hParent = hRoot;
1546     ins.hInsertAfter = TVI_FIRST;
1547     U(ins).item.mask = 0;
1548     item2 = TreeView_InsertItem(hTree, &ins);
1549
1550     check_item(item2, hRoot, hChild, 0);
1551
1552     SendMessage(hTree, TVM_DELETEITEM, 0, (LPARAM)hChild);
1553
1554     /* without children now */
1555     check_item(hRoot, ((struct _ITEM_DATA*)hRoot)->parent, 0, item2);
1556
1557     DestroyWindow(hTree);
1558 }
1559
1560 static void test_TVS_CHECKBOXES(void)
1561 {
1562     TVITEMA item;
1563     HWND hTree;
1564     DWORD ret;
1565
1566     hTree = create_treeview_control(0);
1567     fill_tree(hTree);
1568
1569     item.hItem = hRoot;
1570     item.mask = TVIF_STATE;
1571     item.state = INDEXTOSTATEIMAGEMASK(1);
1572     item.stateMask = TVIS_STATEIMAGEMASK;
1573     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1574     expect(TRUE, ret);
1575     ok(item.state == 0, "got 0x%x\n", item.state);
1576
1577     /* set some index for a child */
1578     item.hItem = hChild;
1579     item.mask = TVIF_STATE;
1580     item.state = INDEXTOSTATEIMAGEMASK(4);
1581     item.stateMask = TVIS_STATEIMAGEMASK;
1582     ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&item);
1583     expect(TRUE, ret);
1584
1585     /* enabling check boxes set all items to 1 state image index */
1586     SetWindowLongA(hTree, GWL_STYLE, GetWindowLongA(hTree, GWL_STYLE) | TVS_CHECKBOXES);
1587
1588     item.hItem = hRoot;
1589     item.mask = TVIF_STATE;
1590     item.state = 0;
1591     item.stateMask = TVIS_STATEIMAGEMASK;
1592     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1593     expect(TRUE, ret);
1594     ok(item.state == INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item.state);
1595
1596     item.hItem = hChild;
1597     item.mask = TVIF_STATE;
1598     item.state = 0;
1599     item.stateMask = TVIS_STATEIMAGEMASK;
1600     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1601     expect(TRUE, ret);
1602     ok(item.state == INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item.state);
1603
1604     DestroyWindow(hTree);
1605
1606     /* the same, but initially created with TVS_CHECKBOXES */
1607     hTree = create_treeview_control(TVS_CHECKBOXES);
1608     fill_tree(hTree);
1609
1610     item.hItem = hRoot;
1611     item.mask = TVIF_STATE;
1612     item.state = 0;
1613     item.stateMask = TVIS_STATEIMAGEMASK;
1614     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1615     expect(TRUE, ret);
1616     ok(item.state == INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item.state);
1617
1618     item.hItem = hChild;
1619     item.mask = TVIF_STATE;
1620     item.state = 0;
1621     item.stateMask = TVIS_STATEIMAGEMASK;
1622     ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
1623     expect(TRUE, ret);
1624     ok(item.state == INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", item.state);
1625
1626     DestroyWindow(hTree);
1627 }
1628
1629 static void test_TVM_GETNEXTITEM(void)
1630 {
1631     HTREEITEM item;
1632     HWND hTree;
1633
1634     hTree = create_treeview_control(0);
1635     fill_tree(hTree);
1636
1637     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_ROOT, 0);
1638     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1639
1640     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_ROOT, (LPARAM)TVI_ROOT);
1641     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1642
1643     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_ROOT, (LPARAM)hRoot);
1644     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1645
1646     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_ROOT, (LPARAM)hChild);
1647     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1648
1649     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_CHILD, 0);
1650     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1651
1652     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hRoot);
1653     ok(item == hChild, "got %p, expected %p\n", item, hChild);
1654
1655     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)TVI_ROOT);
1656     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1657
1658     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_PARENT, 0);
1659     ok(item == NULL, "got %p\n", item);
1660
1661     item = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hChild);
1662     ok(item == hRoot, "got %p, expected %p\n", item, hRoot);
1663
1664     DestroyWindow(hTree);
1665 }
1666
1667 START_TEST(treeview)
1668 {
1669     HMODULE hComctl32;
1670     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
1671     WNDCLASSA wc;
1672     MSG msg;
1673
1674     ULONG_PTR ctx_cookie;
1675     HANDLE hCtx;
1676     HWND hwnd;
1677
1678     hComctl32 = GetModuleHandleA("comctl32.dll");
1679     pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
1680     if (pInitCommonControlsEx)
1681     {
1682         INITCOMMONCONTROLSEX iccex;
1683         iccex.dwSize = sizeof(iccex);
1684         iccex.dwICC  = ICC_TREEVIEW_CLASSES;
1685         pInitCommonControlsEx(&iccex);
1686     }
1687     else
1688         InitCommonControls();
1689
1690     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1691     init_msg_sequences(item_sequence, 1);
1692
1693     wc.style = CS_HREDRAW | CS_VREDRAW;
1694     wc.cbClsExtra = 0;
1695     wc.cbWndExtra = 0;
1696     wc.hInstance = GetModuleHandleA(NULL);
1697     wc.hIcon = NULL;
1698     wc.hCursor = LoadCursorA(NULL, IDC_IBEAM);
1699     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1700     wc.lpszMenuName = NULL;
1701     wc.lpszClassName = "MyTestWnd";
1702     wc.lpfnWndProc = parent_wnd_proc;
1703     RegisterClassA(&wc);
1704
1705     hMainWnd = CreateWindowExA(0, "MyTestWnd", "Blah", WS_OVERLAPPEDWINDOW,
1706       CW_USEDEFAULT, CW_USEDEFAULT, 130, 105, NULL, NULL, GetModuleHandleA(NULL), 0);
1707
1708     ok(hMainWnd != NULL, "Failed to create parent window. Tests aborted.\n");
1709     if (!hMainWnd) return;
1710
1711     test_fillroot();
1712     test_select();
1713     test_getitemtext();
1714     test_focus();
1715     test_get_set_bkcolor();
1716     test_get_set_imagelist();
1717     test_get_set_indent();
1718     test_get_set_insertmark();
1719     test_get_set_item();
1720     test_get_set_itemheight();
1721     test_get_set_scrolltime();
1722     test_get_set_textcolor();
1723     test_get_linecolor();
1724     test_get_insertmarkcolor();
1725     test_get_set_tooltips();
1726     test_get_set_unicodeformat();
1727     test_callback();
1728     test_expandinvisible();
1729     test_itemedit();
1730     test_treeview_classinfo();
1731     test_expandnotify();
1732     test_TVS_SINGLEEXPAND();
1733     test_WM_PAINT();
1734     test_delete_items();
1735     test_htreeitem_layout();
1736     test_TVS_CHECKBOXES();
1737     test_TVM_GETNEXTITEM();
1738
1739     if (!load_v6_module(&ctx_cookie, &hCtx))
1740     {
1741         DestroyWindow(hMainWnd);
1742         return;
1743     }
1744
1745     /* this is a XP SP3 failure workaround */
1746     hwnd = CreateWindowExA(0, WC_TREEVIEW, "foo",
1747                            WS_CHILD | WS_BORDER | WS_VISIBLE,
1748                            0, 0, 100, 100,
1749                            hMainWnd, NULL, GetModuleHandleA(NULL), NULL);
1750     if (!IsWindow(hwnd))
1751     {
1752         win_skip("FIXME: failed to create TreeView window.\n");
1753         unload_v6_module(ctx_cookie, hCtx);
1754         DestroyWindow(hMainWnd);
1755         return;
1756     }
1757     else
1758         DestroyWindow(hwnd);
1759
1760     /* comctl32 version 6 tests start here */
1761     test_expandedimage();
1762     test_htreeitem_layout();
1763
1764     unload_v6_module(ctx_cookie, hCtx);
1765
1766     PostMessageA(hMainWnd, WM_CLOSE, 0, 0);
1767     while(GetMessageA(&msg, 0, 0, 0))
1768     {
1769         TranslateMessage(&msg);
1770         DispatchMessageA(&msg);
1771     }
1772 }