Show atlctrls.h syntax highlighted
// Windows Template Library - WTL version 8.0
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// This file is a part of the Windows Template Library.
// The use and distribution terms for this software are covered by the
// Common Public License 1.0 (http://opensource.org/licenses/cpl.php)
// which can be found in the file CPL.TXT at the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by
// the terms of this license. You must not remove this notice, or
// any other, from this software.
#ifndef __ATLCTRLS_H__
#define __ATLCTRLS_H__
#pragma once
#ifndef __cplusplus
#error ATL requires C++ compilation (use a .cpp suffix)
#endif
#ifndef __ATLAPP_H__
#error atlctrls.h requires atlapp.h to be included first
#endif
#ifndef __ATLWIN_H__
#error atlctrls.h requires atlwin.h to be included first
#endif
#if (_WIN32_IE < 0x0300)
#error atlctrls.h requires IE Version 3.0 or higher
#endif
#ifndef _WIN32_WCE
#include <richedit.h>
#include <richole.h>
#elif defined(WIN32_PLATFORM_WFSP) && !defined(_WINUSERM_H_)
#include <winuserm.h>
#endif // !_WIN32_WCE
// protect template members from windowsx.h macros
#ifdef _INC_WINDOWSX
#undef GetNextSibling
#undef GetPrevSibling
#endif // _INC_WINDOWSX
///////////////////////////////////////////////////////////////////////////////
// Classes in this file:
//
// CStaticT<TBase> - CStatic
// CButtonT<TBase> - CButton
// CListBoxT<TBase> - CListBox
// CComboBoxT<TBase> - CComboBox
// CEditT<TBase> - CEdit
// CEditCommands<T>
// CScrollBarT<TBase> - CScrollBar
//
// CImageList
// CListViewCtrlT<TBase> - CListViewCtrl
// CTreeViewCtrlT<TBase> - CTreeViewCtrl
// CTreeItemT<TBase> - CTreeItem
// CTreeViewCtrlExT<TBase> - CTreeViewCtrlEx
// CHeaderCtrlT<TBase> - CHeaderCtrl
// CToolBarCtrlT<TBase> - CToolBarCtrl
// CStatusBarCtrlT<TBase> - CStatusBarCtrl
// CTabCtrlT<TBase> - CTabCtrl
// CToolInfo
// CToolTipCtrlT<TBase> - CToolTipCtrl
// CTrackBarCtrlT<TBase> - CTrackBarCtrl
// CUpDownCtrlT<TBase> - CUpDownCtrl
// CProgressBarCtrlT<TBase> - CProgressBarCtrl
// CHotKeyCtrlT<TBase> - CHotKeyCtrl
// CAnimateCtrlT<TBase> - CAnimateCtrl
// CRichEditCtrlT<TBase> - CRichEditCtrl
// CRichEditCommands<T>
// CDragListBoxT<TBase> - CDragListBox
// CDragListNotifyImpl<T>
// CReBarCtrlT<TBase> - CReBarCtrl
// CComboBoxExT<TBase> - CComboBoxEx
// CDateTimePickerCtrlT<TBase> - CDateTimePickerCtrl
// CMonthCalendarCtrlT<TBase> - CMonthCalendarCtrl
// CFlatScrollBarImpl<T>
// CFlatScrollBarT<TBase> - CFlatScrollBar
// CIPAddressCtrlT<TBase> - CIPAddressCtrl
// CPagerCtrlT<TBase> - CPagerCtrl
// CLinkCtrlT<TBase> - CLinkCtrl
//
// CCustomDraw<T>
//
// CCECommandBarCtrlT<TBase> - CCECommandBarCtrl
// CCECommandBandsCtrlT<TBase> - CCECommandBandsCtrl
namespace WTL
{
// These are wrapper classes for Windows standard and common controls.
// To implement a window based on a control, use following:
// Example: Implementing a window based on a list box
//
// class CMyListBox : CWindowImpl<CMyListBox, CListBox>
// {
// public:
// BEGIN_MSG_MAP(CMyListBox)
// // put your message handler entries here
// END_MSG_MAP()
// };
// --- Standard Windows controls ---
///////////////////////////////////////////////////////////////////////////////
// CStatic - client side for a Windows STATIC control
template <class TBase>
class CStaticT : public TBase
{
public:
// Constructors
CStaticT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CStaticT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 _T("STATIC");
}
#ifndef _WIN32_WCE
HICON GetIcon() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HICON)::SendMessage(m_hWnd, STM_GETICON, 0, 0L);
}
HICON SetIcon(HICON hIcon)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HICON)::SendMessage(m_hWnd, STM_SETICON, (WPARAM)hIcon, 0L);
}
HENHMETAFILE GetEnhMetaFile() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HENHMETAFILE)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_ENHMETAFILE, 0L);
}
HENHMETAFILE SetEnhMetaFile(HENHMETAFILE hMetaFile)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HENHMETAFILE)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_ENHMETAFILE, (LPARAM)hMetaFile);
}
#else // CE specific
HICON GetIcon() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HICON)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_ICON, 0L);
}
HICON SetIcon(HICON hIcon)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HICON)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
}
#endif // _WIN32_WCE
CBitmapHandle GetBitmap() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_BITMAP, 0L));
}
CBitmapHandle SetBitmap(HBITMAP hBitmap)
{
ATLASSERT(::IsWindow(m_hWnd));
return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hBitmap));
}
HCURSOR GetCursor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HCURSOR)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_CURSOR, 0L);
}
HCURSOR SetCursor(HCURSOR hCursor)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HCURSOR)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_CURSOR, (LPARAM)hCursor);
}
};
typedef CStaticT<ATL::CWindow> CStatic;
///////////////////////////////////////////////////////////////////////////////
// CButton - client side for a Windows BUTTON control
template <class TBase>
class CButtonT : public TBase
{
public:
// Constructors
CButtonT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CButtonT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 _T("BUTTON");
}
UINT GetState() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, BM_GETSTATE, 0, 0L);
}
void SetState(BOOL bHighlight)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, BM_SETSTATE, bHighlight, 0L);
}
int GetCheck() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, BM_GETCHECK, 0, 0L);
}
void SetCheck(int nCheck)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, BM_SETCHECK, nCheck, 0L);
}
UINT GetButtonStyle() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::GetWindowLong(m_hWnd, GWL_STYLE) & 0xFFFF;
}
void SetButtonStyle(UINT nStyle, BOOL bRedraw = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, BM_SETSTYLE, nStyle, (LPARAM)bRedraw);
}
#ifndef _WIN32_WCE
HICON GetIcon() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HICON)::SendMessage(m_hWnd, BM_GETIMAGE, IMAGE_ICON, 0L);
}
HICON SetIcon(HICON hIcon)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HICON)::SendMessage(m_hWnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
}
CBitmapHandle GetBitmap() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, BM_GETIMAGE, IMAGE_BITMAP, 0L));
}
CBitmapHandle SetBitmap(HBITMAP hBitmap)
{
ATLASSERT(::IsWindow(m_hWnd));
return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hBitmap));
}
#endif // !_WIN32_WCE
#if (_WIN32_WINNT >= 0x0501)
BOOL GetIdealSize(LPSIZE lpSize) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, BCM_GETIDEALSIZE, 0, (LPARAM)lpSize);
}
BOOL GetImageList(PBUTTON_IMAGELIST pButtonImagelist) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, BCM_GETIMAGELIST, 0, (LPARAM)pButtonImagelist);
}
BOOL SetImageList(PBUTTON_IMAGELIST pButtonImagelist)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, BCM_SETIMAGELIST, 0, (LPARAM)pButtonImagelist);
}
BOOL GetTextMargin(LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, BCM_GETTEXTMARGIN, 0, (LPARAM)lpRect);
}
BOOL SetTextMargin(LPRECT lpRect)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, BCM_SETTEXTMARGIN, 0, (LPARAM)lpRect);
}
#endif // (_WIN32_WINNT >= 0x0501)
// Operations
void Click()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, BM_CLICK, 0, 0L);
}
};
typedef CButtonT<ATL::CWindow> CButton;
///////////////////////////////////////////////////////////////////////////////
// CListBox - client side for a Windows LISTBOX control
template <class TBase>
class CListBoxT : public TBase
{
public:
// Constructors
CListBoxT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CListBoxT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 _T("LISTBOX");
}
// for entire listbox
int GetCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETCOUNT, 0, 0L);
}
#ifndef _WIN32_WCE
int SetCount(int cItems)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(((GetStyle() & LBS_NODATA) != 0) && ((GetStyle() & LBS_HASSTRINGS) == 0));
return (int)::SendMessage(m_hWnd, LB_SETCOUNT, cItems, 0L);
}
#endif // !_WIN32_WCE
int GetHorizontalExtent() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETHORIZONTALEXTENT, 0, 0L);
}
void SetHorizontalExtent(int cxExtent)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LB_SETHORIZONTALEXTENT, cxExtent, 0L);
}
int GetTopIndex() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETTOPINDEX, 0, 0L);
}
int SetTopIndex(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_SETTOPINDEX, nIndex, 0L);
}
LCID GetLocale() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (LCID)::SendMessage(m_hWnd, LB_GETLOCALE, 0, 0L);
}
LCID SetLocale(LCID nNewLocale)
{
ATLASSERT(::IsWindow(m_hWnd));
return (LCID)::SendMessage(m_hWnd, LB_SETLOCALE, (WPARAM)nNewLocale, 0L);
}
#if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
DWORD GetListBoxInfo() const
{
ATLASSERT(::IsWindow(m_hWnd));
#if (_WIN32_WINNT >= 0x0501)
return (DWORD)::SendMessage(m_hWnd, LB_GETLISTBOXINFO, 0, 0L);
#else // !(_WIN32_WINNT >= 0x0501)
return ::GetListBoxInfo(m_hWnd);
#endif // !(_WIN32_WINNT >= 0x0501)
}
#endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
// for single-selection listboxes
int GetCurSel() const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) == 0);
return (int)::SendMessage(m_hWnd, LB_GETCURSEL, 0, 0L);
}
int SetCurSel(int nSelect)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) == 0);
return (int)::SendMessage(m_hWnd, LB_SETCURSEL, nSelect, 0L);
}
// for multiple-selection listboxes
int GetSel(int nIndex) const // also works for single-selection
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETSEL, nIndex, 0L);
}
int SetSel(int nIndex, BOOL bSelect = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
return (int)::SendMessage(m_hWnd, LB_SETSEL, bSelect, nIndex);
}
int GetSelCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
return (int)::SendMessage(m_hWnd, LB_GETSELCOUNT, 0, 0L);
}
int GetSelItems(int nMaxItems, LPINT rgIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
return (int)::SendMessage(m_hWnd, LB_GETSELITEMS, nMaxItems, (LPARAM)rgIndex);
}
int GetAnchorIndex() const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
return (int)::SendMessage(m_hWnd, LB_GETANCHORINDEX, 0, 0L);
}
void SetAnchorIndex(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
::SendMessage(m_hWnd, LB_SETANCHORINDEX, nIndex, 0L);
}
int GetCaretIndex() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETCARETINDEX, 0, 0);
}
int SetCaretIndex(int nIndex, BOOL bScroll = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_SETCARETINDEX, nIndex, MAKELONG(bScroll, 0));
}
// for listbox items
DWORD_PTR GetItemData(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD_PTR)::SendMessage(m_hWnd, LB_GETITEMDATA, nIndex, 0L);
}
int SetItemData(int nIndex, DWORD_PTR dwItemData)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_SETITEMDATA, nIndex, (LPARAM)dwItemData);
}
void* GetItemDataPtr(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (void*)::SendMessage(m_hWnd, LB_GETITEMDATA, nIndex, 0L);
}
int SetItemDataPtr(int nIndex, void* pData)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItemData(nIndex, (DWORD_PTR)pData);
}
int GetItemRect(int nIndex, LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETITEMRECT, nIndex, (LPARAM)lpRect);
}
int GetText(int nIndex, LPTSTR lpszBuffer) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETTEXT, nIndex, (LPARAM)lpszBuffer);
}
#ifndef _ATL_NO_COM
#ifdef _OLEAUTO_H_
BOOL GetTextBSTR(int nIndex, BSTR& bstrText) const
{
USES_CONVERSION;
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(bstrText == NULL);
int nLen = GetTextLen(nIndex);
if(nLen == LB_ERR)
return FALSE;
LPTSTR lpszText = (LPTSTR)_alloca((nLen + 1) * sizeof(TCHAR));
if(GetText(nIndex, lpszText) == LB_ERR)
return FALSE;
bstrText = ::SysAllocString(T2OLE(lpszText));
return (bstrText != NULL) ? TRUE : FALSE;
}
#endif // _OLEAUTO_H_
#endif // !_ATL_NO_COM
#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
int GetText(int nIndex, _CSTRING_NS::CString& strText) const
{
ATLASSERT(::IsWindow(m_hWnd));
int cchLen = GetTextLen(nIndex);
if(cchLen == LB_ERR)
return LB_ERR;
int nRet = LB_ERR;
LPTSTR lpstr = strText.GetBufferSetLength(cchLen);
if(lpstr != NULL)
{
nRet = GetText(nIndex, lpstr);
strText.ReleaseBuffer();
}
return nRet;
}
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
int GetTextLen(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETTEXTLEN, nIndex, 0L);
}
int GetItemHeight(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_GETITEMHEIGHT, nIndex, 0L);
}
int SetItemHeight(int nIndex, UINT cyItemHeight)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_SETITEMHEIGHT, nIndex, MAKELONG(cyItemHeight, 0));
}
// Settable only attributes
void SetColumnWidth(int cxWidth)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LB_SETCOLUMNWIDTH, cxWidth, 0L);
}
BOOL SetTabStops(int nTabStops, LPINT rgTabStops)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LBS_USETABSTOPS) != 0);
return (BOOL)::SendMessage(m_hWnd, LB_SETTABSTOPS, nTabStops, (LPARAM)rgTabStops);
}
BOOL SetTabStops()
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LBS_USETABSTOPS) != 0);
return (BOOL)::SendMessage(m_hWnd, LB_SETTABSTOPS, 0, 0L);
}
BOOL SetTabStops(const int& cxEachStop) // takes an 'int'
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LBS_USETABSTOPS) != 0);
return (BOOL)::SendMessage(m_hWnd, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)&cxEachStop);
}
// Operations
int InitStorage(int nItems, UINT nBytes)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_INITSTORAGE, (WPARAM)nItems, nBytes);
}
void ResetContent()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LB_RESETCONTENT, 0, 0L);
}
UINT ItemFromPoint(POINT pt, BOOL& bOutside) const
{
ATLASSERT(::IsWindow(m_hWnd));
DWORD dw = (DWORD)::SendMessage(m_hWnd, LB_ITEMFROMPOINT, 0, MAKELPARAM(pt.x, pt.y));
bOutside = (BOOL)HIWORD(dw);
return (UINT)LOWORD(dw);
}
// manipulating listbox items
int AddString(LPCTSTR lpszItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_ADDSTRING, 0, (LPARAM)lpszItem);
}
int DeleteString(UINT nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_DELETESTRING, nIndex, 0L);
}
int InsertString(int nIndex, LPCTSTR lpszItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_INSERTSTRING, nIndex, (LPARAM)lpszItem);
}
#ifndef _WIN32_WCE
int Dir(UINT attr, LPCTSTR lpszWildCard)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_DIR, attr, (LPARAM)lpszWildCard);
}
int AddFile(LPCTSTR lpstrFileName)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_ADDFILE, 0, (LPARAM)lpstrFileName);
}
#endif // !_WIN32_WCE
// selection helpers
int FindString(int nStartAfter, LPCTSTR lpszItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_FINDSTRING, nStartAfter, (LPARAM)lpszItem);
}
int FindStringExact(int nIndexStart, LPCTSTR lpszFind) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_FINDSTRINGEXACT, nIndexStart, (LPARAM)lpszFind);
}
int SelectString(int nStartAfter, LPCTSTR lpszItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LB_SELECTSTRING, nStartAfter, (LPARAM)lpszItem);
}
int SelItemRange(BOOL bSelect, int nFirstItem, int nLastItem)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
ATLASSERT(nFirstItem <= nLastItem);
return bSelect ? (int)::SendMessage(m_hWnd, LB_SELITEMRANGEEX, nFirstItem, nLastItem) : (int)::SendMessage(m_hWnd, LB_SELITEMRANGEEX, nLastItem, nFirstItem);
}
#ifdef WIN32_PLATFORM_WFSP // SmartPhone only messages
DWORD GetInputMode(BOOL bCurrentMode = TRUE)
{
return SendMessage(LB_GETINPUTMODE, 0, (LPARAM)bCurrentMode);
}
BOOL SetInputMode(DWORD dwMode)
{
return SendMessage(LB_SETINPUTMODE, 0, (LPARAM)dwMode);
}
#endif // WIN32_PLATFORM_WFSP
};
typedef CListBoxT<ATL::CWindow> CListBox;
///////////////////////////////////////////////////////////////////////////////
// CComboBox - client side for a Windows COMBOBOX control
template <class TBase>
class CComboBoxT : public TBase
{
public:
// Constructors
CComboBoxT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CComboBoxT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 _T("COMBOBOX");
}
// for entire combo box
int GetCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETCOUNT, 0, 0L);
}
int GetCurSel() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETCURSEL, 0, 0L);
}
int SetCurSel(int nSelect)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETCURSEL, nSelect, 0L);
}
LCID GetLocale() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (LCID)::SendMessage(m_hWnd, CB_GETLOCALE, 0, 0L);
}
LCID SetLocale(LCID nNewLocale)
{
ATLASSERT(::IsWindow(m_hWnd));
return (LCID)::SendMessage(m_hWnd, CB_SETLOCALE, (WPARAM)nNewLocale, 0L);
}
int GetTopIndex() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETTOPINDEX, 0, 0L);
}
int SetTopIndex(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETTOPINDEX, nIndex, 0L);
}
UINT GetHorizontalExtent() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, CB_GETHORIZONTALEXTENT, 0, 0L);
}
void SetHorizontalExtent(UINT nExtent)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, CB_SETHORIZONTALEXTENT, nExtent, 0L);
}
int GetDroppedWidth() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETDROPPEDWIDTH, 0, 0L);
}
int SetDroppedWidth(UINT nWidth)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETDROPPEDWIDTH, nWidth, 0L);
}
#if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
BOOL GetComboBoxInfo(PCOMBOBOXINFO pComboBoxInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
#if (_WIN32_WINNT >= 0x0501)
return (BOOL)::SendMessage(m_hWnd, CB_GETCOMBOBOXINFO, 0, (LPARAM)pComboBoxInfo);
#else // !(_WIN32_WINNT >= 0x0501)
return ::GetComboBoxInfo(m_hWnd, pComboBoxInfo);
#endif // !(_WIN32_WINNT >= 0x0501)
}
#endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
// for edit control
DWORD GetEditSel() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, CB_GETEDITSEL, 0, 0L);
}
BOOL SetEditSel(int nStartChar, int nEndChar)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, CB_SETEDITSEL, 0, MAKELONG(nStartChar, nEndChar));
}
// for combobox item
DWORD_PTR GetItemData(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD_PTR)::SendMessage(m_hWnd, CB_GETITEMDATA, nIndex, 0L);
}
int SetItemData(int nIndex, DWORD_PTR dwItemData)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETITEMDATA, nIndex, (LPARAM)dwItemData);
}
void* GetItemDataPtr(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (void*)GetItemData(nIndex);
}
int SetItemDataPtr(int nIndex, void* pData)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItemData(nIndex, (DWORD_PTR)pData);
}
int GetLBText(int nIndex, LPTSTR lpszText) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETLBTEXT, nIndex, (LPARAM)lpszText);
}
#ifndef _ATL_NO_COM
BOOL GetLBTextBSTR(int nIndex, BSTR& bstrText) const
{
USES_CONVERSION;
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(bstrText == NULL);
int nLen = GetLBTextLen(nIndex);
if(nLen == CB_ERR)
return FALSE;
LPTSTR lpszText = (LPTSTR)_alloca((nLen + 1) * sizeof(TCHAR));
if(GetLBText(nIndex, lpszText) == CB_ERR)
return FALSE;
bstrText = ::SysAllocString(T2OLE(lpszText));
return (bstrText != NULL) ? TRUE : FALSE;
}
#endif // !_ATL_NO_COM
#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
int GetLBText(int nIndex, _CSTRING_NS::CString& strText) const
{
ATLASSERT(::IsWindow(m_hWnd));
int cchLen = GetLBTextLen(nIndex);
if(cchLen == CB_ERR)
return CB_ERR;
int nRet = CB_ERR;
LPTSTR lpstr = strText.GetBufferSetLength(cchLen);
if(lpstr != NULL)
{
nRet = GetLBText(nIndex, lpstr);
strText.ReleaseBuffer();
}
return nRet;
}
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
int GetLBTextLen(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETLBTEXTLEN, nIndex, 0L);
}
int GetItemHeight(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETITEMHEIGHT, nIndex, 0L);
}
int SetItemHeight(int nIndex, UINT cyItemHeight)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETITEMHEIGHT, nIndex, MAKELONG(cyItemHeight, 0));
}
BOOL GetExtendedUI() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, CB_GETEXTENDEDUI, 0, 0L);
}
int SetExtendedUI(BOOL bExtended = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SETEXTENDEDUI, bExtended, 0L);
}
void GetDroppedControlRect(LPRECT lprect) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, CB_GETDROPPEDCONTROLRECT, 0, (LPARAM)lprect);
}
BOOL GetDroppedState() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, CB_GETDROPPEDSTATE, 0, 0L);
}
#if (_WIN32_WINNT >= 0x0501)
int GetMinVisible() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_GETMINVISIBLE, 0, 0L);
}
BOOL SetMinVisible(int nMinVisible)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, CB_SETMINVISIBLE, nMinVisible, 0L);
}
#endif // (_WIN32_WINNT >= 0x0501)
// Operations
int InitStorage(int nItems, UINT nBytes)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_INITSTORAGE, (WPARAM)nItems, nBytes);
}
void ResetContent()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, CB_RESETCONTENT, 0, 0L);
}
// for edit control
BOOL LimitText(int nMaxChars)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, CB_LIMITTEXT, nMaxChars, 0L);
}
// for drop-down combo boxes
void ShowDropDown(BOOL bShowIt = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, CB_SHOWDROPDOWN, bShowIt, 0L);
}
// manipulating listbox items
int AddString(LPCTSTR lpszString)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_ADDSTRING, 0, (LPARAM)lpszString);
}
int DeleteString(UINT nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_DELETESTRING, nIndex, 0L);
}
int InsertString(int nIndex, LPCTSTR lpszString)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_INSERTSTRING, nIndex, (LPARAM)lpszString);
}
#ifndef _WIN32_WCE
int Dir(UINT attr, LPCTSTR lpszWildCard)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_DIR, attr, (LPARAM)lpszWildCard);
}
#endif // !_WIN32_WCE
// selection helpers
int FindString(int nStartAfter, LPCTSTR lpszString) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_FINDSTRING, nStartAfter, (LPARAM)lpszString);
}
int FindStringExact(int nIndexStart, LPCTSTR lpszFind) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_FINDSTRINGEXACT, nIndexStart, (LPARAM)lpszFind);
}
int SelectString(int nStartAfter, LPCTSTR lpszString)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, CB_SELECTSTRING, nStartAfter, (LPARAM)lpszString);
}
// Clipboard operations
void Clear()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
}
void Copy()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_COPY, 0, 0L);
}
void Cut()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_CUT, 0, 0L);
}
void Paste()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
}
};
typedef CComboBoxT<ATL::CWindow> CComboBox;
///////////////////////////////////////////////////////////////////////////////
// CEdit - client side for a Windows EDIT control
template <class TBase>
class CEditT : public TBase
{
public:
// Constructors
CEditT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CEditT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 _T("EDIT");
}
BOOL CanUndo() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L);
}
int GetLineCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, EM_GETLINECOUNT, 0, 0L);
}
BOOL GetModify() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L);
}
void SetModify(BOOL bModified = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETMODIFY, bModified, 0L);
}
void GetRect(LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_GETRECT, 0, (LPARAM)lpRect);
}
DWORD GetSel() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, EM_GETSEL, 0, 0L);
}
void GetSel(int& nStartChar, int& nEndChar) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_GETSEL, (WPARAM)&nStartChar, (LPARAM)&nEndChar);
}
#ifndef _WIN32_WCE
HLOCAL GetHandle() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HLOCAL)::SendMessage(m_hWnd, EM_GETHANDLE, 0, 0L);
}
void SetHandle(HLOCAL hBuffer)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETHANDLE, (WPARAM)hBuffer, 0L);
}
#endif // !_WIN32_WCE
DWORD GetMargins() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, EM_GETMARGINS, 0, 0L);
}
void SetMargins(UINT nLeft, UINT nRight)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETMARGINS, EC_LEFTMARGIN|EC_RIGHTMARGIN, MAKELONG(nLeft, nRight));
}
UINT GetLimitText() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, EM_GETLIMITTEXT, 0, 0L);
}
void SetLimitText(UINT nMax)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETLIMITTEXT, nMax, 0L);
}
POINT PosFromChar(UINT nChar) const
{
ATLASSERT(::IsWindow(m_hWnd));
DWORD dwRet = (DWORD)::SendMessage(m_hWnd, EM_POSFROMCHAR, nChar, 0);
POINT point = { GET_X_LPARAM(dwRet), GET_Y_LPARAM(dwRet) };
return point;
}
int CharFromPos(POINT pt, int* pLine = NULL) const
{
ATLASSERT(::IsWindow(m_hWnd));
DWORD dwRet = (DWORD)::SendMessage(m_hWnd, EM_CHARFROMPOS, 0, MAKELPARAM(pt.x, pt.y));
if(pLine != NULL)
*pLine = (int)(short)HIWORD(dwRet);
return (int)(short)LOWORD(dwRet);
}
// NOTE: first word in lpszBuffer must contain the size of the buffer!
int GetLine(int nIndex, LPTSTR lpszBuffer) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
}
int GetLine(int nIndex, LPTSTR lpszBuffer, int nMaxLength) const
{
ATLASSERT(::IsWindow(m_hWnd));
*(LPWORD)lpszBuffer = (WORD)nMaxLength;
return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
}
TCHAR GetPasswordChar() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (TCHAR)::SendMessage(m_hWnd, EM_GETPASSWORDCHAR, 0, 0L);
}
void SetPasswordChar(TCHAR ch)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETPASSWORDCHAR, ch, 0L);
}
#ifndef _WIN32_WCE
EDITWORDBREAKPROC GetWordBreakProc() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (EDITWORDBREAKPROC)::SendMessage(m_hWnd, EM_GETWORDBREAKPROC, 0, 0L);
}
void SetWordBreakProc(EDITWORDBREAKPROC ewbprc)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETWORDBREAKPROC, 0, (LPARAM)ewbprc);
}
#endif // !_WIN32_WCE
int GetFirstVisibleLine() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L);
}
#ifndef _WIN32_WCE
int GetThumb() const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & ES_MULTILINE) != 0);
return (int)::SendMessage(m_hWnd, EM_GETTHUMB, 0, 0L);
}
#endif // !_WIN32_WCE
BOOL SetReadOnly(BOOL bReadOnly = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_SETREADONLY, bReadOnly, 0L);
}
#if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
UINT GetImeStatus(UINT uStatus) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, EM_GETIMESTATUS, uStatus, 0L);
}
UINT SetImeStatus(UINT uStatus, UINT uData)
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, EM_SETIMESTATUS, uStatus, uData);
}
#endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
#if (_WIN32_WINNT >= 0x0501)
BOOL GetCueBannerText(LPCWSTR lpstrText, int cchText) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_GETCUEBANNER, (WPARAM)lpstrText, cchText);
}
BOOL SetCueBannerText(LPCWSTR lpstrText)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_SETCUEBANNER, 0, (LPARAM)(lpstrText));
}
#endif // (_WIN32_WINNT >= 0x0501)
// Operations
void EmptyUndoBuffer()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_EMPTYUNDOBUFFER, 0, 0L);
}
BOOL FmtLines(BOOL bAddEOL)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_FMTLINES, bAddEOL, 0L);
}
void LimitText(int nChars = 0)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_LIMITTEXT, nChars, 0L);
}
int LineFromChar(int nIndex = -1) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, EM_LINEFROMCHAR, nIndex, 0L);
}
int LineIndex(int nLine = -1) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, EM_LINEINDEX, nLine, 0L);
}
int LineLength(int nLine = -1) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, EM_LINELENGTH, nLine, 0L);
}
void LineScroll(int nLines, int nChars = 0)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_LINESCROLL, nChars, nLines);
}
void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpszNewText);
}
void SetRect(LPCRECT lpRect)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETRECT, 0, (LPARAM)lpRect);
}
void SetRectNP(LPCRECT lpRect)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETRECTNP, 0, (LPARAM)lpRect);
}
void SetSel(DWORD dwSelection, BOOL bNoScroll = FALSE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETSEL, LOWORD(dwSelection), HIWORD(dwSelection));
if(!bNoScroll)
::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
}
void SetSel(int nStartChar, int nEndChar, BOOL bNoScroll = FALSE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SETSEL, nStartChar, nEndChar);
if(!bNoScroll)
::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
}
void SetSelAll(BOOL bNoScroll = FALSE)
{
SetSel(0, -1, bNoScroll);
}
void SetSelNone(BOOL bNoScroll = FALSE)
{
SetSel(-1, 0, bNoScroll);
}
BOOL SetTabStops(int nTabStops, LPINT rgTabStops)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, nTabStops, (LPARAM)rgTabStops);
}
BOOL SetTabStops()
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 0, 0L);
}
BOOL SetTabStops(const int& cxEachStop) // takes an 'int'
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 1, (LPARAM)(LPINT)&cxEachStop);
}
void ScrollCaret()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
}
int Scroll(int nScrollAction)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & ES_MULTILINE) != 0);
LRESULT lRet = ::SendMessage(m_hWnd, EM_SCROLL, nScrollAction, 0L);
if(!(BOOL)HIWORD(lRet))
return -1; // failed
return (int)(short)LOWORD(lRet);
}
void InsertText(int nInsertAfterChar, LPCTSTR lpstrText, BOOL bNoScroll = FALSE, BOOL bCanUndo = FALSE)
{
SetSel(nInsertAfterChar, nInsertAfterChar, bNoScroll);
ReplaceSel(lpstrText, bCanUndo);
}
void AppendText(LPCTSTR lpstrText, BOOL bNoScroll = FALSE, BOOL bCanUndo = FALSE)
{
InsertText(GetWindowTextLength(), lpstrText, bNoScroll, bCanUndo);
}
#if (_WIN32_WINNT >= 0x0501)
BOOL ShowBalloonTip(PEDITBALLOONTIP pEditBaloonTip)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_SHOWBALLOONTIP, 0, (LPARAM)pEditBaloonTip);
}
BOOL HideBalloonTip()
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_HIDEBALLOONTIP, 0, 0L);
}
#endif // (_WIN32_WINNT >= 0x0501)
// Clipboard operations
BOOL Undo()
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, EM_UNDO, 0, 0L);
}
void Clear()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
}
void Copy()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_COPY, 0, 0L);
}
void Cut()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_CUT, 0, 0L);
}
void Paste()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
}
#ifdef WIN32_PLATFORM_WFSP // SmartPhone only messages
DWORD GetExtendedStyle()
{
return SendMessage(EM_GETEXTENDEDSTYLE);
}
DWORD SetExtendedStyle(DWORD dwMask, DWORD dwExStyle)
{
return SendMessage(EM_SETEXTENDEDSTYLE, (WPARAM)dwMask, (LPARAM)dwExStyle);
}
DWORD GetInputMode(BOOL bCurrentMode = TRUE)
{
return SendMessage(EM_GETINPUTMODE, 0, (LPARAM)bCurrentMode);
}
BOOL SetInputMode(DWORD dwMode)
{
return SendMessage(EM_SETINPUTMODE, 0, (LPARAM)dwMode);
}
BOOL SetSymbols(LPCTSTR szSymbols)
{
return SendMessage(EM_SETSYMBOLS, 0, (LPARAM)szSymbols);
}
BOOL ResetSymbols()
{
return SendMessage(EM_SETSYMBOLS);
}
#endif // WIN32_PLATFORM_WFSP
};
typedef CEditT<ATL::CWindow> CEdit;
///////////////////////////////////////////////////////////////////////////////
// CEditCommands - message handlers for standard EDIT commands
// Chain to CEditCommands message map. Your class must also derive from CEdit.
// Example:
// class CMyEdit : public CWindowImpl<CMyEdit, CEdit>,
// public CEditCommands<CMyEdit>
// {
// public:
// BEGIN_MSG_MAP(CMyEdit)
// // your handlers...
// CHAIN_MSG_MAP_ALT(CEditCommands<CMyEdit>, 1)
// END_MSG_MAP()
// // other stuff...
// };
template <class T>
class CEditCommands
{
public:
BEGIN_MSG_MAP(CEditCommands< T >)
ALT_MSG_MAP(1)
COMMAND_ID_HANDLER(ID_EDIT_CLEAR, OnEditClear)
COMMAND_ID_HANDLER(ID_EDIT_CLEAR_ALL, OnEditClearAll)
COMMAND_ID_HANDLER(ID_EDIT_COPY, OnEditCopy)
COMMAND_ID_HANDLER(ID_EDIT_CUT, OnEditCut)
COMMAND_ID_HANDLER(ID_EDIT_PASTE, OnEditPaste)
COMMAND_ID_HANDLER(ID_EDIT_SELECT_ALL, OnEditSelectAll)
COMMAND_ID_HANDLER(ID_EDIT_UNDO, OnEditUndo)
END_MSG_MAP()
LRESULT OnEditClear(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->Clear();
return 0;
}
LRESULT OnEditClearAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->SetSel(0, -1);
pT->Clear();
return 0;
}
LRESULT OnEditCopy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->Copy();
return 0;
}
LRESULT OnEditCut(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->Cut();
return 0;
}
LRESULT OnEditPaste(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->Paste();
return 0;
}
LRESULT OnEditSelectAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->SetSel(0, -1);
return 0;
}
LRESULT OnEditUndo(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
T* pT = static_cast<T*>(this);
pT->Undo();
return 0;
}
// State (update UI) helpers
BOOL CanCut() const
{ return HasSelection(); }
BOOL CanCopy() const
{ return HasSelection(); }
BOOL CanClear() const
{ return HasSelection(); }
BOOL CanSelectAll() const
{ return HasText(); }
BOOL CanFind() const
{ return HasText(); }
BOOL CanRepeat() const
{ return HasText(); }
BOOL CanReplace() const
{ return HasText(); }
BOOL CanClearAll() const
{ return HasText(); }
// Implementation
BOOL HasSelection() const
{
const T* pT = static_cast<const T*>(this);
int nMin, nMax;
::SendMessage(pT->m_hWnd, EM_GETSEL, (WPARAM)&nMin, (LPARAM)&nMax);
return (nMin != nMax);
}
BOOL HasText() const
{
const T* pT = static_cast<const T*>(this);
return (pT->GetWindowTextLength() > 0);
}
};
///////////////////////////////////////////////////////////////////////////////
// CScrollBar - client side for a Windows SCROLLBAR control
template <class TBase>
class CScrollBarT : public TBase
{
public:
// Constructors
CScrollBarT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CScrollBarT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 _T("SCROLLBAR");
}
#ifndef _WIN32_WCE
int GetScrollPos() const
{
ATLASSERT(::IsWindow(m_hWnd));
return ::GetScrollPos(m_hWnd, SB_CTL);
}
#endif // !_WIN32_WCE
int SetScrollPos(int nPos, BOOL bRedraw = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return ::SetScrollPos(m_hWnd, SB_CTL, nPos, bRedraw);
}
#ifndef _WIN32_WCE
void GetScrollRange(LPINT lpMinPos, LPINT lpMaxPos) const
{
ATLASSERT(::IsWindow(m_hWnd));
::GetScrollRange(m_hWnd, SB_CTL, lpMinPos, lpMaxPos);
}
#endif // !_WIN32_WCE
void SetScrollRange(int nMinPos, int nMaxPos, BOOL bRedraw = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
::SetScrollRange(m_hWnd, SB_CTL, nMinPos, nMaxPos, bRedraw);
}
BOOL GetScrollInfo(LPSCROLLINFO lpScrollInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return ::GetScrollInfo(m_hWnd, SB_CTL, lpScrollInfo);
}
int SetScrollInfo(LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return ::SetScrollInfo(m_hWnd, SB_CTL, lpScrollInfo, bRedraw);
}
#ifndef _WIN32_WCE
int GetScrollLimit() const
{
int nMin = 0, nMax = 0;
::GetScrollRange(m_hWnd, SB_CTL, &nMin, &nMax);
SCROLLINFO info = { 0 };
info.cbSize = sizeof(SCROLLINFO);
info.fMask = SIF_PAGE;
if(::GetScrollInfo(m_hWnd, SB_CTL, &info))
nMax -= ((info.nPage - 1) > 0) ? (info.nPage - 1) : 0;
return nMax;
}
#if (WINVER >= 0x0500)
BOOL GetScrollBarInfo(PSCROLLBARINFO pScrollBarInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
#if (_WIN32_WINNT >= 0x0501)
return (BOOL)::SendMessage(m_hWnd, SBM_GETSCROLLBARINFO, 0, (LPARAM)pScrollBarInfo);
#else // !(_WIN32_WINNT >= 0x0501)
return ::GetScrollBarInfo(m_hWnd, OBJID_CLIENT, pScrollBarInfo);
#endif // !(_WIN32_WINNT >= 0x0501)
}
#endif // (WINVER >= 0x0500)
// Operations
void ShowScrollBar(BOOL bShow = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
::ShowScrollBar(m_hWnd, SB_CTL, bShow);
}
BOOL EnableScrollBar(UINT nArrowFlags = ESB_ENABLE_BOTH)
{
ATLASSERT(::IsWindow(m_hWnd));
return ::EnableScrollBar(m_hWnd, SB_CTL, nArrowFlags);
}
#endif // !_WIN32_WCE
};
typedef CScrollBarT<ATL::CWindow> CScrollBar;
// --- Windows Common Controls ---
///////////////////////////////////////////////////////////////////////////////
// CImageList
class CImageList
{
public:
HIMAGELIST m_hImageList;
// Constructor
CImageList(HIMAGELIST hImageList = NULL) : m_hImageList(hImageList)
{ }
// Operators, etc.
CImageList& operator =(HIMAGELIST hImageList)
{
m_hImageList = hImageList;
return *this;
}
operator HIMAGELIST() const { return m_hImageList; }
void Attach(HIMAGELIST hImageList)
{
ATLASSERT(m_hImageList == NULL);
ATLASSERT(hImageList != NULL);
m_hImageList = hImageList;
}
HIMAGELIST Detach()
{
HIMAGELIST hImageList = m_hImageList;
m_hImageList = NULL;
return hImageList;
}
bool IsNull() const { return (m_hImageList == NULL); }
// Attributes
int GetImageCount() const
{
ATLASSERT(m_hImageList != NULL);
return ImageList_GetImageCount(m_hImageList);
}
COLORREF GetBkColor() const
{
ATLASSERT(m_hImageList != NULL);
return ImageList_GetBkColor(m_hImageList);
}
COLORREF SetBkColor(COLORREF cr)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetBkColor(m_hImageList, cr);
}
BOOL GetImageInfo(int nImage, IMAGEINFO* pImageInfo) const
{
ATLASSERT(m_hImageList != NULL);
return ImageList_GetImageInfo(m_hImageList, nImage, pImageInfo);
}
HICON GetIcon(int nIndex, UINT uFlags = ILD_NORMAL) const
{
ATLASSERT(m_hImageList != NULL);
return ImageList_GetIcon(m_hImageList, nIndex, uFlags);
}
BOOL GetIconSize(int& cx, int& cy) const
{
ATLASSERT(m_hImageList != NULL);
return ImageList_GetIconSize(m_hImageList, &cx, &cy);
}
BOOL GetIconSize(SIZE& size) const
{
ATLASSERT(m_hImageList != NULL);
return ImageList_GetIconSize(m_hImageList, (int*)&size.cx, (int*)&size.cy);
}
BOOL SetIconSize(int cx, int cy)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetIconSize(m_hImageList, cx, cy);
}
BOOL SetIconSize(SIZE size)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetIconSize(m_hImageList, size.cx, size.cy);
}
BOOL SetImageCount(UINT uNewCount)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetImageCount(m_hImageList, uNewCount);
}
BOOL SetOverlayImage(int nImage, int nOverlay)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetOverlayImage(m_hImageList, nImage, nOverlay);
}
// Operations
BOOL Create(int cx, int cy, UINT nFlags, int nInitial, int nGrow)
{
ATLASSERT(m_hImageList == NULL);
m_hImageList = ImageList_Create(cx, cy, nFlags, nInitial, nGrow);
return (m_hImageList != NULL) ? TRUE : FALSE;
}
BOOL Create(ATL::_U_STRINGorID bitmap, int cx, int nGrow, COLORREF crMask)
{
ATLASSERT(m_hImageList == NULL);
#if (_ATL_VER >= 0x0700)
m_hImageList = ImageList_LoadBitmap(ATL::_AtlBaseModule.GetResourceInstance(), bitmap.m_lpstr, cx, nGrow, crMask);
#else // !(_ATL_VER >= 0x0700)
m_hImageList = ImageList_LoadBitmap(_Module.GetResourceInstance(), bitmap.m_lpstr, cx, nGrow, crMask);
#endif // !(_ATL_VER >= 0x0700)
return (m_hImageList != NULL) ? TRUE : FALSE;
}
BOOL CreateFromImage(ATL::_U_STRINGorID image, int cx, int nGrow, COLORREF crMask, UINT uType, UINT uFlags = LR_DEFAULTCOLOR | LR_DEFAULTSIZE)
{
ATLASSERT(m_hImageList == NULL);
#if (_ATL_VER >= 0x0700)
m_hImageList = ImageList_LoadImage(ATL::_AtlBaseModule.GetResourceInstance(), image.m_lpstr, cx, nGrow, crMask, uType, uFlags);
#else // !(_ATL_VER >= 0x0700)
m_hImageList = ImageList_LoadImage(_Module.GetResourceInstance(), image.m_lpstr, cx, nGrow, crMask, uType, uFlags);
#endif // !(_ATL_VER >= 0x0700)
return (m_hImageList != NULL) ? TRUE : FALSE;
}
BOOL Merge(HIMAGELIST hImageList1, int nImage1, HIMAGELIST hImageList2, int nImage2, int dx, int dy)
{
ATLASSERT(m_hImageList == NULL);
m_hImageList = ImageList_Merge(hImageList1, nImage1, hImageList2, nImage2, dx, dy);
return (m_hImageList != NULL) ? TRUE : FALSE;
}
#ifndef _WIN32_WCE
BOOL CreateFromStream(LPSTREAM lpStream)
{
ATLASSERT(m_hImageList == NULL);
m_hImageList = ImageList_Read(lpStream);
return (m_hImageList != NULL) ? TRUE : FALSE;
}
#endif // !_WIN32_WCE
BOOL Destroy()
{
if (m_hImageList == NULL)
return FALSE;
BOOL bRet = ImageList_Destroy(m_hImageList);
if(bRet)
m_hImageList = NULL;
return bRet;
}
int Add(HBITMAP hBitmap, HBITMAP hBitmapMask = NULL)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_Add(m_hImageList, hBitmap, hBitmapMask);
}
int Add(HBITMAP hBitmap, COLORREF crMask)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_AddMasked(m_hImageList, hBitmap, crMask);
}
BOOL Remove(int nImage)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_Remove(m_hImageList, nImage);
}
BOOL RemoveAll()
{
ATLASSERT(m_hImageList != NULL);
return ImageList_RemoveAll(m_hImageList);
}
BOOL Replace(int nImage, HBITMAP hBitmap, HBITMAP hBitmapMask)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_Replace(m_hImageList, nImage, hBitmap, hBitmapMask);
}
int AddIcon(HICON hIcon)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_AddIcon(m_hImageList, hIcon);
}
int ReplaceIcon(int nImage, HICON hIcon)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_ReplaceIcon(m_hImageList, nImage, hIcon);
}
HICON ExtractIcon(int nImage)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_ExtractIcon(NULL, m_hImageList, nImage);
}
BOOL Draw(HDC hDC, int nImage, int x, int y, UINT nStyle)
{
ATLASSERT(m_hImageList != NULL);
ATLASSERT(hDC != NULL);
return ImageList_Draw(m_hImageList, nImage, hDC, x, y, nStyle);
}
BOOL Draw(HDC hDC, int nImage, POINT pt, UINT nStyle)
{
ATLASSERT(m_hImageList != NULL);
ATLASSERT(hDC != NULL);
return ImageList_Draw(m_hImageList, nImage, hDC, pt.x, pt.y, nStyle);
}
BOOL DrawEx(int nImage, HDC hDC, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle)
{
ATLASSERT(m_hImageList != NULL);
ATLASSERT(hDC != NULL);
return ImageList_DrawEx(m_hImageList, nImage, hDC, x, y, dx, dy, rgbBk, rgbFg, fStyle);
}
BOOL DrawEx(int nImage, HDC hDC, RECT& rect, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle)
{
ATLASSERT(m_hImageList != NULL);
ATLASSERT(hDC != NULL);
return ImageList_DrawEx(m_hImageList, nImage, hDC, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, rgbBk, rgbFg, fStyle);
}
static BOOL DrawIndirect(IMAGELISTDRAWPARAMS* pimldp)
{
return ImageList_DrawIndirect(pimldp);
}
BOOL Copy(int nSrc, int nDst, UINT uFlags = ILCF_MOVE)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_Copy(m_hImageList, nDst, m_hImageList, nSrc, uFlags);
}
#ifndef _WIN32_WCE
static HIMAGELIST Read(LPSTREAM lpStream)
{
return ImageList_Read(lpStream);
}
BOOL Write(LPSTREAM lpStream)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_Write(m_hImageList, lpStream);
}
#endif // !_WIN32_WCE
#if (_WIN32_WINNT >= 0x0501)
static HRESULT ReadEx(DWORD dwFlags, LPSTREAM lpStream, REFIID riid, PVOID* ppv)
{
return ImageList_ReadEx(dwFlags, lpStream, riid, ppv);
}
HRESULT WriteEx(DWORD dwFlags, LPSTREAM lpStream)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_WriteEx(m_hImageList, dwFlags, lpStream);
}
#endif // (_WIN32_WINNT >= 0x0501)
// Drag operations
BOOL BeginDrag(int nImage, POINT ptHotSpot)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_BeginDrag(m_hImageList, nImage, ptHotSpot.x, ptHotSpot.y);
}
BOOL BeginDrag(int nImage, int xHotSpot, int yHotSpot)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_BeginDrag(m_hImageList, nImage, xHotSpot, yHotSpot);
}
static void EndDrag()
{
ImageList_EndDrag();
}
static BOOL DragMove(POINT pt)
{
return ImageList_DragMove(pt.x, pt.y);
}
static BOOL DragMove(int x, int y)
{
return ImageList_DragMove(x, y);
}
BOOL SetDragCursorImage(int nDrag, POINT ptHotSpot)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetDragCursorImage(m_hImageList, nDrag, ptHotSpot.x, ptHotSpot.y);
}
BOOL SetDragCursorImage(int nDrag, int xHotSpot, int yHotSpot)
{
ATLASSERT(m_hImageList != NULL);
return ImageList_SetDragCursorImage(m_hImageList, nDrag, xHotSpot, yHotSpot);
}
static BOOL DragShowNolock(BOOL bShow = TRUE)
{
return ImageList_DragShowNolock(bShow);
}
static CImageList GetDragImage(LPPOINT lpPoint, LPPOINT lpPointHotSpot)
{
return CImageList(ImageList_GetDragImage(lpPoint, lpPointHotSpot));
}
static BOOL DragEnter(HWND hWnd, POINT point)
{
return ImageList_DragEnter(hWnd, point.x, point.y);
}
static BOOL DragEnter(HWND hWnd, int x, int y)
{
return ImageList_DragEnter(hWnd, x, y);
}
static BOOL DragLeave(HWND hWnd)
{
return ImageList_DragLeave(hWnd);
}
#if (_WIN32_IE >= 0x0400)
CImageList Duplicate() const
{
ATLASSERT(m_hImageList != NULL);
return CImageList(ImageList_Duplicate(m_hImageList));
}
static CImageList Duplicate(HIMAGELIST hImageList)
{
ATLASSERT(hImageList != NULL);
return CImageList(ImageList_Duplicate(hImageList));
}
#endif // (_WIN32_IE >= 0x0400)
};
///////////////////////////////////////////////////////////////////////////////
// CToolTipCtrl
#ifndef _WIN32_WCE
class CToolInfo : public TOOLINFO
{
public:
CToolInfo(UINT nFlags, HWND hWnd, UINT nIDTool = 0, LPRECT lpRect = NULL, LPTSTR lpstrText = LPSTR_TEXTCALLBACK, LPARAM lUserParam = NULL)
{
Init(nFlags, hWnd, nIDTool, lpRect, lpstrText, lUserParam);
}
operator LPTOOLINFO() { return this; }
operator LPARAM() { return (LPARAM)this; }
void Init(UINT nFlags, HWND hWnd, UINT nIDTool = 0, LPRECT lpRect = NULL, LPTSTR lpstrText = LPSTR_TEXTCALLBACK, LPARAM lUserParam = NULL)
{
ATLASSERT(::IsWindow(hWnd));
memset(this, 0, sizeof(TOOLINFO));
cbSize = sizeof(TOOLINFO);
uFlags = nFlags;
if(nIDTool == 0)
{
hwnd = ::GetParent(hWnd);
uFlags |= TTF_IDISHWND;
uId = (UINT_PTR)hWnd;
}
else
{
hwnd = hWnd;
uId = nIDTool;
}
if(lpRect != NULL)
rect = *lpRect;
#if (_ATL_VER >= 0x0700)
hinst = ATL::_AtlBaseModule.GetResourceInstance();
#else // !(_ATL_VER >= 0x0700)
hinst = _Module.GetResourceInstance();
#endif // !(_ATL_VER >= 0x0700)
lpszText = lpstrText;
lParam = lUserParam;
}
};
template <class TBase>
class CToolTipCtrlT : public TBase
{
public:
// Constructors
CToolTipCtrlT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CToolTipCtrlT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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 TOOLTIPS_CLASS;
}
void GetText(LPTOOLINFO lpToolInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_GETTEXT, 0, (LPARAM)&lpToolInfo);
}
void GetText(LPTSTR lpstrText, HWND hWnd, UINT nIDTool = 0) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
CToolInfo ti(0, hWnd, nIDTool, NULL, lpstrText);
::SendMessage(m_hWnd, TTM_GETTEXT, 0, ti);
}
BOOL GetToolInfo(LPTOOLINFO lpToolInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_GETTOOLINFO, 0, (LPARAM)lpToolInfo);
}
BOOL GetToolInfo(HWND hWnd, UINT nIDTool, UINT* puFlags, LPRECT lpRect, LPTSTR lpstrText) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
CToolInfo ti(0, hWnd, nIDTool, NULL, lpstrText);
BOOL bRet = (BOOL)::SendMessage(m_hWnd, TTM_GETTOOLINFO, 0, ti);
if(bRet)
{
*puFlags = ti.uFlags;
memcpy(lpRect, &(ti.rect), sizeof(RECT));
}
return bRet;
}
void SetToolInfo(LPTOOLINFO lpToolInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_SETTOOLINFO, 0, (LPARAM)lpToolInfo);
}
void SetToolRect(LPTOOLINFO lpToolInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_NEWTOOLRECT, 0, (LPARAM)lpToolInfo);
}
void SetToolRect(HWND hWnd, UINT nIDTool, LPCRECT lpRect)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
ATLASSERT(nIDTool != 0);
CToolInfo ti(0, hWnd, nIDTool, (LPRECT)lpRect, NULL);
::SendMessage(m_hWnd, TTM_NEWTOOLRECT, 0, ti);
}
int GetToolCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TTM_GETTOOLCOUNT, 0, 0L);
}
int GetDelayTime(DWORD dwType) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TTM_GETDELAYTIME, dwType, 0L);
}
void SetDelayTime(DWORD dwType, int nTime)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_SETDELAYTIME, dwType, MAKELPARAM(nTime, 0));
}
void GetMargin(LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_GETMARGIN, 0, (LPARAM)lpRect);
}
void SetMargin(LPRECT lpRect)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_SETMARGIN, 0, (LPARAM)lpRect);
}
int GetMaxTipWidth() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TTM_GETMAXTIPWIDTH, 0, 0L);
}
int SetMaxTipWidth(int nWidth)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TTM_SETMAXTIPWIDTH, 0, nWidth);
}
COLORREF GetTipBkColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TTM_GETTIPBKCOLOR, 0, 0L);
}
void SetTipBkColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_SETTIPBKCOLOR, (WPARAM)clr, 0L);
}
COLORREF GetTipTextColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TTM_GETTIPTEXTCOLOR, 0, 0L);
}
void SetTipTextColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_SETTIPTEXTCOLOR, (WPARAM)clr, 0L);
}
BOOL GetCurrentTool(LPTOOLINFO lpToolInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_GETCURRENTTOOL, 0, (LPARAM)lpToolInfo);
}
#if (_WIN32_IE >= 0x0500)
SIZE GetBubbleSize(LPTOOLINFO lpToolInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TTM_GETBUBBLESIZE, 0, (LPARAM)lpToolInfo);
SIZE size = { GET_X_LPARAM(dwRet), GET_Y_LPARAM(dwRet) };
return size;
}
BOOL SetTitle(UINT uIcon, LPCTSTR lpstrTitle)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_SETTITLE, uIcon, (LPARAM)lpstrTitle);
}
#endif // (_WIN32_IE >= 0x0500)
#if (_WIN32_WINNT >= 0x0501)
void GetTitle(PTTGETTITLE pTTGetTitle) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_GETTITLE, 0, (LPARAM)pTTGetTitle);
}
void SetWindowTheme(LPCWSTR lpstrTheme)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_SETWINDOWTHEME, 0, (LPARAM)lpstrTheme);
}
#endif // (_WIN32_WINNT >= 0x0501)
// Operations
void Activate(BOOL bActivate)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_ACTIVATE, bActivate, 0L);
}
BOOL AddTool(LPTOOLINFO lpToolInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_ADDTOOL, 0, (LPARAM)lpToolInfo);
}
BOOL AddTool(HWND hWnd, ATL::_U_STRINGorID text = LPSTR_TEXTCALLBACK, LPCRECT lpRectTool = NULL, UINT nIDTool = 0)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
// the toolrect and toolid must both be zero or both valid
ATLASSERT((lpRectTool != NULL && nIDTool != 0) || (lpRectTool == NULL && nIDTool == 0));
CToolInfo ti(0, hWnd, nIDTool, (LPRECT)lpRectTool, (LPTSTR)text.m_lpstr);
return (BOOL)::SendMessage(m_hWnd, TTM_ADDTOOL, 0, ti);
}
void DelTool(LPTOOLINFO lpToolInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_DELTOOL, 0, (LPARAM)lpToolInfo);
}
void DelTool(HWND hWnd, UINT nIDTool = 0)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
CToolInfo ti(0, hWnd, nIDTool, NULL, NULL);
::SendMessage(m_hWnd, TTM_DELTOOL, 0, ti);
}
BOOL HitTest(LPTTHITTESTINFO lpHitTestInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_HITTEST, 0, (LPARAM)lpHitTestInfo);
}
BOOL HitTest(HWND hWnd, POINT pt, LPTOOLINFO lpToolInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
ATLASSERT(lpToolInfo != NULL);
TTHITTESTINFO hti = { 0 };
hti.ti.cbSize = sizeof(TOOLINFO);
hti.hwnd = hWnd;
hti.pt.x = pt.x;
hti.pt.y = pt.y;
if((BOOL)::SendMessage(m_hWnd, TTM_HITTEST, 0, (LPARAM)&hti))
{
memcpy(lpToolInfo, &hti.ti, sizeof(TOOLINFO));
return TRUE;
}
return FALSE;
}
void RelayEvent(LPMSG lpMsg)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_RELAYEVENT, 0, (LPARAM)lpMsg);
}
void UpdateTipText(LPTOOLINFO lpToolInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_UPDATETIPTEXT, 0, (LPARAM)lpToolInfo);
}
void UpdateTipText(ATL::_U_STRINGorID text, HWND hWnd, UINT nIDTool = 0)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(hWnd != NULL);
CToolInfo ti(0, hWnd, nIDTool, NULL, (LPTSTR)text.m_lpstr);
::SendMessage(m_hWnd, TTM_UPDATETIPTEXT, 0, ti);
}
BOOL EnumTools(UINT nTool, LPTOOLINFO lpToolInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_ENUMTOOLS, nTool, (LPARAM)lpToolInfo);
}
void Pop()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_POP, 0, 0L);
}
void TrackActivate(LPTOOLINFO lpToolInfo, BOOL bActivate)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_TRACKACTIVATE, bActivate, (LPARAM)lpToolInfo);
}
void TrackPosition(int xPos, int yPos)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_TRACKPOSITION, 0, MAKELPARAM(xPos, yPos));
}
#if (_WIN32_IE >= 0x0400)
void Update()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_UPDATE, 0, 0L);
}
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_IE >= 0x0500)
BOOL AdjustRect(LPRECT lpRect, BOOL bLarger /*= TRUE*/)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TTM_ADJUSTRECT, bLarger, (LPARAM)lpRect);
}
#endif // (_WIN32_IE >= 0x0500)
#if (_WIN32_WINNT >= 0x0501)
void Popup()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TTM_POPUP, 0, 0L);
}
#endif // (_WIN32_WINNT >= 0x0501)
};
typedef CToolTipCtrlT<ATL::CWindow> CToolTipCtrl;
#endif // !_WIN32_WCE
///////////////////////////////////////////////////////////////////////////////
// CHeaderCtrl
template <class TBase>
class CHeaderCtrlT : public TBase
{
public:
// Constructors
CHeaderCtrlT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CHeaderCtrlT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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_HEADER;
}
int GetItemCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_GETITEMCOUNT, 0, 0L);
}
BOOL GetItem(int nIndex, LPHDITEM pHeaderItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_GETITEM, nIndex, (LPARAM)pHeaderItem);
}
BOOL SetItem(int nIndex, LPHDITEM pHeaderItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_SETITEM, nIndex, (LPARAM)pHeaderItem);
}
CImageList GetImageList() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, HDM_GETIMAGELIST, 0, 0L));
}
CImageList SetImageList(HIMAGELIST hImageList)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, HDM_SETIMAGELIST, 0, (LPARAM)hImageList));
}
BOOL GetOrderArray(int nSize, int* lpnArray) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_GETORDERARRAY, nSize, (LPARAM)lpnArray);
}
BOOL SetOrderArray(int nSize, int* lpnArray)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_SETORDERARRAY, nSize, (LPARAM)lpnArray);
}
BOOL GetItemRect(int nIndex, LPRECT lpItemRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_GETITEMRECT, nIndex, (LPARAM)lpItemRect);
}
int SetHotDivider(BOOL bPos, DWORD dwInputValue)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_SETHOTDIVIDER, bPos, dwInputValue);
}
#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
BOOL GetUnicodeFormat() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_GETUNICODEFORMAT, 0, 0L);
}
BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_SETUNICODEFORMAT, bUnicode, 0L);
}
#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
int GetBitmapMargin() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_GETBITMAPMARGIN, 0, 0L);
}
int SetBitmapMargin(int nWidth)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_SETBITMAPMARGIN, nWidth, 0L);
}
int SetFilterChangeTimeout(DWORD dwTimeOut)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_SETFILTERCHANGETIMEOUT, 0, dwTimeOut);
}
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
// Operations
int InsertItem(int nIndex, LPHDITEM phdi)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_INSERTITEM, nIndex, (LPARAM)phdi);
}
BOOL DeleteItem(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_DELETEITEM, nIndex, 0L);
}
BOOL Layout(HD_LAYOUT* pHeaderLayout)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, HDM_LAYOUT, 0, (LPARAM)pHeaderLayout);
}
int HitTest(LPHDHITTESTINFO lpHitTestInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_HITTEST, 0, (LPARAM)lpHitTestInfo);
}
int OrderToIndex(int nOrder)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_ORDERTOINDEX, nOrder, 0L);
}
CImageList CreateDragImage(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, HDM_CREATEDRAGIMAGE, nIndex, 0L));
}
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
int EditFilter(int nColumn, BOOL bDiscardChanges)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_EDITFILTER, nColumn, MAKELPARAM(bDiscardChanges, 0));
}
int ClearFilter(int nColumn)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_CLEARFILTER, nColumn, 0L);
}
int ClearAllFilters()
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, HDM_CLEARFILTER, (WPARAM)-1, 0L);
}
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
};
typedef CHeaderCtrlT<ATL::CWindow> CHeaderCtrl;
///////////////////////////////////////////////////////////////////////////////
// CListViewCtrl
template <class TBase>
class CListViewCtrlT : public TBase
{
public:
// Constructors
CListViewCtrlT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CListViewCtrlT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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_LISTVIEW;
}
COLORREF GetBkColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_GETBKCOLOR, 0, 0L);
}
BOOL SetBkColor(COLORREF cr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETBKCOLOR, 0, cr);
}
CImageList GetImageList(int nImageListType) const
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_GETIMAGELIST, nImageListType, 0L));
}
CImageList SetImageList(HIMAGELIST hImageList, int nImageList)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_SETIMAGELIST, nImageList, (LPARAM)hImageList));
}
int GetItemCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETITEMCOUNT, 0, 0L);
}
BOOL SetItemCount(int nItems)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMCOUNT, nItems, 0L);
}
BOOL GetItem(LPLVITEM pItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)pItem);
}
BOOL SetItem(const LVITEM* pItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEM, 0, (LPARAM)pItem);
}
BOOL SetItem(int nItem, int nSubItem, UINT nMask, LPCTSTR lpszItem,
int nImage, UINT nState, UINT nStateMask, LPARAM lParam)
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM lvi = { 0 };
lvi.mask = nMask;
lvi.iItem = nItem;
lvi.iSubItem = nSubItem;
lvi.stateMask = nStateMask;
lvi.state = nState;
lvi.pszText = (LPTSTR) lpszItem;
lvi.iImage = nImage;
lvi.lParam = lParam;
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEM, 0, (LPARAM)&lvi);
}
UINT GetItemState(int nItem, UINT nMask) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, LVM_GETITEMSTATE, nItem, nMask);
}
BOOL SetItemState(int nItem, UINT nState, UINT nStateMask)
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM lvi = { 0 };
lvi.state = nState;
lvi.stateMask = nStateMask;
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMSTATE, nItem, (LPARAM)&lvi);
}
BOOL SetItemState(int nItem, LPLVITEM pItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMSTATE, nItem, (LPARAM)pItem);
}
#ifndef _ATL_NO_COM
BOOL GetItemText(int nItem, int nSubItem, BSTR& bstrText) const
{
USES_CONVERSION;
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(bstrText == NULL);
LVITEM lvi = { 0 };
lvi.iSubItem = nSubItem;
LPTSTR lpstrText = NULL;
int nRes = 0;
for(int nLen = 256; ; nLen *= 2)
{
ATLTRY(lpstrText = new TCHAR[nLen]);
if(lpstrText == NULL)
break;
lpstrText[0] = NULL;
lvi.cchTextMax = nLen;
lvi.pszText = lpstrText;
nRes = (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi);
if(nRes < nLen - 1)
break;
delete [] lpstrText;
lpstrText = NULL;
}
if(lpstrText != NULL)
{
if(nRes != 0)
bstrText = ::SysAllocString(T2OLE(lpstrText));
delete [] lpstrText;
}
return (bstrText != NULL) ? TRUE : FALSE;
}
#endif // !_ATL_NO_COM
#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
int GetItemText(int nItem, int nSubItem, _CSTRING_NS::CString& strText) const
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM lvi = { 0 };
lvi.iSubItem = nSubItem;
strText.Empty();
int nRes = 0;
for(int nLen = 256; ; nLen *= 2)
{
lvi.cchTextMax = nLen;
lvi.pszText = strText.GetBufferSetLength(nLen);
if(lvi.pszText == NULL)
{
nRes = 0;
break;
}
nRes = (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi);
if(nRes < nLen - 1)
break;
}
strText.ReleaseBuffer();
return nRes;
}
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
int GetItemText(int nItem, int nSubItem, LPTSTR lpszText, int nLen) const
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM lvi = { 0 };
lvi.iSubItem = nSubItem;
lvi.cchTextMax = nLen;
lvi.pszText = lpszText;
return (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi);
}
BOOL SetItemText(int nItem, int nSubItem, LPCTSTR lpszText)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItem(nItem, nSubItem, LVIF_TEXT, lpszText, 0, 0, 0, 0);
}
DWORD_PTR GetItemData(int nItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM lvi = { 0 };
lvi.iItem = nItem;
lvi.mask = LVIF_PARAM;
BOOL bRet = (BOOL)::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)&lvi);
return (DWORD_PTR)(bRet ? lvi.lParam : NULL);
}
BOOL SetItemData(int nItem, DWORD_PTR dwData)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItem(nItem, 0, LVIF_PARAM, NULL, 0, 0, 0, (LPARAM)dwData);
}
UINT GetCallbackMask() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, LVM_GETCALLBACKMASK, 0, 0L);
}
BOOL SetCallbackMask(UINT nMask)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETCALLBACKMASK, nMask, 0L);
}
BOOL GetItemPosition(int nItem, LPPOINT lpPoint) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETITEMPOSITION, nItem, (LPARAM)lpPoint);
}
BOOL SetItemPosition(int nItem, POINT pt)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(((GetStyle() & LVS_TYPEMASK) == LVS_ICON) || ((GetStyle() & LVS_TYPEMASK) == LVS_SMALLICON));
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMPOSITION32, nItem, (LPARAM)&pt);
}
BOOL SetItemPosition(int nItem, int x, int y)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(((GetStyle() & LVS_TYPEMASK) == LVS_ICON) || ((GetStyle() & LVS_TYPEMASK) == LVS_SMALLICON));
POINT pt = { x, y };
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMPOSITION32, nItem, (LPARAM)&pt);
}
int GetStringWidth(LPCTSTR lpsz) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETSTRINGWIDTH, 0, (LPARAM)lpsz);
}
CEdit GetEditControl() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CEdit((HWND)::SendMessage(m_hWnd, LVM_GETEDITCONTROL, 0, 0L));
}
BOOL GetColumn(int nCol, LVCOLUMN* pColumn) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETCOLUMN, nCol, (LPARAM)pColumn);
}
BOOL SetColumn(int nCol, const LVCOLUMN* pColumn)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETCOLUMN, nCol, (LPARAM)pColumn);
}
int GetColumnWidth(int nCol) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETCOLUMNWIDTH, nCol, 0L);
}
BOOL SetColumnWidth(int nCol, int cx)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETCOLUMNWIDTH, nCol, MAKELPARAM(cx, 0));
}
BOOL GetViewRect(LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETVIEWRECT, 0, (LPARAM)lpRect);
}
COLORREF GetTextColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_GETTEXTCOLOR, 0, 0L);
}
BOOL SetTextColor(COLORREF cr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETTEXTCOLOR, 0, cr);
}
COLORREF GetTextBkColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_GETTEXTBKCOLOR, 0, 0L);
}
BOOL SetTextBkColor(COLORREF cr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETTEXTBKCOLOR, 0, cr);
}
int GetTopIndex() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETTOPINDEX, 0, 0L);
}
int GetCountPerPage() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETCOUNTPERPAGE, 0, 0L);
}
BOOL GetOrigin(LPPOINT lpPoint) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETORIGIN, 0, (LPARAM)lpPoint);
}
UINT GetSelectedCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, LVM_GETSELECTEDCOUNT, 0, 0L);
}
BOOL GetItemRect(int nItem, LPRECT lpRect, UINT nCode) const
{
ATLASSERT(::IsWindow(m_hWnd));
lpRect->left = nCode;
return (BOOL)::SendMessage(m_hWnd, LVM_GETITEMRECT, (WPARAM)nItem, (LPARAM)lpRect);
}
#ifndef _WIN32_WCE
HCURSOR GetHotCursor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HCURSOR)::SendMessage(m_hWnd, LVM_GETHOTCURSOR, 0, 0L);
}
HCURSOR SetHotCursor(HCURSOR hHotCursor)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HCURSOR)::SendMessage(m_hWnd, LVM_SETHOTCURSOR, 0, (LPARAM)hHotCursor);
}
int GetHotItem() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETHOTITEM, 0, 0L);
}
int SetHotItem(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_SETHOTITEM, nIndex, 0L);
}
#endif // !_WIN32_WCE
BOOL GetColumnOrderArray(int nCount, int* lpnArray) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETCOLUMNORDERARRAY, nCount, (LPARAM)lpnArray);
}
BOOL SetColumnOrderArray(int nCount, int* lpnArray)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETCOLUMNORDERARRAY, nCount, (LPARAM)lpnArray);
}
CHeaderCtrl GetHeader() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CHeaderCtrl((HWND)::SendMessage(m_hWnd, LVM_GETHEADER, 0, 0L));
}
BOOL GetSubItemRect(int nItem, int nSubItem, int nFlag, LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LVS_TYPEMASK) == LVS_REPORT);
ATLASSERT(lpRect != NULL);
lpRect->top = nSubItem;
lpRect->left = nFlag;
return (BOOL)::SendMessage(m_hWnd, LVM_GETSUBITEMRECT, nItem, (LPARAM)lpRect);
}
DWORD SetIconSpacing(int cx, int cy)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LVS_TYPEMASK) == LVS_ICON);
return (DWORD)::SendMessage(m_hWnd, LVM_SETICONSPACING, 0, MAKELPARAM(cx, cy));
}
int GetISearchString(LPTSTR lpstr) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETISEARCHSTRING, 0, (LPARAM)lpstr);
}
void GetItemSpacing(SIZE& sizeSpacing, BOOL bSmallIconView = FALSE) const
{
ATLASSERT(::IsWindow(m_hWnd));
DWORD dwRet = (DWORD)::SendMessage(m_hWnd, LVM_GETITEMSPACING, bSmallIconView, 0L);
sizeSpacing.cx = GET_X_LPARAM(dwRet);
sizeSpacing.cy = GET_Y_LPARAM(dwRet);
}
#if (_WIN32_WCE >= 410)
void SetItemSpacing(INT cySpacing)
{
ATLASSERT(::IsWindow(m_hWnd));
ListView_SetItemSpacing(m_hWnd, cySpacing);
}
#endif // (_WIN32_WCE >= 410)
// single-selection only
int GetSelectedIndex() const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LVS_SINGLESEL) != 0);
return (int)::SendMessage(m_hWnd, LVM_GETNEXTITEM, (WPARAM)-1, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0));
}
BOOL GetSelectedItem(LPLVITEM pItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LVS_SINGLESEL) != 0);
ATLASSERT(pItem != NULL);
pItem->iItem = (int)::SendMessage(m_hWnd, LVM_GETNEXTITEM, (WPARAM)-1, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0));
if(pItem->iItem == -1)
return FALSE;
return (BOOL)::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)pItem);
}
// extended list view styles
DWORD GetExtendedListViewStyle() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0L);
}
// dwExMask = 0 means all styles
DWORD SetExtendedListViewStyle(DWORD dwExStyle, DWORD dwExMask = 0)
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, LVM_SETEXTENDEDLISTVIEWSTYLE, dwExMask, dwExStyle);
}
// checkboxes only
BOOL GetCheckState(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetExtendedListViewStyle() & LVS_EX_CHECKBOXES) != 0);
UINT uRet = GetItemState(nIndex, LVIS_STATEIMAGEMASK);
return (uRet >> 12) - 1;
}
BOOL SetCheckState(int nItem, BOOL bCheck)
{
int nCheck = bCheck ? 2 : 1; // one based index
return SetItemState(nItem, INDEXTOSTATEIMAGEMASK(nCheck), LVIS_STATEIMAGEMASK);
}
// view type
DWORD GetViewType() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (GetStyle() & LVS_TYPEMASK);
}
DWORD SetViewType(DWORD dwType)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(dwType == LVS_ICON || dwType == LVS_SMALLICON || dwType == LVS_LIST || dwType == LVS_REPORT);
DWORD dwOldType = GetViewType();
if(dwType != dwOldType)
ModifyStyle(LVS_TYPEMASK, (dwType & LVS_TYPEMASK));
return dwOldType;
}
#if (_WIN32_IE >= 0x0400)
#ifndef _WIN32_WCE
BOOL GetBkImage(LPLVBKIMAGE plvbki) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETBKIMAGE, 0, (LPARAM)plvbki);
}
BOOL SetBkImage(LPLVBKIMAGE plvbki)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETBKIMAGE, 0, (LPARAM)plvbki);
}
#endif // !_WIN32_WCE
int GetSelectionMark() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETSELECTIONMARK, 0, 0L);
}
int SetSelectionMark(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_SETSELECTIONMARK, 0, nIndex);
}
#ifndef _WIN32_WCE
BOOL GetWorkAreas(int nWorkAreas, LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETWORKAREAS, nWorkAreas, (LPARAM)lpRect);
}
BOOL SetWorkAreas(int nWorkAreas, LPRECT lpRect)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETWORKAREAS, nWorkAreas, (LPARAM)lpRect);
}
DWORD GetHoverTime() const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetExtendedListViewStyle() & (LVS_EX_TRACKSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_TWOCLICKACTIVATE)) != 0);
return (DWORD)::SendMessage(m_hWnd, LVM_GETHOVERTIME, 0, 0L);
}
DWORD SetHoverTime(DWORD dwHoverTime)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetExtendedListViewStyle() & (LVS_EX_TRACKSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_TWOCLICKACTIVATE)) != 0);
return (DWORD)::SendMessage(m_hWnd, LVM_SETHOVERTIME, 0, dwHoverTime);
}
BOOL GetNumberOfWorkAreas(int* pnWorkAreas) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETNUMBEROFWORKAREAS, 0, (LPARAM)pnWorkAreas);
}
#endif // !_WIN32_WCE
BOOL SetItemCountEx(int nItems, DWORD dwFlags)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(((GetStyle() & LVS_OWNERDATA) != 0) && (((GetStyle() & LVS_TYPEMASK) == LVS_REPORT) || ((GetStyle() & LVS_TYPEMASK) == LVS_LIST)));
return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMCOUNT, nItems, dwFlags);
}
#ifndef _WIN32_WCE
CToolTipCtrl GetToolTips() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CToolTipCtrl((HWND)::SendMessage(m_hWnd, LVM_GETTOOLTIPS, 0, 0L));
}
CToolTipCtrl SetToolTips(HWND hWndTT)
{
ATLASSERT(::IsWindow(m_hWnd));
return CToolTipCtrl((HWND)::SendMessage(m_hWnd, LVM_SETTOOLTIPS, (WPARAM)hWndTT, 0L));
}
BOOL GetUnicodeFormat() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETUNICODEFORMAT, 0, 0L);
}
BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETUNICODEFORMAT, bUnicode, 0L);
}
#endif // !_WIN32_WCE
#endif // (_WIN32_IE >= 0x0400)
#if (_WIN32_WINNT >= 0x0501)
int GetSelectedColumn() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETSELECTEDCOLUMN, 0, 0L);
}
void SetSelectedColumn(int nColumn)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_SETSELECTEDCOLUMN, nColumn, 0L);
}
DWORD GetView() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, LVM_GETVIEW, 0, 0L);
}
int SetView(DWORD dwView)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_SETVIEW, dwView, 0L);
}
BOOL IsGroupViewEnabled() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_ISGROUPVIEWENABLED, 0, 0L);
}
int GetGroupInfo(int nGroupID, PLVGROUP pGroup) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETGROUPINFO, nGroupID, (LPARAM)pGroup);
}
int SetGroupInfo(int nGroupID, PLVGROUP pGroup)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_SETGROUPINFO, nGroupID, (LPARAM)pGroup);
}
void GetGroupMetrics(PLVGROUPMETRICS pGroupMetrics) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_GETGROUPMETRICS, 0, (LPARAM)pGroupMetrics);
}
void SetGroupMetrics(PLVGROUPMETRICS pGroupMetrics)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_SETGROUPMETRICS, 0, (LPARAM)pGroupMetrics);
}
void GetTileViewInfo(PLVTILEVIEWINFO pTileViewInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_GETTILEVIEWINFO, 0, (LPARAM)pTileViewInfo);
}
BOOL SetTileViewInfo(PLVTILEVIEWINFO pTileViewInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETTILEVIEWINFO, 0, (LPARAM)pTileViewInfo);
}
void GetTileInfo(PLVTILEINFO pTileInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_GETTILEINFO, 0, (LPARAM)pTileInfo);
}
BOOL SetTileInfo(PLVTILEINFO pTileInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETTILEINFO, 0, (LPARAM)pTileInfo);
}
BOOL GetInsertMark(LPLVINSERTMARK pInsertMark) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_GETINSERTMARK, 0, (LPARAM)pInsertMark);
}
BOOL SetInsertMark(LPLVINSERTMARK pInsertMark)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETINSERTMARK, 0, (LPARAM)pInsertMark);
}
int GetInsertMarkRect(LPRECT lpRect) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETINSERTMARKRECT, 0, (LPARAM)lpRect);
}
COLORREF GetInsertMarkColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_GETINSERTMARKCOLOR, 0, 0L);
}
COLORREF SetInsertMarkColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_SETINSERTMARKCOLOR, 0, clr);
}
COLORREF GetOutlineColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_GETOUTLINECOLOR, 0, 0L);
}
COLORREF SetOutlineColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, LVM_SETOUTLINECOLOR, 0, clr);
}
#endif // (_WIN32_WINNT >= 0x0501)
// Operations
int InsertColumn(int nCol, const LVCOLUMN* pColumn)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_INSERTCOLUMN, nCol, (LPARAM)pColumn);
}
int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat = LVCFMT_LEFT,
int nWidth = -1, int nSubItem = -1, int iImage = -1, int iOrder = -1)
{
LVCOLUMN column = { 0 };
column.mask = LVCF_TEXT|LVCF_FMT;
column.pszText = (LPTSTR)lpszColumnHeading;
column.fmt = nFormat;
if (nWidth != -1)
{
column.mask |= LVCF_WIDTH;
column.cx = nWidth;
}
if (nSubItem != -1)
{
column.mask |= LVCF_SUBITEM;
column.iSubItem = nSubItem;
}
if (iImage != -1)
{
column.mask |= LVCF_IMAGE;
column.iImage = iImage;
}
if (iOrder != -1)
{
column.mask |= LVCF_ORDER;
column.iOrder = iOrder;
}
return InsertColumn(nCol, &column);
}
BOOL DeleteColumn(int nCol)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_DELETECOLUMN, nCol, 0L);
}
int InsertItem(UINT nMask, int nItem, LPCTSTR lpszItem, UINT nState, UINT nStateMask, int nImage, LPARAM lParam)
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM item = { 0 };
item.mask = nMask;
item.iItem = nItem;
item.iSubItem = 0;
item.pszText = (LPTSTR)lpszItem;
item.state = nState;
item.stateMask = nStateMask;
item.iImage = nImage;
item.lParam = lParam;
return InsertItem(&item);
}
int InsertItem(const LVITEM* pItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_INSERTITEM, 0, (LPARAM)pItem);
}
int InsertItem(int nItem, LPCTSTR lpszItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return InsertItem(LVIF_TEXT, nItem, lpszItem, 0, 0, 0, 0);
}
int InsertItem(int nItem, LPCTSTR lpszItem, int nImage)
{
ATLASSERT(::IsWindow(m_hWnd));
return InsertItem(LVIF_TEXT|LVIF_IMAGE, nItem, lpszItem, 0, 0, nImage, 0);
}
int GetNextItem(int nItem, int nFlags) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_GETNEXTITEM, nItem, MAKELPARAM(nFlags, 0));
}
BOOL DeleteItem(int nItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_DELETEITEM, nItem, 0L);
}
BOOL DeleteAllItems()
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_DELETEALLITEMS, 0, 0L);
}
int FindItem(LVFINDINFO* pFindInfo, int nStart) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_FINDITEM, nStart, (LPARAM)pFindInfo);
}
int HitTest(LVHITTESTINFO* pHitTestInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_HITTEST, 0, (LPARAM)pHitTestInfo);
}
int HitTest(POINT pt, UINT* pFlags) const
{
ATLASSERT(::IsWindow(m_hWnd));
LVHITTESTINFO hti = { 0 };
hti.pt = pt;
int nRes = (int)::SendMessage(m_hWnd, LVM_HITTEST, 0, (LPARAM)&hti);
if (pFlags != NULL)
*pFlags = hti.flags;
return nRes;
}
BOOL EnsureVisible(int nItem, BOOL bPartialOK)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_ENSUREVISIBLE, nItem, MAKELPARAM(bPartialOK, 0));
}
BOOL Scroll(SIZE size)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SCROLL, size.cx, size.cy);
}
BOOL RedrawItems(int nFirst, int nLast)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_REDRAWITEMS, nFirst, nLast);
}
BOOL Arrange(UINT nCode)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_ARRANGE, nCode, 0L);
}
CEdit EditLabel(int nItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return CEdit((HWND)::SendMessage(m_hWnd, LVM_EDITLABEL, nItem, 0L));
}
BOOL Update(int nItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_UPDATE, nItem, 0L);
}
BOOL SortItems(PFNLVCOMPARE pfnCompare, LPARAM lParamSort)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SORTITEMS, (WPARAM)lParamSort, (LPARAM)pfnCompare);
}
CImageList RemoveImageList(int nImageList)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_SETIMAGELIST, (WPARAM)nImageList, NULL));
}
CImageList CreateDragImage(int nItem, LPPOINT lpPoint)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_CREATEDRAGIMAGE, nItem, (LPARAM)lpPoint));
}
DWORD ApproximateViewRect(int cx = -1, int cy = -1, int nCount = -1)
{
ATLASSERT(::IsWindow(m_hWnd));
return (DWORD)::SendMessage(m_hWnd, LVM_APPROXIMATEVIEWRECT, nCount, MAKELPARAM(cx, cy));
}
int SubItemHitTest(LPLVHITTESTINFO lpInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_SUBITEMHITTEST, 0, (LPARAM)lpInfo);
}
int AddColumn(LPCTSTR strItem, int nItem, int nSubItem = -1,
int nMask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
int nFmt = LVCFMT_LEFT)
{
const int cxOffset = 15;
ATLASSERT(::IsWindow(m_hWnd));
LVCOLUMN lvc = { 0 };
lvc.mask = nMask;
lvc.fmt = nFmt;
lvc.pszText = (LPTSTR)strItem;
lvc.cx = GetStringWidth(lvc.pszText) + cxOffset;
if(nMask & LVCF_SUBITEM)
lvc.iSubItem = (nSubItem != -1) ? nSubItem : nItem;
return InsertColumn(nItem, &lvc);
}
int AddItem(int nItem, int nSubItem, LPCTSTR strItem, int nImageIndex = -1)
{
ATLASSERT(::IsWindow(m_hWnd));
LVITEM lvItem = { 0 };
lvItem.mask = LVIF_TEXT;
lvItem.iItem = nItem;
lvItem.iSubItem = nSubItem;
lvItem.pszText = (LPTSTR)strItem;
if(nImageIndex != -1)
{
lvItem.mask |= LVIF_IMAGE;
lvItem.iImage = nImageIndex;
}
if(nSubItem == 0)
return InsertItem(&lvItem);
return SetItem(&lvItem) ? nItem : -1;
}
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
BOOL SortItemsEx(PFNLVCOMPARE pfnCompare, LPARAM lParamSort)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SORTITEMSEX, (WPARAM)lParamSort, (LPARAM)pfnCompare);
}
#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
#if (_WIN32_WINNT >= 0x0501)
int InsertGroup(int nItem, PLVGROUP pGroup)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_INSERTGROUP, nItem, (LPARAM)pGroup);
}
int RemoveGroup(int nGroupID)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_REMOVEGROUP, nGroupID, 0L);
}
void MoveGroup(int nGroupID, int nItem)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_MOVEGROUP, nGroupID, nItem);
}
void MoveItemToGroup(int nItem, int nGroupID)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_MOVEITEMTOGROUP, nItem, nGroupID);
}
int EnableGroupView(BOOL bEnable)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_ENABLEGROUPVIEW, bEnable, 0L);
}
int SortGroups(PFNLVGROUPCOMPARE pCompareFunc, LPVOID lpVoid = NULL)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_SORTGROUPS, (WPARAM)pCompareFunc, (LPARAM)lpVoid);
}
void InsertGroupSorted(PLVINSERTGROUPSORTED pInsertGroupSorted)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_INSERTGROUPSORTED, (WPARAM)pInsertGroupSorted, 0L);
}
void RemoveAllGroups()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_REMOVEALLGROUPS, 0, 0L);
}
BOOL HasGroup(int nGroupID)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_HASGROUP, nGroupID, 0L);
}
BOOL InsertMarkHitTest(LPPOINT lpPoint, LPLVINSERTMARK pInsertMark) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_INSERTMARKHITTEST, (WPARAM)lpPoint, (LPARAM)pInsertMark);
}
BOOL SetInfoTip(PLVSETINFOTIP pSetInfoTip)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, LVM_SETINFOTIP, 0, (LPARAM)pSetInfoTip);
}
void CancelEditLabel()
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, LVM_CANCELEDITLABEL, 0, 0L);
}
UINT MapIndexToID(int nIndex) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, LVM_MAPINDEXTOID, nIndex, 0L);
}
int MapIDToIndex(UINT uID) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, LVM_MAPIDTOINDEX, uID, 0L);
}
#endif // (_WIN32_WINNT >= 0x0501)
// single-selection only
BOOL SelectItem(int nIndex)
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & LVS_SINGLESEL) != 0);
BOOL bRet = SetItemState(nIndex, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
if(bRet)
bRet = EnsureVisible(nIndex, FALSE);
return bRet;
}
};
typedef CListViewCtrlT<ATL::CWindow> CListViewCtrl;
///////////////////////////////////////////////////////////////////////////////
// CTreeViewCtrl
template <class TBase>
class CTreeViewCtrlT : public TBase
{
public:
// Constructors
CTreeViewCtrlT(HWND hWnd = NULL) : TBase(hWnd)
{ }
CTreeViewCtrlT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
HWND Create(HWND hWndParent, ATL::_U_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
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, TVM_GETCOUNT, 0, 0L);
}
UINT GetIndent() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, TVM_GETINDENT, 0, 0L);
}
void SetIndent(UINT nIndent)
{
ATLASSERT(::IsWindow(m_hWnd));
::SendMessage(m_hWnd, TVM_SETINDENT, nIndent, 0L);
}
CImageList GetImageList(int nImageListType = TVSIL_NORMAL) const
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_GETIMAGELIST, (WPARAM)nImageListType, 0L));
}
CImageList SetImageList(HIMAGELIST hImageList, int nImageListType = TVSIL_NORMAL)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_SETIMAGELIST, (WPARAM)nImageListType, (LPARAM)hImageList));
}
BOOL GetItem(LPTVITEM pItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)pItem);
}
BOOL SetItem(LPTVITEM pItem)
{
ATLASSERT(::IsWindow(m_hWnd));
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)
{
ATLASSERT(::IsWindow(m_hWnd));
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
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(lpstrText != NULL);
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);
}
#ifndef _ATL_NO_COM
BOOL GetItemText(HTREEITEM hItem, BSTR& bstrText) const
{
USES_CONVERSION;
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT(bstrText == NULL);
TVITEM item = { 0 };
item.hItem = hItem;
item.mask = TVIF_TEXT;
LPTSTR lpstrText = NULL;
BOOL bRet = FALSE;
for(int nLen = 256; ; nLen *= 2)
{
ATLTRY(lpstrText = new TCHAR[nLen]);
if(lpstrText == NULL)
break;
lpstrText[0] = NULL;
item.pszText = lpstrText;
item.cchTextMax = nLen;
bRet = (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
if(!bRet || (lstrlen(item.pszText) < nLen - 1))
break;
delete [] lpstrText;
lpstrText = NULL;
}
if(lpstrText != NULL)
{
if(bRet)
bstrText = ::SysAllocString(T2OLE(lpstrText));
delete [] lpstrText;
}
return (bstrText != NULL) ? TRUE : FALSE;
}
#endif // !_ATL_NO_COM
#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
BOOL GetItemText(HTREEITEM hItem, _CSTRING_NS::CString& strText) const
{
ATLASSERT(::IsWindow(m_hWnd));
TVITEM item = { 0 };
item.hItem = hItem;
item.mask = TVIF_TEXT;
strText.Empty();
BOOL bRet = FALSE;
for(int nLen = 256; ; nLen *= 2)
{
item.pszText = strText.GetBufferSetLength(nLen);
if(item.pszText == NULL)
{
bRet = FALSE;
break;
}
item.cchTextMax = nLen;
bRet = (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
if(!bRet || (lstrlen(item.pszText) < nLen - 1))
break;
}
strText.ReleaseBuffer();
return bRet;
}
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
BOOL SetItemText(HTREEITEM hItem, LPCTSTR lpszItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItem(hItem, TVIF_TEXT, lpszItem, 0, 0, 0, 0, NULL);
}
BOOL GetItemImage(HTREEITEM hItem, int& nImage, int& nSelectedImage) const
{
ATLASSERT(::IsWindow(m_hWnd));
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)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItem(hItem, TVIF_IMAGE|TVIF_SELECTEDIMAGE, NULL, nImage, nSelectedImage, 0, 0, NULL);
}
UINT GetItemState(HTREEITEM hItem, UINT nStateMask) const
{
ATLASSERT(::IsWindow(m_hWnd));
#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
return (UINT)::SendMessage(m_hWnd, TVM_GETITEMSTATE, (WPARAM)hItem, (LPARAM)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;
#endif // !((_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE))
}
BOOL SetItemState(HTREEITEM hItem, UINT nState, UINT nStateMask)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItem(hItem, TVIF_STATE, NULL, 0, 0, nState, nStateMask, NULL);
}
DWORD_PTR GetItemData(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
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 ? item.lParam : NULL);
}
BOOL SetItemData(HTREEITEM hItem, DWORD_PTR dwData)
{
ATLASSERT(::IsWindow(m_hWnd));
return SetItem(hItem, TVIF_PARAM, NULL, 0, 0, 0, 0, (LPARAM)dwData);
}
CEdit GetEditControl() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CEdit((HWND)::SendMessage(m_hWnd, TVM_GETEDITCONTROL, 0, 0L));
}
UINT GetVisibleCount() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, TVM_GETVISIBLECOUNT, 0, 0L);
}
BOOL GetItemRect(HTREEITEM hItem, LPRECT lpRect, BOOL bTextOnly) const
{
ATLASSERT(::IsWindow(m_hWnd));
*(HTREEITEM*)lpRect = hItem;
return (BOOL)::SendMessage(m_hWnd, TVM_GETITEMRECT, (WPARAM)bTextOnly, (LPARAM)lpRect);
}
BOOL ItemHasChildren(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
TVITEM item = { 0 };
item.hItem = hItem;
item.mask = TVIF_CHILDREN;
::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
return item.cChildren;
}
#ifndef _WIN32_WCE
CToolTipCtrl GetToolTips() const
{
ATLASSERT(::IsWindow(m_hWnd));
return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TVM_GETTOOLTIPS, 0, 0L));
}
CToolTipCtrl SetToolTips(HWND hWndTT)
{
ATLASSERT(::IsWindow(m_hWnd));
return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TVM_SETTOOLTIPS, (WPARAM)hWndTT, 0L));
}
#endif // !_WIN32_WCE
int GetISearchString(LPTSTR lpstr) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TVM_GETISEARCHSTRING, 0, (LPARAM)lpstr);
}
// checkboxes only
BOOL GetCheckState(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
ATLASSERT((GetStyle() & TVS_CHECKBOXES) != 0);
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
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_GETBKCOLOR, 0, 0L);
}
COLORREF SetBkColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_SETBKCOLOR, 0, (LPARAM)clr);
}
COLORREF GetInsertMarkColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_GETINSERTMARKCOLOR, 0, 0L);
}
COLORREF SetInsertMarkColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_SETINSERTMARKCOLOR, 0, (LPARAM)clr);
}
int GetItemHeight() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TVM_GETITEMHEIGHT, 0, 0L);
}
int SetItemHeight(int cyHeight)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TVM_SETITEMHEIGHT, cyHeight, 0L);
}
int GetScrollTime() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TVM_GETSCROLLTIME, 0, 0L);
}
int SetScrollTime(int nScrollTime)
{
ATLASSERT(::IsWindow(m_hWnd));
return (int)::SendMessage(m_hWnd, TVM_SETSCROLLTIME, nScrollTime, 0L);
}
COLORREF GetTextColor() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_GETTEXTCOLOR, 0, 0L);
}
COLORREF SetTextColor(COLORREF clr)
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_SETTEXTCOLOR, 0, (LPARAM)clr);
}
BOOL GetUnicodeFormat() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_GETUNICODEFORMAT, 0, 0L);
}
BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
{
ATLASSERT(::IsWindow(m_hWnd));
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
{
ATLASSERT(::IsWindow(m_hWnd));
return (COLORREF)::SendMessage(m_hWnd, TVM_GETLINECOLOR, 0, 0L);
}
COLORREF SetLineColor(COLORREF clrNew /*= CLR_DEFAULT*/)
{
ATLASSERT(::IsWindow(m_hWnd));
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
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)pItem);
}
BOOL SetItem(LPTVITEMEX pItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SETITEM, 0, (LPARAM)pItem);
}
#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
// Operations
HTREEITEM InsertItem(LPTVINSERTSTRUCT lpInsertStruct)
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)lpInsertStruct);
}
HTREEITEM InsertItem(LPCTSTR lpszItem, int nImage,
int nSelectedImage, HTREEITEM hParent, HTREEITEM hInsertAfter)
{
ATLASSERT(::IsWindow(m_hWnd));
return InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE, lpszItem, nImage, nSelectedImage, 0, 0, 0, hParent, hInsertAfter);
}
HTREEITEM InsertItem(LPCTSTR lpszItem, HTREEITEM hParent, HTREEITEM hInsertAfter)
{
ATLASSERT(::IsWindow(m_hWnd));
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)
{
ATLASSERT(::IsWindow(m_hWnd));
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)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_DELETEITEM, 0, (LPARAM)hItem);
}
BOOL DeleteAllItems()
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
}
BOOL Expand(HTREEITEM hItem, UINT nCode = TVE_EXPAND)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_EXPAND, nCode, (LPARAM)hItem);
}
HTREEITEM GetNextItem(HTREEITEM hItem, UINT nCode) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, nCode, (LPARAM)hItem);
}
HTREEITEM GetChildItem(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem);
}
HTREEITEM GetNextSiblingItem(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem);
}
HTREEITEM GetPrevSiblingItem(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUS, (LPARAM)hItem);
}
HTREEITEM GetParentItem(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hItem);
}
HTREEITEM GetFirstVisibleItem() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_FIRSTVISIBLE, 0L);
}
HTREEITEM GetNextVisibleItem(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTVISIBLE, (LPARAM)hItem);
}
HTREEITEM GetPrevVisibleItem(HTREEITEM hItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUSVISIBLE, (LPARAM)hItem);
}
HTREEITEM GetSelectedItem() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CARET, 0L);
}
HTREEITEM GetDropHilightItem() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_DROPHILITE, 0L);
}
HTREEITEM GetRootItem() const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_ROOT, 0L);
}
BOOL Select(HTREEITEM hItem, UINT nCode)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, nCode, (LPARAM)hItem);
}
BOOL SelectItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hItem);
}
BOOL SelectDropTarget(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, TVGN_DROPHILITE, (LPARAM)hItem);
}
BOOL SelectSetFirstVisible(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, TVGN_FIRSTVISIBLE, (LPARAM)hItem);
}
CEdit EditLabel(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return CEdit((HWND)::SendMessage(m_hWnd, TVM_EDITLABEL, 0, (LPARAM)hItem));
}
BOOL EndEditLabelNow(BOOL bCancel)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_ENDEDITLABELNOW, bCancel, 0L);
}
HTREEITEM HitTest(TVHITTESTINFO* pHitTestInfo) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo);
}
HTREEITEM HitTest(POINT pt, UINT* pFlags) const
{
ATLASSERT(::IsWindow(m_hWnd));
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)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SORTCHILDREN, (WPARAM)bRecurse, (LPARAM)hItem);
}
BOOL EnsureVisible(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_ENSUREVISIBLE, 0, (LPARAM)hItem);
}
BOOL SortChildrenCB(LPTVSORTCB pSort, BOOL bRecurse = FALSE)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SORTCHILDRENCB, (WPARAM)bRecurse, (LPARAM)pSort);
}
CImageList RemoveImageList(int nImageList)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_SETIMAGELIST, (WPARAM)nImageList, NULL));
}
CImageList CreateDragImage(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_CREATEDRAGIMAGE, 0, (LPARAM)hItem));
}
#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
BOOL SetInsertMark(HTREEITEM hTreeItem, BOOL bAfter)
{
ATLASSERT(::IsWindow(m_hWnd));
return (BOOL)::SendMessage(m_hWnd, TVM_SETINSERTMARK, bAfter, (LPARAM)hTreeItem);
}
BOOL RemoveInsertMark()
{
ATLASSERT(::IsWindow(m_hWnd));
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
{
ATLASSERT(::IsWindow(m_hWnd));
return (HTREEITEM)::SendMessage(m_hWnd, TVM_MAPACCIDTOHTREEITEM, uID, 0L);
}
UINT MapHTREEITEMToAccID(HTREEITEM hTreeItem) const
{
ATLASSERT(::IsWindow(m_hWnd));
return (UINT)::SendMessage(m_hWnd, TVM_MAPHTREEITEMTOACCID, (WPARAM)hTreeItem, 0L);
}
#endif // (_WIN32_WINNT >= 0x0501)
};
typedef CTreeViewCtrlT<ATL::CWindow> CTreeViewCtrl;
///////////////////////////////////////////////////////////////////////////////
// CTreeViewCtrlEx
// forward declaration
template <class TBase> class CTreeViewCtrlExT;
// Note: TBase here is for CTreeViewCtrlExT, and not for CTreeItemT itself
template <class TBase>
class CTreeItemT
{
public:
HTREEITEM m_hTreeItem;
CTreeViewCtrlExT<TBase>* m_pTreeView;
// Construction
CTreeItemT(HTREEITEM hTreeItem = NULL, CTreeViewCtrlExT<TBase>* pTreeView = NULL) : m_hTreeItem(hTreeItem), m_pTreeView(pTreeView)
{ }
CTreeItemT(const CTreeItemT<TBase>& posSrc)
{
*this = posSrc;
}
operator HTREEITEM() { return m_hTreeItem; }
CTreeItemT<TBase>& operator =(const CTreeItemT<TBase>& itemSrc)
{
m_hTreeItem = itemSrc.m_hTreeItem;
m_pTreeView = itemSrc.m_pTreeView;
return *this;
}
// Attributes
CTreeViewCtrlExT<TBase>* GetTreeView() const { return m_pTreeView; }
BOOL operator !() const { return m_hTreeItem == NULL; }
BOOL IsNull() const { return m_hTreeItem == NULL; }
BOOL GetRect(LPRECT lpRect, BOOL bTextOnly) const;
BOOL GetText(LPTSTR lpstrText, int nLen) const;
#ifndef _ATL_NO_COM
BOOL GetText(BSTR& bstrText) const;
#endif // !_ATL_NO_COM
#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
BOOL GetText(_CSTRING_NS::CString& strText) const;
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
BOOL SetText(LPCTSTR lpszItem);
BOOL GetImage(int& nImage, int& nSelectedImage) const;
BOOL SetImage(int nImage, int nSelectedImage);
UINT GetState(UINT nStateMask) const;
BOOL SetState(UINT nState, UINT nStateMask);
DWORD_PTR GetData() const;
BOOL SetData(DWORD_PTR dwData);
BOOL SetItem(UINT nMask, LPCTSTR lpszItem, int nImage, int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam);
// Operations
CTreeItemT<TBase> InsertAfter(LPCTSTR lpstrItem, HTREEITEM hItemAfter, int nImageIndex)
{
return _Insert(lpstrItem, nImageIndex, hItemAfter);
}
CTreeItemT<TBase> AddHead(LPCTSTR lpstrItem, int nImageIndex)
{
return _Insert(lpstrItem, nImageIndex, TVI_FIRST);
}
CTreeItemT<TBase> AddTail(LPCTSTR lpstrItem, int nImageIndex)
{
return _Insert(lpstrItem, nImageIndex, TVI_LAST);
}
CTreeItemT<TBase> GetChild() const;
CTreeItemT<TBase> GetNext(UINT nCode) const;
CTreeItemT<TBase> GetNextSibling() const;
CTreeItemT<TBase> GetPrevSibling() const;
CTreeItemT<TBase> GetParent() const;
CTreeItemT<TBase> GetFirstVisible() const;
CTreeItemT<TBase> GetNextVisible() const;
CTreeItemT<TBase> GetPrevVisible() const;
CTreeItemT<TBase> GetSelected() const;
CTreeItemT<TBase> GetDropHilight() const;
CTreeItemT<TBase> GetRoot() const;
BOOL HasChildren() const;
BOOL Delete();
BOOL Expand(UINT nCode = TVE_EXPAND);
BOOL Select(UINT nCode);
BOOL Select();
BOOL SelectDropTarget();
BOOL SelectSetFirstVisible();
HWND EditLabel();
HIMAGELIST CreateDragImage();
BOOL SortChildren(BOOL bRecurse = FALSE);
BOOL EnsureVisible();
CTreeItemT<TBase> _Insert(LPCTSTR lpstrItem, int nImageIndex, HTREEITEM hItemAfter);
int GetImageIndex() const;
#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
BOOL SetInsertMark(BOOL bAfter);
#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
#if (_WIN32_WINNT >= 0x0501)
UINT MapHTREEITEMToAccID() const;
#endif // (_WIN32_WINNT >= 0x0501)
};
typedef CTreeItemT<ATL::CWindow> CTreeItem;
template <class TBase>
class CTreeViewCtrlExT : public CTreeViewCtrlT< TBase >
{
public:
// Constructors
CTreeViewCtrlExT(HWND hWnd = NULL) : CTreeViewCtrlT< TBase >(hWnd)
{ }
CTreeViewCtrlExT< TBase >& operator =(HWND hWnd)
{
m_hWnd = hWnd;
return *this;
}
// Operations (overides that return CTreeItem)
CTreeItemT<TBase> InsertItem(LPTVINSERTSTRUCT lpInsertStruct)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)lpInsertStruct);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> InsertItem(LPCTSTR lpszItem, int nImage,
int nSelectedImage, HTREEITEM hParent, HTREEITEM hInsertAfter)
{
ATLASSERT(::IsWindow(m_hWnd));
return InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE, lpszItem, nImage, nSelectedImage, 0, 0, 0, hParent, hInsertAfter);
}
CTreeItemT<TBase> InsertItem(LPCTSTR lpszItem, HTREEITEM hParent, HTREEITEM hInsertAfter)
{
ATLASSERT(::IsWindow(m_hWnd));
return InsertItem(TVIF_TEXT, lpszItem, 0, 0, 0, 0, 0, hParent, hInsertAfter);
}
CTreeItemT<TBase> GetNextItem(HTREEITEM hItem, UINT nCode)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, nCode, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetChildItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetNextSiblingItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetPrevSiblingItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUS, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetParentItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetFirstVisibleItem()
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_FIRSTVISIBLE, 0L);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetNextVisibleItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTVISIBLE, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetPrevVisibleItem(HTREEITEM hItem)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUSVISIBLE, (LPARAM)hItem);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetSelectedItem()
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CARET, 0L);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetDropHilightItem()
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_DROPHILITE, 0L);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> GetRootItem()
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_ROOT, 0L);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> HitTest(TVHITTESTINFO* pHitTestInfo)
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> InsertItem(UINT nMask, LPCTSTR lpszItem, int nImage,
int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam,
HTREEITEM hParent, HTREEITEM hInsertAfter)
{
ATLASSERT(::IsWindow(m_hWnd));
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;
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)&tvis);
return CTreeItemT<TBase>(hTreeItem, this);
}
CTreeItemT<TBase> HitTest(POINT pt, UINT* pFlags)
{
ATLASSERT(::IsWindow(m_hWnd));
TVHITTESTINFO hti = { 0 };
hti.pt = pt;
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)&hti);
if (pFlags != NULL)
*pFlags = hti.flags;
return CTreeItemT<TBase>(hTreeItem, this);
}
#if (_WIN32_WINNT >= 0x0501)
CTreeItemT<TBase> MapAccIDToHTREEITEM(UINT uID) const
{
ATLASSERT(::IsWindow(m_hWnd));
HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_MAPACCIDTOHTREEITEM, uID, 0L);
return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlEx*)this);
}
#endif // (_WIN32_WINNT >= 0x0501)
};
typedef CTreeViewCtrlExT<ATL::CWindow> CTreeViewCtrlEx;
// CTreeItem inline methods
template <class TBase>
inline BOOL CTreeItemT<TBase>::GetRect(LPRECT lpRect, BOOL bTextOnly) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemRect(m_hTreeItem,lpRect,bTextOnly);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNext(UINT nCode) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetNextItem(m_hTreeItem,nCode);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetChild() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetChildItem(m_hTreeItem);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNextSibling() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetNextSiblingItem(m_hTreeItem);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetPrevSibling() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetPrevSiblingItem(m_hTreeItem);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetParent() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetParentItem(m_hTreeItem);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetFirstVisible() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetFirstVisibleItem();
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNextVisible() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetNextVisibleItem(m_hTreeItem);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetPrevVisible() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetPrevVisibleItem(m_hTreeItem);
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetSelected() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetSelectedItem();
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetDropHilight() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetDropHilightItem();
}
template <class TBase>
inline CTreeItemT<TBase> CTreeItemT<TBase>::GetRoot() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetRootItem();
}
template <class TBase>
inline BOOL CTreeItemT<TBase>::GetText(LPTSTR lpstrText, int nLen) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemText(m_hTreeItem, lpstrText, nLen);
}
#ifndef _ATL_NO_COM
#ifdef _OLEAUTO_H_
template <class TBase>
inline BOOL CTreeItemT<TBase>::GetText(BSTR& bstrText) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemText(m_hTreeItem, bstrText);
}
#endif // _OLEAUTO_H_
#endif // !_ATL_NO_COM
#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
template <class TBase>
inline BOOL CTreeItemT<TBase>::GetText(_CSTRING_NS::CString& strText) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemText(m_hTreeItem, strText);
}
#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
template <class TBase>
inline BOOL CTreeItemT<TBase>::GetImage(int& nImage, int& nSelectedImage) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemImage(m_hTreeItem,nImage,nSelectedImage);
}
template <class TBase>
inline UINT CTreeItemT<TBase>::GetState(UINT nStateMask) const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemState(m_hTreeItem,nStateMask);
}
template <class TBase>
inline DWORD_PTR CTreeItemT<TBase>::GetData() const
{
ATLASSERT(m_pTreeView != NULL);
return m_pTreeView->GetItemData(m_hTreeItem);
}
template <class TBase>
inline BOOL CTreeItemT<TBase>::SetItem(UINT nMask, LPCTSTR lpszItem, int nImage,
int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam)