sprint/gtl/TreeView.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_TREEVIEW_H
#define _SPRINT_TREEVIEW_H

#include <sprint/gtl/Window.h>
#include <sprint/gtl/detail/commctrl.h>

namespace sprint {
        namespace gtl {

class TreeView : public CWindow
{
public:
// Constructors
        TreeView(HWND hWnd = NULL) : CWindow(hWnd)
        { }

/*
        HWND Create(HWND hWndParent, RECT rect = NULL, LPCTSTR szWindowName = NULL,
                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
        {
                return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
        }
*/

// Attributes
        static LPCTSTR GetWndClassName()
        {
                return WC_TREEVIEW;
        }

        UINT GetCount() const
        {
                return (UINT)::SendMessage(m_hwnd, TVM_GETCOUNT, 0, 0L);
        }

        UINT GetIndent() const
        {
                return (UINT)::SendMessage(m_hwnd, TVM_GETINDENT, 0, 0L);
        }

        void SetIndent(UINT nIndent)
        {
                ::SendMessage(m_hwnd, TVM_SETINDENT, nIndent, 0L);
        }

        HIMAGELIST GetImageList(int nImageListType = TVSIL_NORMAL) const
        {
                return ((HIMAGELIST)::SendMessage(m_hwnd, TVM_GETIMAGELIST, (WPARAM)nImageListType, 0L));
        }

        HIMAGELIST SetImageList(HIMAGELIST hImageList, int nImageListType = TVSIL_NORMAL)
        {
                return ((HIMAGELIST)::SendMessage(m_hwnd, TVM_SETIMAGELIST, (WPARAM)nImageListType, (LPARAM)hImageList));
        }

        BOOL GetItem(LPTVITEM pItem) const
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)pItem);
        }

        BOOL SetItem(LPTVITEM pItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SETITEM, 0, (LPARAM)pItem);
        }

        BOOL SetItem(HTREEITEM hItem, UINT nMask, LPCTSTR lpszItem, int nImage,
                int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam)
        {
                TVITEM item = { 0 };
                item.hItem = hItem;
                item.mask = nMask;
                item.pszText = (LPTSTR) lpszItem;
                item.iImage = nImage;
                item.iSelectedImage = nSelectedImage;
                item.state = nState;
                item.stateMask = nStateMask;
                item.lParam = lParam;
                return (BOOL)::SendMessage(m_hwnd, TVM_SETITEM, 0, (LPARAM)&item);
        }

        BOOL GetItemText(HTREEITEM hItem, LPTSTR lpstrText, int nLen) const
        {
                TVITEM item = { 0 };
                item.hItem = hItem;
                item.mask = TVIF_TEXT;
                item.pszText = lpstrText;
                item.cchTextMax = nLen;

                return (BOOL)::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)&item);
        }

        BOOL SetItemText(HTREEITEM hItem, LPCTSTR lpszItem)
        {
                return SetItem(hItem, TVIF_TEXT, lpszItem, 0, 0, 0, 0, 0);
        }

        BOOL GetItemImage(HTREEITEM hItem, int& nImage, int& nSelectedImage) const
        {
                TVITEM item = { 0 };
                item.hItem = hItem;
                item.mask = TVIF_IMAGE|TVIF_SELECTEDIMAGE;
                BOOL bRes = (BOOL)::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)&item);
                if (bRes)
                {
                        nImage = item.iImage;
                        nSelectedImage = item.iSelectedImage;
                }
                return bRes;
        }

        BOOL SetItemImage(HTREEITEM hItem, int nImage, int nSelectedImage)
        {
                return SetItem(hItem, TVIF_IMAGE|TVIF_SELECTEDIMAGE, NULL, nImage, nSelectedImage, 0, 0, 0);
        }

        UINT GetItemState(HTREEITEM hItem, UINT nStateMask) const
        {
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
                return (((UINT)::SendMessage(m_hwnd, TVM_GETITEMSTATE, (WPARAM)hItem, (LPARAM)nStateMask)) & nStateMask);
#else // !((_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE))
                TVITEM item = { 0 };
                item.hItem = hItem;
                item.mask = TVIF_STATE;
                item.state = 0;
                item.stateMask = nStateMask;
                ::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)&item);
                return (item.state & nStateMask);
#endif // !((_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE))
        }

        BOOL SetItemState(HTREEITEM hItem, UINT nState, UINT nStateMask)
        {
                return SetItem(hItem, TVIF_STATE, NULL, 0, 0, nState, nStateMask, 0);
        }

        DWORD_PTR GetItemData(HTREEITEM hItem) const
        {
                TVITEM item = { 0 };
                item.hItem = hItem;
                item.mask = TVIF_PARAM;
                BOOL bRet = (BOOL)::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)&item);
                return (DWORD_PTR)(bRet ? (DWORD_PTR)item.lParam : (DWORD_PTR)NULL);
        }

        BOOL SetItemData(HTREEITEM hItem, DWORD_PTR dwData)
        {
                return SetItem(hItem, TVIF_PARAM, NULL, 0, 0, 0, 0, (LPARAM)dwData);
        }

        HWND GetEditControl() const
        {
                return ((HWND)::SendMessage(m_hwnd, TVM_GETEDITCONTROL, 0, 0L));
        }
        UINT GetVisibleCount() const
        {
                return (UINT)::SendMessage(m_hwnd, TVM_GETVISIBLECOUNT, 0, 0L);
        }

        BOOL GetItemRect(HTREEITEM hItem, LPRECT lpRect, BOOL bTextOnly) const
        {
                *(HTREEITEM*)lpRect = hItem;
                return (BOOL)::SendMessage(m_hwnd, TVM_GETITEMRECT, (WPARAM)bTextOnly, (LPARAM)lpRect);
        }

        BOOL ItemHasChildren(HTREEITEM hItem) const
        {
                TVITEM item = { 0 };
                item.hItem = hItem;
                item.mask = TVIF_CHILDREN;
                ::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)&item);
                return item.cChildren;
        }

        int GetISearchString(LPTSTR lpstr) const
        {
                return (int)::SendMessage(m_hwnd, TVM_GETISEARCHSTRING, 0, (LPARAM)lpstr);
        }

        // checkboxes only
        BOOL GetCheckState(HTREEITEM hItem) const
        {
                UINT uRet = GetItemState(hItem, TVIS_STATEIMAGEMASK);
                return (uRet >> 12) - 1;
        }

        BOOL SetCheckState(HTREEITEM hItem, BOOL bCheck)
        {
                int nCheck = bCheck ? 2 : 1;   // one based index
                return SetItemState(hItem, INDEXTOSTATEIMAGEMASK(nCheck), TVIS_STATEIMAGEMASK);
        }

#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
        COLORREF GetBkColor() const
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_GETBKCOLOR, 0, 0L);
        }

        COLORREF SetBkColor(COLORREF clr)
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_SETBKCOLOR, 0, (LPARAM)clr);
        }

        COLORREF GetInsertMarkColor() const
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_GETINSERTMARKCOLOR, 0, 0L);
        }

        COLORREF SetInsertMarkColor(COLORREF clr)
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_SETINSERTMARKCOLOR, 0, (LPARAM)clr);
        }

        int GetItemHeight() const
        {
                return (int)::SendMessage(m_hwnd, TVM_GETITEMHEIGHT, 0, 0L);
        }

        int SetItemHeight(int cyHeight)
        {
                return (int)::SendMessage(m_hwnd, TVM_SETITEMHEIGHT, cyHeight, 0L);
        }

        int GetScrollTime() const
        {
                return (int)::SendMessage(m_hwnd, TVM_GETSCROLLTIME, 0, 0L);
        }

        int SetScrollTime(int nScrollTime)
        {
                return (int)::SendMessage(m_hwnd, TVM_SETSCROLLTIME, nScrollTime, 0L);
        }

        COLORREF GetTextColor() const
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_GETTEXTCOLOR, 0, 0L);
        }

        COLORREF SetTextColor(COLORREF clr)
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_SETTEXTCOLOR, 0, (LPARAM)clr);
        }

        BOOL GetUnicodeFormat() const
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_GETUNICODEFORMAT, 0, 0L);
        }

        BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SETUNICODEFORMAT, bUnicode, 0L);
        }
#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)

#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
        COLORREF GetLineColor() const
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_GETLINECOLOR, 0, 0L);
        }

        COLORREF SetLineColor(COLORREF clrNew /*= CLR_DEFAULT*/)
        {
                return (COLORREF)::SendMessage(m_hwnd, TVM_SETLINECOLOR, 0, (LPARAM)clrNew);
        }
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)

#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
        BOOL GetItem(LPTVITEMEX pItem) const
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_GETITEM, 0, (LPARAM)pItem);
        }

        BOOL SetItem(LPTVITEMEX pItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SETITEM, 0, (LPARAM)pItem);
        }
#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)

        DWORD GetExtendedStyle() const
        {
#ifndef TVM_GETEXTENDEDSTYLE
                const UINT TVM_GETEXTENDEDSTYLE = (TV_FIRST + 45);
#endif
                return (DWORD)::SendMessage(m_hwnd, TVM_GETEXTENDEDSTYLE, 0, 0L);
        }

        DWORD SetExtendedStyle(DWORD dwStyle, DWORD dwMask)
        {
#ifndef TVM_SETEXTENDEDSTYLE
                const UINT TVM_SETEXTENDEDSTYLE = (TV_FIRST + 44);
#endif
                return (DWORD)::SendMessage(m_hwnd, TVM_SETEXTENDEDSTYLE, dwMask, dwStyle);
        }

#if (_WIN32_WINNT >= 0x0600)
        BOOL SetAutoScrollInfo(UINT uPixPerSec, UINT uUpdateTime)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SETAUTOSCROLLINFO, (WPARAM)uPixPerSec, (LPARAM)uUpdateTime);
        }

        DWORD GetSelectedCount() const
        {
                return (DWORD)::SendMessage(m_hwnd, TVM_GETSELECTEDCOUNT, 0, 0L);
        }

        BOOL GetItemPartRect(HTREEITEM hItem, TVITEMPART partID, LPRECT lpRect) const
        {
                TVGETITEMPARTRECTINFO gipri = { hItem, lpRect, partID };
                return (BOOL)::SendMessage(m_hwnd, TVM_GETITEMPARTRECT, 0, (LPARAM)&gipri);
        }
#endif // (_WIN32_WINNT >= 0x0600)

// Operations
        HTREEITEM InsertItem(LPTVINSERTSTRUCT lpInsertStruct)
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_INSERTITEM, 0, (LPARAM)lpInsertStruct);
        }

        HTREEITEM InsertItem(LPCTSTR lpszItem, int nImage,
                int nSelectedImage, HTREEITEM hParent, HTREEITEM hInsertAfter)
        {
                return InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE, lpszItem, nImage, nSelectedImage, 0, 0, 0, hParent, hInsertAfter); 
        }

        HTREEITEM InsertItem(LPCTSTR lpszItem, HTREEITEM hParent, HTREEITEM hInsertAfter)
        {
                return InsertItem(TVIF_TEXT, lpszItem, 0, 0, 0, 0, 0, hParent, hInsertAfter);
        }

        HTREEITEM InsertItem(UINT nMask, LPCTSTR lpszItem, int nImage,
                int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam,
                HTREEITEM hParent, HTREEITEM hInsertAfter)
        {
                TVINSERTSTRUCT tvis = { 0 };
                tvis.hParent = hParent;
                tvis.hInsertAfter = hInsertAfter;
                tvis.item.mask = nMask;
                tvis.item.pszText = (LPTSTR) lpszItem;
                tvis.item.iImage = nImage;
                tvis.item.iSelectedImage = nSelectedImage;
                tvis.item.state = nState;
                tvis.item.stateMask = nStateMask;
                tvis.item.lParam = lParam;
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_INSERTITEM, 0, (LPARAM)&tvis);
        }

        BOOL DeleteItem(HTREEITEM hItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_DELETEITEM, 0, (LPARAM)hItem);
        }

        BOOL DeleteAllItems()
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
        }

        BOOL Expand(HTREEITEM hItem, UINT nCode = TVE_EXPAND)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_EXPAND, nCode, (LPARAM)hItem);
        }

        HTREEITEM GetNextItem(HTREEITEM hItem, UINT nCode) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, nCode, (LPARAM)hItem);
        }

        HTREEITEM GetChildItem(HTREEITEM hItem) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem);
        }

        HTREEITEM GetNextSiblingItem(HTREEITEM hItem) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem); 
        }

        HTREEITEM GetPrevSiblingItem(HTREEITEM hItem) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_PREVIOUS, (LPARAM)hItem);
        }

        HTREEITEM GetParentItem(HTREEITEM hItem) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hItem); 
        }

        HTREEITEM GetFirstVisibleItem() const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_FIRSTVISIBLE, 0L);
        }

        HTREEITEM GetNextVisibleItem(HTREEITEM hItem) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_NEXTVISIBLE, (LPARAM)hItem);
        }

        HTREEITEM GetPrevVisibleItem(HTREEITEM hItem) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_PREVIOUSVISIBLE, (LPARAM)hItem);
        }

        HTREEITEM GetSelectedItem() const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_CARET, 0L);
        }

        HTREEITEM GetDropHilightItem() const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_DROPHILITE, 0L);
        }

        HTREEITEM GetRootItem() const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_ROOT, 0L);
        }

#if !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
        HTREEITEM GetLastVisibleItem() const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_LASTVISIBLE, 0L);
        }
#endif // !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)

#if (_WIN32_IE >= 0x0600)
        HTREEITEM GetNextSelectedItem() const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_GETNEXTITEM, TVGN_NEXTSELECTED, 0L);
        }
#endif // (_WIN32_IE >= 0x0600)

        BOOL Select(HTREEITEM hItem, UINT nCode)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SELECTITEM, nCode, (LPARAM)hItem);
        }

        BOOL SelectItem(HTREEITEM hItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hItem);
        }

        BOOL SelectDropTarget(HTREEITEM hItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SELECTITEM, TVGN_DROPHILITE, (LPARAM)hItem);
        }

        BOOL SelectSetFirstVisible(HTREEITEM hItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SELECTITEM, TVGN_FIRSTVISIBLE, (LPARAM)hItem);
        }

        HWND EditLabel(HTREEITEM hItem)
        {
                return ((HWND)::SendMessage(m_hwnd, TVM_EDITLABEL, 0, (LPARAM)hItem));
        }

        BOOL EndEditLabelNow(BOOL bCancel)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_ENDEDITLABELNOW, bCancel, 0L);
        }

        HTREEITEM HitTest(TVHITTESTINFO* pHitTestInfo) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo);
        }

        HTREEITEM HitTest(POINT pt, UINT* pFlags) const
        {
                TVHITTESTINFO hti = { 0 };
                hti.pt = pt;
                HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hwnd, TVM_HITTEST, 0, (LPARAM)&hti);
                if (pFlags != NULL)
                        *pFlags = hti.flags;
                return hTreeItem;
        }

        BOOL SortChildren(HTREEITEM hItem, BOOL bRecurse = FALSE)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SORTCHILDREN, (WPARAM)bRecurse, (LPARAM)hItem);
        }

        BOOL EnsureVisible(HTREEITEM hItem)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_ENSUREVISIBLE, 0, (LPARAM)hItem);
        }

        BOOL SortChildrenCB(LPTVSORTCB pSort, BOOL bRecurse = FALSE)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SORTCHILDRENCB, (WPARAM)bRecurse, (LPARAM)pSort);
        }

        HIMAGELIST RemoveImageList(int nImageList)
        {
                return ((HIMAGELIST)::SendMessage(m_hwnd, TVM_SETIMAGELIST, (WPARAM)nImageList, 0));
        }

        HIMAGELIST CreateDragImage(HTREEITEM hItem)
        {
                return ((HIMAGELIST)::SendMessage(m_hwnd, TVM_CREATEDRAGIMAGE, 0, (LPARAM)hItem));
        }

#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
        BOOL SetInsertMark(HTREEITEM hTreeItem, BOOL bAfter)
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SETINSERTMARK, bAfter, (LPARAM)hTreeItem);
        }

        BOOL RemoveInsertMark()
        {
                return (BOOL)::SendMessage(m_hwnd, TVM_SETINSERTMARK, 0, 0L);
        }
#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)

#if (_WIN32_WINNT >= 0x0501)
        HTREEITEM MapAccIDToHTREEITEM(UINT uID) const
        {
                return (HTREEITEM)::SendMessage(m_hwnd, TVM_MAPACCIDTOHTREEITEM, uID, 0L);
        }

        UINT MapHTREEITEMToAccID(HTREEITEM hTreeItem) const
        {
                return (UINT)::SendMessage(m_hwnd, TVM_MAPHTREEITEMTOACCID, (WPARAM)hTreeItem, 0L);
        }
#endif // (_WIN32_WINNT >= 0x0501)

#if (_WIN32_WINNT >= 0x0600)
        void ShowInfoTip(HTREEITEM hItem)
        {
                ::SendMessage(m_hwnd, TVM_SHOWINFOTIP, 0, (LPARAM)hItem);
        }
#endif // (_WIN32_WINNT >= 0x0600)
};

}
}

#endif