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