treeview.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "winreg.h"
#include "wine/commctrl.h"
#include "wine/test.h"
#include "v6util.h"
#include "msg.h"

Include dependency graph for treeview.c:

Go to the source code of this file.

Classes
struct	_ITEM_DATA

Macros
#define	NUM_MSG_SEQUENCES   3
#define	TREEVIEW_SEQ_INDEX   0
#define	PARENT_SEQ_INDEX   1
#define	PARENT_CD_SEQ_INDEX   2
#define	expect(expected, got)   ok(got == expected, "Expected %d, got %d\n", expected, got)
#define	check_item(a, b, c, d)   _check_item(a, b, c, d, __LINE__)
#define	X(f)   p##f = (void*)GetProcAddress(hComCtl32, #f);

Functions
static	BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX *)
static void	flush_events (void)
static void	Clear (void)
static void	AddItem (char ch)
static void	IdentifyItem (HTREEITEM hItem)
static LRESULT WINAPI	TreeviewWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
static HWND	create_treeview_control (DWORD style)
static void	fill_tree (HWND hTree)
static void	test_fillroot (void)
static void	test_callback (void)
static void	test_select (void)
static void	test_getitemtext (void)
static void	test_focus (void)
static void	test_get_set_bkcolor (void)
static void	test_get_set_imagelist (void)
static void	test_get_set_indent (void)
static void	test_get_set_insertmark (void)
static void	test_get_set_item (void)
static void	test_get_set_itemheight (void)
static void	test_get_set_scrolltime (void)
static void	test_get_set_textcolor (void)
static void	test_get_set_tooltips (void)
static void	test_get_set_unicodeformat (void)
static LRESULT CALLBACK	parent_wnd_proc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
static void	test_expandinvisible (void)
static void	test_itemedit (void)
static void	test_treeview_classinfo (void)
static void	test_get_linecolor (void)
static void	test_get_insertmarkcolor (void)
static void	test_expandnotify (void)
static void	test_expandedimage (void)
static void	test_TVS_SINGLEEXPAND (void)
static void	test_WM_PAINT (void)
static void	test_delete_items (void)
static void	test_cchildren (void)
static void	_check_item (HTREEITEM item, HTREEITEM parent, HTREEITEM nextsibling, HTREEITEM firstchild, int line)
static void	test_htreeitem_layout (void)
static void	test_TVS_CHECKBOXES (void)
static void	test_TVM_GETNEXTITEM (void)
static void	test_TVM_HITTEST (void)
static void	test_WM_GETDLGCODE (void)
static void	test_customdraw (void)
static void	test_WM_KEYDOWN (void)
static void	test_TVS_FULLROWSELECT (void)
static void	get_item_names_string (HWND hwnd, HTREEITEM item, char *str)
static void	fill_treeview_sort_test (HWND hwnd)
static void	test_TVM_SORTCHILDREN (void)
static void	test_right_click (void)
static void	init_functions (void)
	START_TEST (treeview)

Variables
static const char *	TEST_CALLBACK_TEXT = "callback_text"
static TVITEMA	g_item_expanding
static TVITEMA	g_item_expanded
static BOOL	g_get_from_expand
static BOOL	g_get_rect_in_expand
static BOOL	g_disp_A_to_W
static BOOL	g_disp_set_stateimage
static BOOL	g_beginedit_alter_text
static HFONT	g_customdraw_font
static BOOL	g_v6
static struct msg_sequence *	sequences [NUM_MSG_SEQUENCES]
static struct msg_sequence *	item_sequence [1]
static const struct message	FillRootSeq []
static const struct message	rootnone_select_seq []
static const struct message	rootchild_select_seq []
static const struct message	getitemtext_seq []
static const struct message	focus_seq []
static const struct message	test_get_set_bkcolor_seq []
static const struct message	test_get_set_imagelist_seq []
static const struct message	test_get_set_indent_seq []
static const struct message	test_get_set_insertmarkcolor_seq []
static const struct message	test_get_set_item_seq []
static const struct message	test_get_set_itemheight_seq []
static const struct message	test_get_set_scrolltime_seq []
static const struct message	test_get_set_textcolor_seq []
static const struct message	test_get_set_tooltips_seq []
static const struct message	test_get_set_unicodeformat_seq []
static const struct message	test_right_click_seq []
static const struct message	parent_expand_seq []
static const struct message	parent_expand_kb_seq []
static const struct message	parent_collapse_2nd_kb_seq []
static const struct message	parent_expand_empty_kb_seq []
static const struct message	parent_singleexpand_seq0 []
static const struct message	parent_singleexpand_seq1 []
static const struct message	parent_singleexpand_seq2 []
static const struct message	parent_singleexpand_seq3 []
static const struct message	parent_singleexpand_seq4 []
static const struct message	parent_singleexpand_seq5 []
static const struct message	parent_singleexpand_seq6 []
static const struct message	parent_singleexpand_seq7 []
static const struct message	parent_get_dispinfo_seq []
static const struct message	empty_seq []
static const struct message	parent_cd_seq []
static const struct message	parent_vk_return_seq []
static const struct message	parent_right_click_seq []
static HWND	hMainWnd
static HTREEITEM	hRoot
static HTREEITEM	hChild
static int	pos = 0
static char	sequence [256]

Macro Definition Documentation

check_item

#define check_item	(		a,
			b,
			c,
			d
	)		_check_item(a, b, c, d, __LINE__)

Definition at line 2146 of file treeview.c.

expect

#define expect	(		expected,
			got
	)		ok(got == expected, "Expected %d, got %d\n", expected, got)

Definition at line 53 of file treeview.c.

NUM_MSG_SEQUENCES

#define NUM_MSG_SEQUENCES   3

Definition at line 48 of file treeview.c.

PARENT_CD_SEQ_INDEX

#define PARENT_CD_SEQ_INDEX   2

Definition at line 51 of file treeview.c.

PARENT_SEQ_INDEX

#define PARENT_SEQ_INDEX   1

Definition at line 50 of file treeview.c.

TREEVIEW_SEQ_INDEX

#define TREEVIEW_SEQ_INDEX   0

Definition at line 49 of file treeview.c.

X

#define X

(

f

)

p##f = (void*)GetProcAddress(hComCtl32, #f);

Function Documentation

_check_item()

static void _check_item ( HTREEITEM  item, HTREEITEM  parent, HTREEITEM  nextsibling, HTREEITEM  firstchild, int  line  )

static

Definition at line 2137 of file treeview.c.

{
    struct _ITEM_DATA *data = (struct _ITEM_DATA*)item;

    ok_(__FILE__, line)(data->parent == parent, "parent %p, got %p\n", parent, data->parent);
    ok_(__FILE__, line)(data->nextsibling == nextsibling, "sibling %p, got %p\n", nextsibling, data->nextsibling);
    ok_(__FILE__, line)(data->firstchild == firstchild, "firstchild %p, got %p\n", firstchild, data->firstchild);
}

AddItem()

static void AddItem ( char  ch )

static

Definition at line 392 of file treeview.c.

{
    sequence[pos++] = ch;
    sequence[pos] = '\0';
}

Referenced by IdentifyItem(), parent_wnd_proc(), test_fillroot(), and test_select().

BOOL()

static BOOL ( WINAPI *  pInitCommonControlsEx ) const

static

Clear()

static void Clear ( void  )

static

Definition at line 386 of file treeview.c.

{
    pos = 0;
    sequence[0] = '\0';
}

Referenced by test_fillroot(), and test_select().

create_treeview_control()

static HWND create_treeview_control ( DWORD  style )

static

Definition at line 437 of file treeview.c.

{
    WNDPROC pOldWndProc;
    HWND hTree;

    hTree = CreateWindowExA(WS_EX_CLIENTEDGE, WC_TREEVIEWA, NULL, WS_CHILD|WS_VISIBLE|
            TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS|TVS_EDITLABELS|style,
            0, 0, 120, 100, hMainWnd, (HMENU)100, GetModuleHandleA(0), 0);

    SetFocus(hTree);

    /* Record the old WNDPROC so we can call it after recording the messages */
    pOldWndProc = (WNDPROC)SetWindowLongPtrA(hTree, GWLP_WNDPROC, (LONG_PTR)TreeviewWndProc);
    SetWindowLongPtrA(hTree, GWLP_USERDATA, (LONG_PTR)pOldWndProc);

    return hTree;
}

Referenced by test_callback(), test_cchildren(), test_customdraw(), test_delete_items(), test_expandedimage(), test_expandinvisible(), test_expandnotify(), test_fillroot(), test_focus(), test_get_insertmarkcolor(), test_get_linecolor(), test_get_set_bkcolor(), test_get_set_imagelist(), test_get_set_indent(), test_get_set_insertmark(), test_get_set_item(), test_get_set_itemheight(), test_get_set_scrolltime(), test_get_set_textcolor(), test_get_set_tooltips(), test_get_set_unicodeformat(), test_getitemtext(), test_htreeitem_layout(), test_itemedit(), test_right_click(), test_select(), test_TVM_GETNEXTITEM(), test_TVM_HITTEST(), test_TVM_SORTCHILDREN(), test_TVS_CHECKBOXES(), test_TVS_FULLROWSELECT(), test_TVS_SINGLEEXPAND(), test_WM_GETDLGCODE(), test_WM_KEYDOWN(), and test_WM_PAINT().

fill_tree()

static void fill_tree ( HWND  hTree )

static

Definition at line 455 of file treeview.c.

{
    TVINSERTSTRUCTA ins;
    static CHAR root[]  = "Root",
                child[] = "Child";

    ins.hParent = TVI_ROOT;
    ins.hInsertAfter = TVI_ROOT;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = root;
    hRoot = TreeView_InsertItemA(hTree, &ins);

    ins.hParent = hRoot;
    ins.hInsertAfter = TVI_FIRST;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = child;
    hChild = TreeView_InsertItemA(hTree, &ins);
}

Referenced by test_cchildren(), test_customdraw(), test_delete_items(), test_expandedimage(), test_expandnotify(), test_fillroot(), test_focus(), test_get_set_bkcolor(), test_get_set_imagelist(), test_get_set_indent(), test_get_set_insertmark(), test_get_set_item(), test_get_set_itemheight(), test_get_set_scrolltime(), test_get_set_textcolor(), test_get_set_tooltips(), test_get_set_unicodeformat(), test_getitemtext(), test_htreeitem_layout(), test_itemedit(), test_right_click(), test_select(), test_TVM_GETNEXTITEM(), test_TVM_HITTEST(), test_TVS_CHECKBOXES(), and test_TVS_SINGLEEXPAND().

fill_treeview_sort_test()

static void fill_treeview_sort_test ( HWND  hwnd )

static

Definition at line 2558 of file treeview.c.

{
    static const char *itemnames[] =
    {
        "root", "Wasp", "Caribou", "Vacuum",
        "Ocelot", "Newspaper", "Litter bin"
    };

    HTREEITEM root, children[2];
    TVINSERTSTRUCTA ins;
    unsigned i = 0;

    SendMessageA(hwnd, TVM_DELETEITEM, 0, 0);

    /* root, two children, with two children each */
    ins.hParent = TVI_ROOT;
    ins.hInsertAfter = TVI_ROOT;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = (char *)itemnames[i++];
    root = (HTREEITEM)SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);

    ins.hParent = root;
    ins.hInsertAfter = TVI_LAST;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = (char *)itemnames[i++];
    children[0] = (HTREEITEM)SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);

    U(ins).item.pszText = (char *)itemnames[i++];
    children[1] = (HTREEITEM)SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);

    ins.hParent = children[0];
    U(ins).item.pszText = (char *)itemnames[i++];
    SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);

    U(ins).item.pszText = (char *)itemnames[i++];
    SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);

    ins.hParent = children[1];
    U(ins).item.pszText = (char *)itemnames[i++];
    SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);

    U(ins).item.pszText = (char *)itemnames[i++];
    SendMessageA(hwnd, TVM_INSERTITEMA, 0, (LPARAM)&ins);
}

Referenced by test_TVM_SORTCHILDREN().

flush_events()

static void flush_events ( void  )

static

Definition at line 58 of file treeview.c.

{
    MSG msg;
    int diff = 200;
    int min_timeout = 100;
    DWORD time = GetTickCount() + diff;

    while (diff > 0)
    {
        if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT) break;
        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
        diff = time - GetTickCount();
    }
}

Referenced by test_right_click().

get_item_names_string()

static void get_item_names_string ( HWND  hwnd, HTREEITEM  item, char *  str  )

static

Definition at line 2530 of file treeview.c.

{
    TVITEMA tvitem = { 0 };
    HTREEITEM child;
    char name[16];

    if (!item)
    {
        item = (HTREEITEM)SendMessageA(hwnd, TVM_GETNEXTITEM, TVGN_ROOT, 0);
        str[0] = 0;
    }

    child = (HTREEITEM)SendMessageA(hwnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)item);

    tvitem.mask = TVIF_TEXT;
    tvitem.hItem = item;
    tvitem.pszText = name;
    tvitem.cchTextMax = sizeof(name);
    SendMessageA(hwnd, TVM_GETITEMA, 0, (LPARAM)&tvitem);
    strcat(str, tvitem.pszText);

    while (child != NULL)
    {
        get_item_names_string(hwnd, child, str);
        child = (HTREEITEM)SendMessageA(hwnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)child);
    }
}

Referenced by test_TVM_SORTCHILDREN().

IdentifyItem()

static void IdentifyItem ( HTREEITEM  hItem )

static

Definition at line 398 of file treeview.c.

{
    if (hItem == hRoot) {
        AddItem('R');
        return;
    }
    if (hItem == hChild) {
        AddItem('C');
        return;
    }
    if (hItem == NULL) {
        AddItem('n');
        return;
    }
    AddItem('?');
}

Referenced by parent_wnd_proc().

init_functions()

static void init_functions ( void  )

static

Definition at line 2770 of file treeview.c.

{
    HMODULE hComCtl32 = LoadLibraryA("comctl32.dll");

#define X(f) p##f = (void*)GetProcAddress(hComCtl32, #f);
    X(InitCommonControlsEx);
#undef X
}

Referenced by START_TEST().

parent_wnd_proc()

static LRESULT CALLBACK parent_wnd_proc ( HWND  hWnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1227 of file treeview.c.

{
    static LONG defwndproc_counter = 0;
    struct message msg = { 0 };
    LRESULT ret;
    RECT rect;
    HTREEITEM visibleItem;

    msg.message = message;
    msg.flags = sent|wparam|lparam;
    if (defwndproc_counter) msg.flags |= defwinproc;
    msg.wParam = wParam;
    msg.lParam = lParam;
    if (message == WM_NOTIFY && lParam)
        msg.id = ((NMHDR*)lParam)->code;

    /* log system messages, except for painting */
    if (message < WM_USER &&
        message != WM_PAINT &&
        message != WM_ERASEBKGND &&
        message != WM_NCPAINT &&
        message != WM_NCHITTEST &&
        message != WM_GETTEXT &&
        message != WM_GETICON &&
        message != WM_DEVICECHANGE)
    {
        add_message(sequences, PARENT_SEQ_INDEX, &msg);
    }

    switch(message) {
    case WM_NOTIFYFORMAT:
    {
        /* Make NF_QUERY return an invalid format to show that it defaults to ANSI */
        if (lParam == NF_QUERY) return 0;
        break;
    }

    case WM_NOTIFY:
    {
        NMHDR *pHdr = (NMHDR *)lParam;

        ok(pHdr->code != NM_TOOLTIPSCREATED, "Treeview should not send NM_TOOLTIPSCREATED\n");
        if (pHdr->idFrom == 100)
        {
            NMTREEVIEWA *pTreeView = (LPNMTREEVIEWA) lParam;
            switch(pHdr->code)
            {
            case TVN_SELCHANGINGA:
                AddItem('(');
                IdentifyItem(pTreeView->itemOld.hItem);
                IdentifyItem(pTreeView->itemNew.hItem);
                break;
            case TVN_SELCHANGEDA:
                AddItem(')');
                IdentifyItem(pTreeView->itemOld.hItem);
                IdentifyItem(pTreeView->itemNew.hItem);
                break;
            case TVN_GETDISPINFOA: {
                NMTVDISPINFOA *disp = (NMTVDISPINFOA *)lParam;
                if (disp->item.mask & TVIF_TEXT) {
                    lstrcpynA(disp->item.pszText, TEST_CALLBACK_TEXT, disp->item.cchTextMax);
                }

                if (g_disp_A_to_W && (disp->item.mask & TVIF_TEXT)) {
                    static const WCHAR testW[] = {'T','E','S','T','2',0};

                    disp->hdr.code = TVN_GETDISPINFOW;
                    memcpy(disp->item.pszText, testW, sizeof(testW));
                }

                if (g_disp_set_stateimage)
                {
                    ok(disp->item.mask == TVIF_IMAGE, "got %x\n", disp->item.mask);
                    /* both masks set here are necessary to change state bits */
                    disp->item.mask |= TVIF_STATE;
                    disp->item.state = TVIS_SELECTED | INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(3);
                    disp->item.stateMask = TVIS_SELECTED | TVIS_OVERLAYMASK | TVIS_STATEIMAGEMASK;
                }

                break;
              }
            case TVN_BEGINLABELEDITA:
              {
                if (g_beginedit_alter_text)
                {
                    static const char* textA = "<edittextaltered>";
                    HWND edit;

                    edit = (HWND)SendMessageA(pHdr->hwndFrom, TVM_GETEDITCONTROL, 0, 0);
                    ok(IsWindow(edit), "failed to get edit handle\n");
                    SetWindowTextA(edit, textA);
                }

                break;
              }

            case TVN_ENDLABELEDITA: return TRUE;
            case TVN_ITEMEXPANDINGA:
              {
                UINT newmask = pTreeView->itemNew.mask & ~TVIF_CHILDREN;
                ok(newmask ==
                   (TVIF_HANDLE | TVIF_SELECTEDIMAGE | TVIF_IMAGE | TVIF_PARAM | TVIF_STATE),
                   "got wrong mask %x\n", pTreeView->itemNew.mask);
                ok(pTreeView->itemOld.mask == 0,
                   "got wrong mask %x\n", pTreeView->itemOld.mask);

                if (g_get_from_expand)
                {
                  g_item_expanding.mask = TVIF_STATE;
                  g_item_expanding.hItem = hRoot;
                  ret = SendMessageA(pHdr->hwndFrom, TVM_GETITEMA, 0, (LPARAM)&g_item_expanding);
                  ok(ret == TRUE, "got %lu\n", ret);
                }
                break;
              }
            case TVN_ITEMEXPANDEDA:
                ok(pTreeView->itemNew.mask & TVIF_STATE, "got wrong mask %x\n", pTreeView->itemNew.mask);
                ok(pTreeView->itemNew.state & (TVIS_EXPANDED|TVIS_EXPANDEDONCE),
                   "got wrong mask %x\n", pTreeView->itemNew.mask);
                ok(pTreeView->itemOld.mask == 0,
                   "got wrong mask %x\n", pTreeView->itemOld.mask);

                if (g_get_from_expand)
                {
                  g_item_expanded.mask = TVIF_STATE;
                  g_item_expanded.hItem = hRoot;
                  ret = SendMessageA(pHdr->hwndFrom, TVM_GETITEMA, 0, (LPARAM)&g_item_expanded);
                  ok(ret == TRUE, "got %lu\n", ret);
                }
                if (g_get_rect_in_expand)
                {
                  visibleItem = (HTREEITEM)SendMessageA(pHdr->hwndFrom, TVM_GETNEXTITEM,
                          TVGN_FIRSTVISIBLE, 0);
                  ok(pTreeView->itemNew.hItem == visibleItem, "expanded item == first visible item\n");
                  *(HTREEITEM*)&rect = visibleItem;
                  ok(SendMessageA(pHdr->hwndFrom, TVM_GETITEMRECT, TRUE, (LPARAM)&rect),
                          "Failed to get rect for first visible item.\n");
                  visibleItem = (HTREEITEM)SendMessageA(pHdr->hwndFrom, TVM_GETNEXTITEM,
                          TVGN_NEXTVISIBLE, (LPARAM)visibleItem);
                  *(HTREEITEM*)&rect = visibleItem;
                  ok(visibleItem != NULL, "There must be a visible item after the first visisble item.\n");
                  ok(SendMessageA(pHdr->hwndFrom, TVM_GETITEMRECT, TRUE, (LPARAM)&rect),
                          "Failed to get rect for second visible item.\n");
                }
                break;
            case TVN_DELETEITEMA:
            {
                struct message item;

                ok(pTreeView->itemNew.mask == 0, "got wrong mask 0x%x\n", pTreeView->itemNew.mask);

                ok(pTreeView->itemOld.mask == (TVIF_HANDLE | TVIF_PARAM), "got wrong mask 0x%x\n", pTreeView->itemOld.mask);
                ok(pTreeView->itemOld.hItem != NULL, "got %p\n", pTreeView->itemOld.hItem);

                memset(&item, 0, sizeof(item));
                item.lParam = (LPARAM)pTreeView->itemOld.hItem;
                add_message(item_sequence, 0, &item);

                break;
            }
            case NM_CUSTOMDRAW:
            {
                NMTVCUSTOMDRAW *nmcd = (NMTVCUSTOMDRAW*)lParam;
                COLORREF c0ffee = RGB(0xc0,0xff,0xee), cafe = RGB(0xca,0xfe,0x00);
                COLORREF text = GetTextColor(nmcd->nmcd.hdc), bkgnd = GetBkColor(nmcd->nmcd.hdc);

                msg.flags |= custdraw;
                msg.stage = nmcd->nmcd.dwDrawStage;
                add_message(sequences, PARENT_CD_SEQ_INDEX, &msg);

                switch (msg.stage)
                {
                case CDDS_PREPAINT:
                    return CDRF_NOTIFYITEMDRAW|CDRF_NOTIFYITEMERASE|CDRF_NOTIFYPOSTPAINT;
                case CDDS_ITEMPREPAINT:
                    ok(text == nmcd->clrText || (g_v6 && nmcd->clrText == 0xffffffff),
                       "got %08x vs %08x\n", text, nmcd->clrText);
                    ok(bkgnd == nmcd->clrTextBk || (g_v6 && nmcd->clrTextBk == 0xffffffff),
                       "got %08x vs %08x\n", bkgnd, nmcd->clrTextBk);
                    nmcd->clrText = cafe;
                    nmcd->clrTextBk = c0ffee;
                    SetTextColor(nmcd->nmcd.hdc, c0ffee);
                    SetBkColor(nmcd->nmcd.hdc, cafe);
                    if (g_customdraw_font)
                        SelectObject(nmcd->nmcd.hdc, g_customdraw_font);
                    return CDRF_NOTIFYPOSTPAINT|CDRF_NEWFONT;
                case CDDS_ITEMPOSTPAINT:
                    /* at the point of post paint notification colors are already restored */
                    ok(nmcd->clrText == cafe, "got 0%x\n", nmcd->clrText);
                    ok(nmcd->clrTextBk == c0ffee, "got 0%x\n", nmcd->clrTextBk);
                    ok(text != cafe, "got 0%x\n", text);
                    ok(bkgnd != c0ffee, "got 0%x\n", bkgnd);
                    if (g_customdraw_font)
                        ok(GetCurrentObject(nmcd->nmcd.hdc, OBJ_FONT) != g_customdraw_font, "got %p\n",
                           GetCurrentObject(nmcd->nmcd.hdc, OBJ_FONT));
                    break;
                default:
                    ;
                }
                break;
            }
            case NM_RCLICK:
            {
                HTREEITEM selected = (HTREEITEM)SendMessageA(((NMHDR *)lParam)->hwndFrom,
                                                             TVM_GETNEXTITEM, TVGN_CARET, 0);
                ok(selected == hChild, "child item should still be selected\n");
                break;
            }
            }
        }
        break;
    }

    }

    defwndproc_counter++;
    ret = DefWindowProcA(hWnd, message, wParam, lParam);
    defwndproc_counter--;

    return ret;
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

treeview

)

Definition at line 2779 of file treeview.c.

{
    INITCOMMONCONTROLSEX iccex;
    ULONG_PTR ctx_cookie;
    HANDLE hCtx;
    WNDCLASSA wc;

    init_functions();

    iccex.dwSize = sizeof(iccex);
    iccex.dwICC  = ICC_TREEVIEW_CLASSES;
    pInitCommonControlsEx(&iccex);

    init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
    init_msg_sequences(item_sequence, 1);
  
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = GetModuleHandleA(NULL);
    wc.hIcon = NULL;
    wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_IBEAM);
    wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "MyTestWnd";
    wc.lpfnWndProc = parent_wnd_proc;
    RegisterClassA(&wc);

    hMainWnd = CreateWindowExA(0, "MyTestWnd", "Blah", WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT, 130, 105, NULL, NULL, GetModuleHandleA(NULL), 0);

    ok(hMainWnd != NULL, "Failed to create parent window. Tests aborted.\n");
    if (!hMainWnd) return;

    test_fillroot();
    test_select();
    test_getitemtext();
    test_focus();
    test_get_set_bkcolor();
    test_get_set_imagelist();
    test_get_set_indent();
    test_get_set_insertmark();
    test_get_set_item();
    test_get_set_itemheight();
    test_get_set_scrolltime();
    test_get_set_textcolor();
    test_get_linecolor();
    test_get_insertmarkcolor();
    test_get_set_tooltips();
    test_get_set_unicodeformat();
    test_callback();
    test_expandinvisible();
    test_itemedit();
    test_treeview_classinfo();
    test_expandnotify();
    test_TVS_SINGLEEXPAND();
    test_WM_PAINT();
    test_delete_items();
    test_cchildren();
    test_htreeitem_layout();
    test_TVS_CHECKBOXES();
    test_TVM_GETNEXTITEM();
    test_TVM_HITTEST();
    test_WM_GETDLGCODE();
    test_customdraw();
    test_WM_KEYDOWN();
    test_TVS_FULLROWSELECT();
    test_TVM_SORTCHILDREN();
    test_right_click();

    if (!load_v6_module(&ctx_cookie, &hCtx))
    {
        DestroyWindow(hMainWnd);
        return;
    }

    /* comctl32 version 6 tests start here */
    g_v6 = TRUE;

    test_fillroot();
    test_getitemtext();
    test_get_set_insertmark();
    test_get_set_item();
    test_get_set_scrolltime();
    test_get_set_textcolor();
    test_get_linecolor();
    test_get_insertmarkcolor();
    test_expandedimage();
    test_get_set_tooltips();
    test_get_set_unicodeformat();
    test_expandinvisible();
    test_itemedit();
    test_treeview_classinfo();
    test_delete_items();
    test_cchildren();
    test_htreeitem_layout();
    test_TVM_GETNEXTITEM();
    test_TVM_HITTEST();
    test_WM_GETDLGCODE();
    test_customdraw();
    test_WM_KEYDOWN();
    test_TVS_FULLROWSELECT();
    test_TVM_SORTCHILDREN();

    unload_v6_module(ctx_cookie, hCtx);
}

test_callback()

static void test_callback ( void  )

static

Definition at line 504 of file treeview.c.

{
    HTREEITEM hRoot;
    HTREEITEM hItem1, hItem2;
    TVINSERTSTRUCTA ins;
    TVITEMA tvi;
    CHAR test_string[] = "Test_string";
    static const CHAR test2A[] = "TEST2";
    CHAR buf[128];
    HWND hTree;
    DWORD ret;

    hTree = create_treeview_control(0);

    ret = SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
    expect(TRUE, ret);
    ins.hParent = TVI_ROOT;
    ins.hInsertAfter = TVI_ROOT;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = LPSTR_TEXTCALLBACKA;
    hRoot = TreeView_InsertItemA(hTree, &ins);
    ok(hRoot != NULL, "failed to set root\n");

    tvi.hItem = hRoot;
    tvi.mask = TVIF_TEXT;
    tvi.pszText = buf;
    tvi.cchTextMax = sizeof(buf)/sizeof(buf[0]);
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(strcmp(tvi.pszText, TEST_CALLBACK_TEXT) == 0, "Callback item text mismatch %s vs %s\n",
        tvi.pszText, TEST_CALLBACK_TEXT);

    ins.hParent = hRoot;
    ins.hInsertAfter = TVI_FIRST;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = test_string;
    hItem1 = TreeView_InsertItemA(hTree, &ins);
    ok(hItem1 != NULL, "failed to set Item1\n");

    tvi.hItem = hItem1;
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(strcmp(tvi.pszText, test_string) == 0, "Item text mismatch %s vs %s\n",
        tvi.pszText, test_string);

    /* undocumented: pszText of NULL also means LPSTR_CALLBACK: */
    tvi.pszText = NULL;
    ret = TreeView_SetItemA(hTree, &tvi);
    expect(TRUE, ret);
    tvi.pszText = buf;
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(strcmp(tvi.pszText, TEST_CALLBACK_TEXT) == 0, "Item text mismatch %s vs %s\n",
        tvi.pszText, TEST_CALLBACK_TEXT);

    U(ins).item.pszText = NULL;
    hItem2 = TreeView_InsertItemA(hTree, &ins);
    ok(hItem2 != NULL, "failed to set Item2\n");
    tvi.hItem = hItem2;
    memset(buf, 0, sizeof(buf));
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(strcmp(tvi.pszText, TEST_CALLBACK_TEXT) == 0, "Item text mismatch %s vs %s\n",
        tvi.pszText, TEST_CALLBACK_TEXT);

    /* notification handler changed A->W */
    g_disp_A_to_W = TRUE;
    tvi.hItem = hItem2;
    memset(buf, 0, sizeof(buf));
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(strcmp(tvi.pszText, test2A) == 0, "got %s, expected %s\n",
        tvi.pszText, test2A);
    g_disp_A_to_W = FALSE;

    /* handler changes state image index */
    SetWindowLongA(hTree, GWL_STYLE, GetWindowLongA(hTree, GWL_STYLE) | TVS_CHECKBOXES);

    /* clear selection, handler will set selected state */
    ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, 0);
    expect(TRUE, ret);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    tvi.hItem = hRoot;
    tvi.mask = TVIF_STATE;
    tvi.state = TVIS_SELECTED;
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(tvi.state == INDEXTOSTATEIMAGEMASK(1), "got 0x%x\n", tvi.state);

    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
                "no TVN_GETDISPINFO for a state seq", FALSE);

    tvi.hItem     = hRoot;
    tvi.mask      = TVIF_IMAGE | TVIF_STATE;
    tvi.state     = TVIS_FOCUSED;
    tvi.stateMask = TVIS_FOCUSED;
    tvi.iImage    = I_IMAGECALLBACK;
    ret = TreeView_SetItemA(hTree, &tvi);
    expect(TRUE, ret);

    /* ask for item image index through callback - state is also set with state image index */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    tvi.hItem = hRoot;
    tvi.mask = TVIF_IMAGE;
    tvi.state = 0;
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    ok(tvi.state == (INDEXTOSTATEIMAGEMASK(1) | TVIS_FOCUSED), "got 0x%x\n", tvi.state);

    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_get_dispinfo_seq,
                "callback for state/overlay image index, noop seq", FALSE);

    /* ask for image again and overwrite state to some value in handler */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    g_disp_set_stateimage = TRUE;
    tvi.hItem = hRoot;
    tvi.mask = TVIF_IMAGE;
    tvi.state = INDEXTOSTATEIMAGEMASK(1);
    tvi.stateMask = 0;
    ret = TreeView_GetItemA(hTree, &tvi);
    expect(TRUE, ret);
    /* handler sets TVIS_SELECTED as well */
    ok(tvi.state == (TVIS_FOCUSED | TVIS_SELECTED | INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(3)), "got 0x%x\n", tvi.state);
    g_disp_set_stateimage = FALSE;

    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_get_dispinfo_seq,
                "callback for state/overlay image index seq", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_cchildren()

static void test_cchildren ( void  )

static

Definition at line 2081 of file treeview.c.

{
    HWND hTree;
    INT ret;
    TVITEMA item;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    ret = SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hChild);
    expect(TRUE, ret);

    /* check cChildren - automatic mode */
    item.hItem = hRoot;
    item.mask = TVIF_CHILDREN;

    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);
    expect(0, item.cChildren);

    DestroyWindow(hTree);

    /* start over */
    hTree = create_treeview_control(0);
    fill_tree(hTree);

    /* turn off automatic mode by setting cChildren explicitly */
    item.hItem = hRoot;
    item.mask = TVIF_CHILDREN;

    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);
    expect(1, item.cChildren);

    ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);

    ret = SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hChild);
    expect(TRUE, ret);

    /* check cChildren */
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);
todo_wine
    expect(1, item.cChildren);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_customdraw()

static void test_customdraw ( void  )

static

Definition at line 2460 of file treeview.c.

{
    LOGFONTA lf;
    HWND hwnd;

    hwnd = create_treeview_control(0);
    fill_tree(hwnd);
    SendMessageA(hwnd, TVM_EXPAND, TVE_EXPAND, (WPARAM)hRoot);

    /* create additional font, custom draw handler will select it */
    SystemParametersInfoA(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, 0);
    lf.lfHeight *= 2;
    g_customdraw_font = CreateFontIndirectA(&lf);
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    InvalidateRect(hwnd, NULL, TRUE);
    UpdateWindow(hwnd);
    ok_sequence(sequences, PARENT_CD_SEQ_INDEX, parent_cd_seq, "custom draw notifications", FALSE);
    DeleteObject(g_customdraw_font);
    g_customdraw_font = NULL;

    DestroyWindow(hwnd);
}

Referenced by START_TEST().

test_delete_items()

static void test_delete_items ( void  )

static

Definition at line 2019 of file treeview.c.

{
    const struct message *msg;
    HWND hTree;
    HTREEITEM hItem1, hItem2;
    TVINSERTSTRUCTA ins;
    INT ret;

    static CHAR item1[] = "Item 1";
    static CHAR item2[] = "Item 2";

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    /* check delete order */
    flush_sequences(item_sequence, 1);
    ret = SendMessageA(hTree, TVM_DELETEITEM, 0, 0);
    ok(ret == TRUE, "got %d\n", ret);

    msg = item_sequence[0]->sequence;
    ok(item_sequence[0]->count == 2, "expected 2 items, got %d\n", item_sequence[0]->count);

    if (item_sequence[0]->count == 2)
    {
      ok(msg[0].lParam == (LPARAM)hChild, "expected %p, got 0x%lx\n", hChild, msg[0].lParam);
      ok(msg[1].lParam == (LPARAM)hRoot, "expected %p, got 0x%lx\n", hRoot, msg[1].lParam);
    }

    ret = SendMessageA(hTree, TVM_GETCOUNT, 0, 0);
    ok(ret == 0, "got %d\n", ret);

    DestroyWindow(hTree);

    /* Regression test for a crash when deleting the first visible item while bRedraw == false. */
    hTree = create_treeview_control(0);

    ret = SendMessageA(hTree, WM_SETREDRAW, FALSE, 0);
    ok(ret == 0, "got %d\n", ret);

    ins.hParent = TVI_ROOT;
    ins.hInsertAfter = TVI_ROOT;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = item1;
    hItem1 = TreeView_InsertItemA(hTree, &ins);
    ok(hItem1 != NULL, "InsertItem failed\n");

    ins.hParent = TVI_ROOT;
    ins.hInsertAfter = hItem1;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = item2;
    hItem2 = TreeView_InsertItemA(hTree, &ins);
    ok(hItem2 != NULL, "InsertItem failed\n");

    ret = SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hItem1);
    ok(ret == TRUE, "got %d\n", ret);

    ret = SendMessageA(hTree, WM_SETREDRAW, TRUE, 0);
    ok(ret == 0, "got %d\n", ret);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_expandedimage()

static void test_expandedimage ( void  )

static

Definition at line 1847 of file treeview.c.

{
    TVITEMEXA item;
    HWND hTree;
    BOOL ret;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    item.mask = TVIF_EXPANDEDIMAGE;
    item.iExpandedImage = 1;
    item.hItem = hRoot;
    ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&item);
    ok(ret, "got %d\n", ret);

    item.mask = TVIF_EXPANDEDIMAGE;
    item.iExpandedImage = -1;
    item.hItem = hRoot;
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    ok(ret, "got %d\n", ret);

    if (item.iExpandedImage != 1)
    {
        win_skip("TVIF_EXPANDEDIMAGE not supported\n");
        DestroyWindow(hTree);
        return;
    }

    /* test for default iExpandedImage value */
    item.mask = TVIF_EXPANDEDIMAGE;
    item.iExpandedImage = -1;
    item.hItem = hChild;
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    ok(ret, "got %d\n", ret);
    ok(item.iExpandedImage == (WORD)I_IMAGENONE, "got %d\n", item.iExpandedImage);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_expandinvisible()

static void test_expandinvisible ( void  )

static

Definition at line 1449 of file treeview.c.

{
    static CHAR nodeText[][5] = {"0", "1", "2", "3", "4"};
    TVINSERTSTRUCTA ins;
    HTREEITEM node[5];
    RECT dummyRect;
    BOOL nodeVisible;
    LRESULT ret;
    HWND hTree;

    hTree = create_treeview_control(0);

    /* The test builds the following tree and expands node 1, while node 0 is collapsed.
     *
     * 0
     * |- 1
     * |  |- 2
     * |  |- 3
     * |- 4
     *
     */

    ret = SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
    ok(ret == TRUE, "ret\n");
    ins.hParent = TVI_ROOT;
    ins.hInsertAfter = TVI_ROOT;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = nodeText[0];
    node[0] = TreeView_InsertItemA(hTree, &ins);
    ok(node[0] != NULL, "failed to set node[0]\n");

    ins.hInsertAfter = TVI_LAST;
    U(ins).item.mask = TVIF_TEXT;
    ins.hParent = node[0];

    U(ins).item.pszText = nodeText[1];
    node[1] = TreeView_InsertItemA(hTree, &ins);
    ok(node[1] != NULL, "failed to set node[1]\n");
    U(ins).item.pszText = nodeText[4];
    node[4] = TreeView_InsertItemA(hTree, &ins);
    ok(node[4] != NULL, "failed to set node[4]\n");

    ins.hParent = node[1];

    U(ins).item.pszText = nodeText[2];
    node[2] = TreeView_InsertItemA(hTree, &ins);
    ok(node[2] != NULL, "failed to set node[2]\n");
    U(ins).item.pszText = nodeText[3];
    node[3] = TreeView_InsertItemA(hTree, &ins);
    ok(node[3] != NULL, "failed to set node[3]\n");

    *(HTREEITEM *)&dummyRect = node[1];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 1 should not be visible.\n");
    *(HTREEITEM *)&dummyRect = node[2];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 2 should not be visible.\n");
    *(HTREEITEM *)&dummyRect = node[3];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 3 should not be visible.\n");
    *(HTREEITEM *)&dummyRect = node[4];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 4 should not be visible.\n");

    ok(SendMessageA(hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)node[1]), "Expand of node 1 failed.\n");

    *(HTREEITEM *)&dummyRect = node[1];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 1 should not be visible.\n");
    *(HTREEITEM *)&dummyRect = node[2];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 2 should not be visible.\n");
    *(HTREEITEM *)&dummyRect = node[3];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 3 should not be visible.\n");
    *(HTREEITEM *)&dummyRect = node[4];
    nodeVisible = SendMessageA(hTree, TVM_GETITEMRECT, FALSE, (LPARAM)&dummyRect);
    ok(!nodeVisible, "Node 4 should not be visible.\n");

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_expandnotify()

static void test_expandnotify ( void  )

static

Definition at line 1675 of file treeview.c.

{
    HTREEITEM hitem;
    HWND hTree;
    BOOL ret;
    TVITEMA item;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    item.hItem = hRoot;
    item.mask = TVIF_STATE;

    item.state = TVIS_EXPANDED;
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);
    ok((item.state & TVIS_EXPANDED) == 0, "expected collapsed\n");

    /* preselect root node here */
    ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hRoot);
    expect(TRUE, ret);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, TVM_EXPAND, TVE_COLLAPSE, (LPARAM)hRoot);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "no collapse notifications", FALSE);

    g_get_from_expand = TRUE;
    /* expand */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    g_item_expanding.state = 0xdeadbeef;
    g_item_expanded.state = 0xdeadbeef;
    ret = SendMessageA(hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)hRoot);
    expect(TRUE, ret);
    ok(g_item_expanding.state == TVIS_SELECTED, "got state on TVN_ITEMEXPANDING 0x%08x\n",
       g_item_expanding.state);
    ok(g_item_expanded.state == (TVIS_SELECTED|TVIS_EXPANDED), "got state on TVN_ITEMEXPANDED 0x%08x\n",
       g_item_expanded.state);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_seq, "expand notifications", FALSE);
    g_get_from_expand = FALSE;

    /* check that it's expanded */
    item.state = TVIS_EXPANDED;
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);
    ok((item.state & TVIS_EXPANDED) == TVIS_EXPANDED, "expected expanded\n");

    /* collapse */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, TVM_EXPAND, TVE_COLLAPSE, (LPARAM)hRoot);
    expect(TRUE, ret);
    item.state = TVIS_EXPANDED;
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);
    ok((item.state & TVIS_EXPANDED) == 0, "expected collapsed\n");
    /* all further collapse/expand attempts won't produce any notifications,
       the only way is to reset with all children removed */
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "collapse after expand notifications", FALSE);

    /* try to toggle child that doesn't have children itself */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, TVM_EXPAND, TVE_TOGGLE, (LPARAM)hChild);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "toggle node without children", FALSE);

    DestroyWindow(hTree);

    /* test TVM_GETITEMRECT inside TVN_ITEMEXPANDED notification */
    hTree = create_treeview_control(0);
    fill_tree(hTree);
    g_get_rect_in_expand = TRUE;
    ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hChild);
    expect(TRUE, ret);
    g_get_rect_in_expand = FALSE;

    DestroyWindow(hTree);

    /* TVE_TOGGLE acts as any other TVM_EXPAND */
    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, TVM_EXPAND, TVE_TOGGLE, (LPARAM)hRoot);
    expect(TRUE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_seq, "toggle node (expand)", FALSE);

    /* toggle again - no notifications */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, TVM_EXPAND, TVE_TOGGLE, (LPARAM)hRoot);
    expect(TRUE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "toggle node (collapse)", FALSE);

    DestroyWindow(hTree);

    /* some keyboard events are also translated to expand */
    hTree = create_treeview_control(0);
    fill_tree(hTree);

    /* preselect root node here */
    ret = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hRoot);
    expect(TRUE, ret);

    g_get_from_expand = TRUE;
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_ADD, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_kb_seq, "expand node", FALSE);
    ok(g_item_expanding.state == TVIS_SELECTED, "got state on TVN_ITEMEXPANDING 0x%08x\n",
       g_item_expanding.state);
    ok(g_item_expanded.state == (TVIS_SELECTED|TVIS_EXPANDED), "got state on TVN_ITEMEXPANDED 0x%08x\n",
       g_item_expanded.state);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_ADD, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_kb_seq, "expand node again", FALSE);
    ok(g_item_expanding.state == (TVIS_SELECTED|TVIS_EXPANDED|TVIS_EXPANDEDONCE), "got state on TVN_ITEMEXPANDING 0x%08x\n",
       g_item_expanding.state);
    ok(g_item_expanded.state == (TVIS_SELECTED|TVIS_EXPANDED|TVIS_EXPANDEDONCE), "got state on TVN_ITEMEXPANDED 0x%08x\n",
       g_item_expanded.state);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_SUBTRACT, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_kb_seq, "collapse node", FALSE);
    ok(g_item_expanding.state == (TVIS_SELECTED|TVIS_EXPANDED|TVIS_EXPANDEDONCE), "got state on TVN_ITEMEXPANDING 0x%08x\n",
       g_item_expanding.state);
    ok(g_item_expanded.state == (TVIS_SELECTED|TVIS_EXPANDEDONCE), "got state on TVN_ITEMEXPANDED 0x%08x\n",
       g_item_expanded.state);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_SUBTRACT, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_collapse_2nd_kb_seq, "collapse node again", FALSE);
    ok(g_item_expanding.state == (TVIS_SELECTED|TVIS_EXPANDEDONCE), "got state on TVN_ITEMEXPANDING 0x%08x\n",
       g_item_expanding.state);
    g_get_from_expand = FALSE;

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_ADD, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_kb_seq, "expand node", FALSE);

    /* go to child */
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_RIGHT, 0);
    expect(FALSE, ret);

    /* try to expand child that doesn't have children itself */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_ADD, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_expand_empty_kb_seq, "expand node with no children", FALSE);

    /* stay on current selection and set non-zero children count */
    hitem = (HTREEITEM)SendMessageA(hTree, TVM_GETNEXTITEM, TVGN_CARET, 0);
    ok(hitem != NULL, "got %p\n", hitem);

    item.hItem = hitem;
    item.mask = TVIF_CHILDREN;
    item.cChildren = 0x80000000;

    ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&item);
    expect(TRUE, ret);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ret = SendMessageA(hTree, WM_KEYDOWN, VK_ADD, 0);
    expect(FALSE, ret);
    ok_sequence(sequences, PARENT_SEQ_INDEX, parent_collapse_2nd_kb_seq, "expand node with children", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_fillroot()

static void test_fillroot ( void  )

static

Definition at line 474 of file treeview.c.

{
    TVITEMA tvi;
    HWND hTree;

    hTree = create_treeview_control(0);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    fill_tree(hTree);

    Clear();
    AddItem('A');
    ok(hRoot != NULL, "failed to set root\n");
    AddItem('B');
    ok(hChild != NULL, "failed to set child\n");
    AddItem('.');
    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, FillRootSeq, "FillRoot", FALSE);
    ok(!strcmp(sequence, "AB."), "Item creation\n");

    /* UMLPad 1.15 depends on this being not -1 (I_IMAGECALLBACK) */
    tvi.hItem = hRoot;
    tvi.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&tvi);
    ok(tvi.iImage == 0, "tvi.iImage=%d\n", tvi.iImage);
    ok(tvi.iSelectedImage == 0, "tvi.iSelectedImage=%d\n", tvi.iSelectedImage);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_focus()

static void test_focus ( void  )

static

Definition at line 739 of file treeview.c.

{
    TVINSERTSTRUCTA ins;
    static CHAR child1[]  = "Edit",
                child2[]  = "A really long string";
    HTREEITEM hChild1, hChild2;
    HWND hTree;
    HWND hEdit;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* This test verifies that when a label is being edited, scrolling
     * the treeview does not cause the label to lose focus. To test
     * this, first some additional entries are added to generate
     * scrollbars.
     */
    ins.hParent = hRoot;
    ins.hInsertAfter = hChild;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = child1;
    hChild1 = TreeView_InsertItemA(hTree, &ins);
    ok(hChild1 != NULL, "failed to set hChild1\n");
    ins.hInsertAfter = hChild1;
    U(ins).item.mask = TVIF_TEXT;
    U(ins).item.pszText = child2;
    hChild2 = TreeView_InsertItemA(hTree, &ins);
    ok(hChild2 != NULL, "failed to set hChild2\n");

    ShowWindow(hMainWnd,SW_SHOW);
    SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hChild);
    hEdit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, (LPARAM)hChild);
    ScrollWindowEx(hTree, -10, 0, NULL, NULL, NULL, NULL, SW_SCROLLCHILDREN);
    ok(GetFocus() == hEdit, "Edit control should have focus\n");
    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, focus_seq, "focus test", TRUE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_insertmarkcolor()

static void test_get_insertmarkcolor ( void  )

static

Definition at line 1658 of file treeview.c.

{
    COLORREF clr;
    HWND hTree;

    hTree = create_treeview_control(0);

    /* newly created control has default color */
    clr = SendMessageA(hTree, TVM_GETINSERTMARKCOLOR, 0, 0);
    if (clr == 0)
        win_skip("TVM_GETINSERTMARKCOLOR is not supported on comctl32 < 5.80\n");
    else
        expect(CLR_DEFAULT, clr);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_linecolor()

static void test_get_linecolor ( void  )

static

Definition at line 1641 of file treeview.c.

{
    COLORREF clr;
    HWND hTree;

    hTree = create_treeview_control(0);

    /* newly created control has default color */
    clr = SendMessageA(hTree, TVM_GETLINECOLOR, 0, 0);
    if (clr == 0)
        win_skip("TVM_GETLINECOLOR is not supported on comctl32 < 5.80\n");
    else
        expect(CLR_DEFAULT, clr);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_bkcolor()

static void test_get_set_bkcolor ( void  )

static

Definition at line 780 of file treeview.c.

{
    COLORREF crColor;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* If the value is -1, the control is using the system color for the background color. */
    crColor = SendMessageA(hTree, TVM_GETBKCOLOR, 0, 0);
    ok(crColor == ~0u, "Default background color reported as 0x%.8x\n", crColor);

    /* Test for black background */
    SendMessageA(hTree, TVM_SETBKCOLOR, 0, RGB(0,0,0));
    crColor = SendMessageA(hTree, TVM_GETBKCOLOR, 0, 0);
    ok(crColor == RGB(0,0,0), "Black background color reported as 0x%.8x\n", crColor);

    /* Test for white background */
    SendMessageA(hTree, TVM_SETBKCOLOR, 0, RGB(255,255,255));
    crColor = SendMessageA(hTree, TVM_GETBKCOLOR, 0, 0);
    ok(crColor == RGB(255,255,255), "White background color reported as 0x%.8x\n", crColor);

    /* Reset the default background */
    SendMessageA(hTree, TVM_SETBKCOLOR, 0, -1);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_bkcolor_seq,
        "test get set bkcolor", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_imagelist()

static void test_get_set_imagelist ( void  )

static

Definition at line 813 of file treeview.c.

{
    HIMAGELIST himl;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* Test a NULL HIMAGELIST */
    SendMessageA(hTree, TVM_SETIMAGELIST, TVSIL_NORMAL, 0);
    himl = (HIMAGELIST)SendMessageA(hTree, TVM_GETIMAGELIST, TVSIL_NORMAL, 0);
    ok(himl == NULL, "NULL image list, reported as %p, expected 0.\n", himl);

    /* TODO: Test an actual image list */

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_imagelist_seq,
        "test get imagelist", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_indent()

static void test_get_set_indent ( void  )

static

Definition at line 836 of file treeview.c.

{
    int ulIndent;
    int ulMinIndent;
    int ulMoreThanTwiceMin;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* Finding the minimum indent */
    SendMessageA(hTree, TVM_SETINDENT, 0, 0);
    ulMinIndent = SendMessageA(hTree, TVM_GETINDENT, 0, 0);

    /* Checking an indent that is more than twice the default indent */
    ulMoreThanTwiceMin = 2*ulMinIndent+1;
    SendMessageA(hTree, TVM_SETINDENT, ulMoreThanTwiceMin, 0);
    ulIndent = SendMessageA(hTree, TVM_GETINDENT, 0, 0);
    ok(ulIndent == ulMoreThanTwiceMin, "Indent reported as %d, expected %d\n", ulIndent, ulMoreThanTwiceMin);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_indent_seq,
        "test get set indent", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_insertmark()

static void test_get_set_insertmark ( void  )

static

Definition at line 864 of file treeview.c.

{
    COLORREF crColor = RGB(0,0,0);
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    SendMessageA(hTree, TVM_SETINSERTMARKCOLOR, 0, crColor);
    crColor = SendMessageA(hTree, TVM_GETINSERTMARKCOLOR, 0, 0);
    ok(crColor == RGB(0,0,0), "Insert mark color reported as 0x%.8x, expected 0x00000000\n", crColor);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_insertmarkcolor_seq,
        "test get set insertmark color", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_item()

static void test_get_set_item ( void  )

static

Definition at line 884 of file treeview.c.

{
    TVITEMA tviRoot = {0};
    int nBufferSize = 80;
    char szBuffer[80] = {0};
    HWND hTree, hTree2;
    DWORD ret;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    tviRoot.hItem = hRoot;
    tviRoot.mask  = TVIF_STATE;
    tviRoot.state = TVIS_FOCUSED;
    tviRoot.stateMask = TVIS_FOCUSED;
    ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&tviRoot);
    expect(TRUE, ret);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* Test the root item, state is set even when not requested */
    tviRoot.hItem = hRoot;
    tviRoot.mask = TVIF_TEXT;
    tviRoot.state = 0;
    tviRoot.stateMask = 0;
    tviRoot.cchTextMax = nBufferSize;
    tviRoot.pszText = szBuffer;
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&tviRoot);
    expect(TRUE, ret);
    ok(!strcmp("Root", szBuffer), "GetItem: szBuffer=\"%s\", expected \"Root\"\n", szBuffer);
    ok(tviRoot.state == TVIS_FOCUSED, "got 0x%0x\n", tviRoot.state);

    /* Change the root text */
    lstrcpynA(szBuffer, "Testing123", nBufferSize);
    ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&tviRoot);
    expect(TRUE, ret);
    memset(szBuffer, 0, nBufferSize);
    ret = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&tviRoot);
    expect(TRUE, ret);
    ok(!strcmp("Testing123", szBuffer), "GetItem: szBuffer=\"%s\", expected \"Testing123\"\n", szBuffer);

    /* Reset the root text */
    memset(szBuffer, 0, nBufferSize);
    lstrcpynA(szBuffer, "Root", nBufferSize);
    ret = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&tviRoot);
    expect(TRUE, ret);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_item_seq,
        "test get set item", FALSE);

    /* get item from a different tree */
    hTree2 = create_treeview_control(0);

    tviRoot.hItem = hRoot;
    tviRoot.mask = TVIF_STATE;
    tviRoot.state = 0;
    ret = SendMessageA(hTree2, TVM_GETITEMA, 0, (LPARAM)&tviRoot);
    expect(TRUE, ret);
    ok(tviRoot.state == TVIS_FOCUSED, "got state 0x%0x\n", tviRoot.state);

    /* invalid item pointer, nt4 crashes here but later versions just return 0 */
    tviRoot.hItem = (HTREEITEM)0xdeadbeef;
    tviRoot.mask = TVIF_STATE;
    tviRoot.state = 0;
    ret = SendMessageA(hTree2, TVM_GETITEMA, 0, (LPARAM)&tviRoot);
    expect(FALSE, ret);

    DestroyWindow(hTree);
    DestroyWindow(hTree2);
}

Referenced by START_TEST().

test_get_set_itemheight()

static void test_get_set_itemheight ( void  )

static

Definition at line 955 of file treeview.c.

{
    int ulOldHeight = 0;
    int ulNewHeight = 0;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* Assuming default height to begin with */
    ulOldHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);

    /* Explicitly setting and getting the default height */
    SendMessageA(hTree, TVM_SETITEMHEIGHT, -1, 0);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == ulOldHeight, "Default height not set properly, reported %d, expected %d\n", ulNewHeight, ulOldHeight);

    /* Explicitly setting and getting the height of twice the normal */
    SendMessageA(hTree, TVM_SETITEMHEIGHT, 2*ulOldHeight, 0);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == 2*ulOldHeight, "New height not set properly, reported %d, expected %d\n", ulNewHeight, 2*ulOldHeight);

    /* Assuming tree doesn't have TVS_NONEVENHEIGHT set, so a set of 9 will round down to 8 */
    SendMessageA(hTree, TVM_SETITEMHEIGHT, 9, 0);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == 8, "Uneven height not set properly, reported %d, expected %d\n", ulNewHeight, 8);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_itemheight_seq,
        "test get set item height", FALSE);

    /* without TVS_NONEVENHEIGHT */
    SetWindowLongA(hTree, GWL_STYLE, GetWindowLongA(hTree, GWL_STYLE) & ~TVS_NONEVENHEIGHT);
    /* odd value */
    ulOldHeight = SendMessageA(hTree, TVM_SETITEMHEIGHT, 3, 0);
    ok(ulOldHeight == 8, "got %d, expected %d\n", ulOldHeight, 8);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == 2, "got %d, expected %d\n", ulNewHeight, 2);

    ulOldHeight = SendMessageA(hTree, TVM_SETITEMHEIGHT, 4, 0);
    ok(ulOldHeight == 2, "got %d, expected %d\n", ulOldHeight, 2);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == 4, "got %d, expected %d\n", ulNewHeight, 4);

    /* with TVS_NONEVENHEIGHT */
    SetWindowLongA(hTree, GWL_STYLE, GetWindowLongA(hTree, GWL_STYLE) | TVS_NONEVENHEIGHT);
    /* odd value */
    ulOldHeight = SendMessageA(hTree, TVM_SETITEMHEIGHT, 3, 0);
    ok(ulOldHeight == 4, "got %d, expected %d\n", ulOldHeight, 4);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == 3, "got %d, expected %d\n", ulNewHeight, 3);
    /* even value */
    ulOldHeight = SendMessageA(hTree, TVM_SETITEMHEIGHT, 10, 0);
    ok(ulOldHeight == 3, "got %d, expected %d\n", ulOldHeight, 3);
    ulNewHeight = SendMessageA(hTree, TVM_GETITEMHEIGHT, 0, 0);
    ok(ulNewHeight == 10, "got %d, expected %d\n", ulNewHeight, 10);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_scrolltime()

static void test_get_set_scrolltime ( void  )

static

Definition at line 1016 of file treeview.c.

{
    int ulExpectedTime = 20;
    int ulTime = 0;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    SendMessageA(hTree, TVM_SETSCROLLTIME, ulExpectedTime, 0);
    ulTime = SendMessageA(hTree, TVM_GETSCROLLTIME, 0, 0);
    ok(ulTime == ulExpectedTime, "Scroll time reported as %d, expected %d\n", ulTime, ulExpectedTime);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_scrolltime_seq,
        "test get set scroll time", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_textcolor()

static void test_get_set_textcolor ( void  )

static

Definition at line 1037 of file treeview.c.

{
    /* If the value is -1, the control is using the system color for the text color. */
    COLORREF crColor;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    crColor = SendMessageA(hTree, TVM_GETTEXTCOLOR, 0, 0);
    ok(crColor == ~0u, "Default text color reported as 0x%.8x\n", crColor);

    /* Test for black text */
    SendMessageA(hTree, TVM_SETTEXTCOLOR, 0, RGB(0,0,0));
    crColor = SendMessageA(hTree, TVM_GETTEXTCOLOR, 0, 0);
    ok(crColor == RGB(0,0,0), "Black text color reported as 0x%.8x\n", crColor);

    /* Test for white text */
    SendMessageA(hTree, TVM_SETTEXTCOLOR, 0, RGB(255,255,255));
    crColor = SendMessageA(hTree, TVM_GETTEXTCOLOR, 0, 0);
    ok(crColor == RGB(255,255,255), "White text color reported as 0x%.8x\n", crColor);

    /* Reset the default text color */
    SendMessageA(hTree, TVM_SETTEXTCOLOR, 0, CLR_NONE);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_textcolor_seq,
        "test get set text color", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_get_set_tooltips()

static void test_get_set_tooltips ( void  )

static

Definition at line 1070 of file treeview.c.

{
    HWND hTree, tooltips, hwnd;
    DWORD style;
    int i;

    /* TVS_NOTOOLTIPS */
    hTree = create_treeview_control(TVS_NOTOOLTIPS);

    tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(tooltips == NULL, "Unexpected tooltip window %p.\n", tooltips);

    tooltips = (HWND)SendMessageA(hTree, TVM_SETTOOLTIPS, 0, 0);
    ok(tooltips == NULL, "Unexpected ret value %p.\n", tooltips);

    /* Toggle style */
    style = GetWindowLongA(hTree, GWL_STYLE);
    SetWindowLongA(hTree, GWL_STYLE, style & ~TVS_NOTOOLTIPS);

    tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(IsWindow(tooltips), "Unexpected tooltip window %p.\n", tooltips);

    style = GetWindowLongA(hTree, GWL_STYLE);
    SetWindowLongA(hTree, GWL_STYLE, style | TVS_NOTOOLTIPS);

    tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(tooltips == NULL, "Unexpected tooltip window %p.\n", tooltips);

    DestroyWindow(hTree);

    /* Set some valid window, does not have to be tooltips class. */
    hTree = create_treeview_control(TVS_NOTOOLTIPS);

    hwnd = CreateWindowA(WC_STATICA, "Test", WS_VISIBLE|WS_CHILD, 5, 5, 100, 100, hMainWnd, NULL, NULL, 0);
    ok(hwnd != NULL, "Failed to create child window.\n");

    tooltips = (HWND)SendMessageA(hTree, TVM_SETTOOLTIPS, (WPARAM)hwnd, 0);
    ok(tooltips == NULL, "Unexpected ret value %p.\n", tooltips);

    tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(tooltips == hwnd, "Unexpected tooltip window %p.\n", tooltips);

    /* Externally set tooltips window, disable style. */
    style = GetWindowLongA(hTree, GWL_STYLE);
    SetWindowLongA(hTree, GWL_STYLE, style & ~TVS_NOTOOLTIPS);

    tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(IsWindow(tooltips) && tooltips != hwnd, "Unexpected tooltip window %p.\n", tooltips);
    ok(IsWindow(hwnd), "Expected valid window.\n");

    style = GetWindowLongA(hTree, GWL_STYLE);
    SetWindowLongA(hTree, GWL_STYLE, style | TVS_NOTOOLTIPS);
    ok(!IsWindow(tooltips), "Unexpected tooltip window %p.\n", tooltips);

    tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(tooltips == NULL, "Unexpected tooltip window %p.\n", tooltips);
    ok(IsWindow(hwnd), "Expected valid window.\n");

    DestroyWindow(hTree);
    ok(IsWindow(hwnd), "Expected valid window.\n");

    /* Set window, disable tooltips. */
    hTree = create_treeview_control(0);

    tooltips = (HWND)SendMessageA(hTree, TVM_SETTOOLTIPS, (WPARAM)hwnd, 0);
    ok(IsWindow(tooltips), "Unexpected ret value %p.\n", tooltips);

    style = GetWindowLongA(hTree, GWL_STYLE);
    SetWindowLongA(hTree, GWL_STYLE, style | TVS_NOTOOLTIPS);
    ok(!IsWindow(hwnd), "Unexpected tooltip window %p.\n", tooltips);
    ok(IsWindow(tooltips), "Expected valid window %p.\n", tooltips);

    DestroyWindow(hTree);
    ok(IsWindow(tooltips), "Expected valid window %p.\n", tooltips);
    DestroyWindow(tooltips);
    DestroyWindow(hwnd);

    for (i = 0; i < 2; i++)
    {
        DWORD style = i == 0 ? 0 : TVS_NOTOOLTIPS;

        hwnd = CreateWindowA(WC_STATICA, "Test", WS_VISIBLE|WS_CHILD, 5, 5, 100, 100, hMainWnd, NULL, NULL, 0);
        ok(hwnd != NULL, "Failed to create child window.\n");

        hTree = create_treeview_control(style);

        tooltips = (HWND)SendMessageA(hTree, TVM_SETTOOLTIPS, (WPARAM)hwnd, 0);
        ok(style & TVS_NOTOOLTIPS ? tooltips == NULL : IsWindow(tooltips), "Unexpected ret value %p.\n", tooltips);
        DestroyWindow(tooltips);

        tooltips = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
        ok(tooltips == hwnd, "Unexpected tooltip window %p.\n", tooltips);

        /* TreeView is destroyed, check if set window is still around. */
        DestroyWindow(hTree);
        ok(!IsWindow(hwnd), "Unexpected window.\n");
    }

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* show even WS_POPUP treeview don't send NM_TOOLTIPSCREATED */
    hwnd = CreateWindowA(WC_TREEVIEWA, NULL, WS_POPUP|WS_VISIBLE, 0, 0, 100, 100,
            hMainWnd, NULL, NULL, NULL);
    DestroyWindow(hwnd);

    /* Testing setting a NULL ToolTip */
    tooltips = (HWND)SendMessageA(hTree, TVM_SETTOOLTIPS, 0, 0);
    ok(IsWindow(tooltips), "Unexpected ret value %p.\n", tooltips);

    hwnd = (HWND)SendMessageA(hTree, TVM_GETTOOLTIPS, 0, 0);
    ok(hwnd == NULL, "Unexpected tooltip window %p.\n", hwnd);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_tooltips_seq,
        "test get set tooltips", TRUE);

    DestroyWindow(hTree);
    ok(IsWindow(tooltips), "Expected valid window.\n");
    DestroyWindow(tooltips);
}

Referenced by START_TEST().

test_get_set_unicodeformat()

static void test_get_set_unicodeformat ( void  )

static

Definition at line 1193 of file treeview.c.

{
    BOOL bPreviousSetting;
    BOOL bNewSetting;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    /* Check that an invalid format returned by NF_QUERY defaults to ANSI */
    bPreviousSetting = SendMessageA(hTree, TVM_GETUNICODEFORMAT, 0, 0);
    ok(bPreviousSetting == FALSE, "Format should be ANSI.\n");

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* Set to Unicode */
    bPreviousSetting = SendMessageA(hTree, TVM_SETUNICODEFORMAT, 1, 0);
    bNewSetting = SendMessageA(hTree, TVM_GETUNICODEFORMAT, 0, 0);
    ok(bNewSetting == TRUE, "Unicode setting did not work.\n");

    /* Set to ANSI */
    SendMessageA(hTree, TVM_SETUNICODEFORMAT, 0, 0);
    bNewSetting = SendMessageA(hTree, TVM_GETUNICODEFORMAT, 0, 0);
    ok(bNewSetting == FALSE, "ANSI setting did not work.\n");

    /* Revert to original setting */
    SendMessageA(hTree, TVM_SETUNICODEFORMAT, bPreviousSetting, 0);

    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, test_get_set_unicodeformat_seq,
        "test get set unicode format", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_getitemtext()

static void test_getitemtext ( void  )

static

Definition at line 701 of file treeview.c.

{
    TVINSERTSTRUCTA ins;
    HTREEITEM hChild;
    TVITEMA tvi;
    HWND hTree;

    CHAR szBuffer[80] = "Blah";
    int nBufferSize = sizeof(szBuffer)/sizeof(CHAR);

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    /* add an item without TVIF_TEXT mask and pszText == NULL */
    ins.hParent = hRoot;
    ins.hInsertAfter = TVI_ROOT;
    U(ins).item.mask = 0;
    U(ins).item.pszText = NULL;
    U(ins).item.cchTextMax = 0;
    hChild = TreeView_InsertItemA(hTree, &ins);
    ok(hChild != NULL, "failed to set hChild\n");

    /* retrieve it with TVIF_TEXT mask */
    tvi.hItem = hChild;
    tvi.mask = TVIF_TEXT;
    tvi.cchTextMax = nBufferSize;
    tvi.pszText = szBuffer;

    SendMessageA( hTree, TVM_GETITEMA, 0, (LPARAM)&tvi );
    ok(!strcmp(szBuffer, ""), "szBuffer=\"%s\", expected \"\"\n", szBuffer);
    ok(SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hChild), "DeleteItem failed\n");
    ok_sequence(sequences, TREEVIEW_SEQ_INDEX, getitemtext_seq, "get item text seq", FALSE);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_htreeitem_layout()

static void test_htreeitem_layout ( void  )

static

Definition at line 2148 of file treeview.c.

{
    TVINSERTSTRUCTA ins;
    HTREEITEM item1, item2;
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    /* root has some special pointer in parent field */
    check_item(hRoot, ((struct _ITEM_DATA*)hRoot)->parent, 0, hChild);
    check_item(hChild, hRoot, 0, 0);

    ins.hParent = hChild;
    ins.hInsertAfter = TVI_FIRST;
    U(ins).item.mask = 0;
    item1 = TreeView_InsertItemA(hTree, &ins);

    check_item(item1, hChild, 0, 0);

    ins.hParent = hRoot;
    ins.hInsertAfter = TVI_FIRST;
    U(ins).item.mask = 0;
    item2 = TreeView_InsertItemA(hTree, &ins);

    check_item(item2, hRoot, hChild, 0);

    SendMessageA(hTree, TVM_DELETEITEM, 0, (LPARAM)hChild);

    /* without children now */
    check_item(hRoot, ((struct _ITEM_DATA*)hRoot)->parent, 0, item2);

    DestroyWindow(hTree);
}

Referenced by START_TEST().

test_itemedit()

static void test_itemedit ( void  )

static

Definition at line 1531 of file treeview.c.

{
    DWORD r;
    HWND edit;
    TVITEMA item;
    CHAR buffA[20];
    HWND hTree;

    hTree = create_treeview_control(0);
    fill_tree(hTree);

    /* try with null item */
    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, 0);
    ok(!IsWindow(edit), "Expected valid handle\n");

    /* trigger edit */
    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, (LPARAM)hRoot);
    ok(IsWindow(edit), "Expected valid handle\n");
    /* item shouldn't be selected automatically after TVM_EDITLABELA */
    r = SendMessageA(hTree, TVM_GETITEMSTATE, (WPARAM)hRoot, TVIS_SELECTED);
    expect(0, r);
    /* try to cancel with wrong edit handle */
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), 0);
    expect(0, r);
    ok(IsWindow(edit), "Expected edit control to be valid\n");
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
    expect(0, r);
    ok(!IsWindow(edit), "Expected edit control to be destroyed\n");
    /* try to cancel without creating edit */
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), 0);
    expect(0, r);

    /* try to cancel with wrong (not null) handle */
    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, (LPARAM)hRoot);
    ok(IsWindow(edit), "Expected valid handle\n");
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hTree);
    expect(0, r);
    ok(IsWindow(edit), "Expected edit control to be valid\n");
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
    expect(0, r);

    /* remove selection after starting edit */
    r = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hRoot);
    expect(TRUE, r);
    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, (LPARAM)hRoot);
    ok(IsWindow(edit), "Expected valid handle\n");
    r = SendMessageA(hTree, TVM_SELECTITEM, TVGN_CARET, 0);
    expect(TRUE, r);
    /* alter text */
    strcpy(buffA, "x");
    r = SendMessageA(edit, WM_SETTEXT, 0, (LPARAM)buffA);
    expect(TRUE, r);
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
    expect(0, r);
    ok(!IsWindow(edit), "Expected edit control to be destroyed\n");
    /* check that text is saved */
    item.mask = TVIF_TEXT;
    item.hItem = hRoot;
    item.pszText = buffA;
    item.cchTextMax = sizeof(buffA)/sizeof(CHAR);
    r = SendMessageA(hTree, TVM_GETITEMA, 0, (LPARAM)&item);
    expect(TRUE, r);
    ok(!strcmp("x", buffA), "Expected item text to change\n");

    /* try A/W messages */
    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, (LPARAM)hRoot);
    ok(IsWindow(edit), "Expected valid handle\n");
    ok(IsWindowUnicode(edit), "got ansi window\n");
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
    expect(0, r);
    ok(!IsWindow(edit), "expected invalid handle\n");

    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELW, 0, (LPARAM)hRoot);
    ok(IsWindow(edit), "Expected valid handle\n");
    ok(IsWindowUnicode(edit), "got ansi window\n");
    r = SendMessageA(hTree, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)edit);
    expect(0, r);

    /* alter text during TVM_BEGINLABELEDIT, check that it's preserved */
    strcpy(buffA, "<root>");

    item.mask = TVIF_TEXT;
    item.hItem = hRoot;
    item.pszText = buffA;
    item.cchTextMax = 0;
    r = SendMessageA(hTree, TVM_SETITEMA, 0, (LPARAM)&item);
    expect(TRUE, r);

    g_beginedit_alter_text = TRUE;
    edit = (HWND)SendMessageA(hTree, TVM_EDITLABELA, 0, (LPARAM)