// WTL Version 3.1 // Copyright (C) 1997-2000 Microsoft Corporation // All rights reserved. // // This file is a part of Windows Template Library. // The code and information is provided "as-is" without // warranty of any kind, either expressed or implied. #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 #include #include // protect template members from windowsx.h macros #ifdef _INC_WINDOWSX #undef GetNextSibling #undef GetPrevSibling #endif //_INC_WINDOWSX 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 // { // public: // BEGIN_MSG_MAP(CMyListBox) // // put your message handler entries here // END_MSG_MAP() // }; ///////////////////////////////////////////////////////////////////////////// // Forward declarations template class CStaticT; template class CButtonT; template class CListBoxT; template class CComboBoxT; template class CEditT; template class CEditCommands; template class CScrollBarT; class CImageList; template class CListViewCtrlT; template class CTreeViewCtrlT; class CTreeItem; template class CTreeViewCtrlExT; template class CHeaderCtrlT; template class CToolBarCtrlT; template class CStatusBarCtrlT; template class CTabCtrlT; class CToolInfo; template class CToolTipCtrlT; template class CTrackBarCtrlT; template class CUpDownCtrlT; template class CProgressBarCtrlT; template class CHotKeyCtrlT; template class CAnimateCtrlT; template class CRichEditCtrlT; template class CRichEditCommands; template class CDragListBoxT; template class CDragListNotifyImpl; template class CReBarCtrlT; template class CComboBoxExT; template class CDateTimePickerCtrlT; template class CMonthCalendarCtrlT; #if (_WIN32_IE >= 0x0400) template class CFlatScrollBarImpl; template class CFlatScrollBarT; template class CIPAddressCtrlT; template class CPagerCtrlT; #endif //(_WIN32_IE >= 0x0400) template class CCustomDraw; // --- Standard Windows controls --- ///////////////////////////////////////////////////////////////////////////// // CStatic - client side for a Windows STATIC control template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return _T("STATIC"); } 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); } 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 CStatic; ///////////////////////////////////////////////////////////////////////////// // CButton - client side for a Windows BUTTON control template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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) & 0xff; } void SetButtonStyle(UINT nStyle, BOOL bRedraw = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, BM_SETSTYLE, nStyle, (LPARAM)bRedraw); } 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)); } // Operations void Click() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, BM_CLICK, 0, 0L); } }; typedef CButtonT CButton; ///////////////////////////////////////////////////////////////////////////// // CListBox - client side for a Windows LISTBOX control template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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); } 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); } 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); } // 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 #ifdef __ATLSTR_H__ int GetText(int nIndex, CString& strText) const { ATLASSERT(::IsWindow(m_hWnd)); int nRet = GetText(nIndex, strText.GetBufferSetLength(GetTextLen(nIndex))); strText.ReleaseBuffer(); return nRet; } #endif //__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); } 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); } // 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); } }; typedef CListBoxT CListBox; ///////////////////////////////////////////////////////////////////////////// // CComboBox - client side for a Windows COMBOBOX control template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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); } // 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 #ifdef __ATLSTR_H__ int GetLBText(int nIndex, CString& strText) const { ATLASSERT(::IsWindow(m_hWnd)); int nRet = GetLBText(nIndex, strText.GetBufferSetLength(GetLBTextLen(nIndex))); strText.ReleaseBuffer(); return nRet; } #endif //__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); } // 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); } int Dir(UINT attr, LPCTSTR lpszWildCard) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, CB_DIR, attr, (LPARAM)lpszWildCard); } // 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 CComboBox; ///////////////////////////////////////////////////////////////////////////// // CEdit - client side for a Windows EDIT control template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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); } 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); } 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); } 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); } int GetFirstVisibleLine() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L); } int GetThumb() const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((GetStyle() & ES_MULTILINE) != 0); return (int)::SendMessage(m_hWnd, EM_GETTHUMB, 0, 0L); } BOOL SetReadOnly(BOOL bReadOnly = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_SETREADONLY, bReadOnly, 0L); } #if (WINVER >= 0x0500) 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) // 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); } // 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); } }; typedef CEditT 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, // public CEditCommands // { // public: // BEGIN_MSG_MAP(CMyEdit) // // your handlers... // CHAIN_MSG_MAP_ALT(CEditCommands, 1) // END_MSG_MAP() // // other stuff... // }; template 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(this); pT->Clear(); return 0; } LRESULT OnEditClearAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(this); pT->SetSel(0, -1); pT->Clear(); return 0; } LRESULT OnEditCopy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(this); pT->Copy(); return 0; } LRESULT OnEditCut(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(this); pT->Cut(); return 0; } LRESULT OnEditPaste(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(this); pT->Paste(); return 0; } LRESULT OnEditSelectAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(this); pT->SetSel(0, -1); return 0; } LRESULT OnEditUndo(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(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(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(this); return (pT->GetWindowTextLength() > 0); } }; ///////////////////////////////////////////////////////////////////////////// // CScrollBar - client side for a Windows SCROLLBAR control template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return _T("SCROLLBAR"); } int GetScrollPos() const { ATLASSERT(::IsWindow(m_hWnd)); return ::GetScrollPos(m_hWnd, SB_CTL); } int SetScrollPos(int nPos, BOOL bRedraw = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return ::SetScrollPos(m_hWnd, SB_CTL, nPos, bRedraw); } void GetScrollRange(LPINT lpMinPos, LPINT lpMaxPos) const { ATLASSERT(::IsWindow(m_hWnd)); ::GetScrollRange(m_hWnd, SB_CTL, lpMinPos, lpMaxPos); } 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); } int GetScrollLimit() const { int nMin, nMax; ::GetScrollRange(m_hWnd, SB_CTL, &nMin, &nMax); SCROLLINFO info; 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; } // 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); } }; typedef CScrollBarT 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(_U_STRINGorID bitmap, int cx, int nGrow, COLORREF crMask) { ATLASSERT(m_hImageList == NULL); m_hImageList = ImageList_LoadBitmap(_Module.GetResourceInstance(), bitmap.m_lpstr, cx, nGrow, crMask); return (m_hImageList != NULL) ? TRUE : FALSE; } BOOL CreateFromImage(_U_STRINGorID image, int cx, int nGrow, COLORREF crMask, UINT uType, UINT uFlags = LR_DEFAULTCOLOR | LR_DEFAULTSIZE) { ATLASSERT(m_hImageList == NULL); m_hImageList = ImageList_LoadImage(_Module.GetResourceInstance(), image.m_lpstr, cx, nGrow, crMask, uType, uFlags); 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; } BOOL Destroy() { if (m_hImageList == NULL) return FALSE; BOOL bRet = ImageList_Destroy(Detach()); 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); } HIMAGELIST Read(LPSTREAM lpStream) { ATLASSERT(m_hImageList == NULL); return ImageList_Read(lpStream); } BOOL Write(LPSTREAM lpStream) { ATLASSERT(m_hImageList != NULL); return ImageList_Write(m_hImageList, lpStream); } // 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() { 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 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; hinst = _Module.GetResourceInstance(); lpszText = lpstrText; lParam = lUserParam; } }; template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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) // 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, _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; memset(&hti, 0, sizeof(hti)); 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(_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) }; typedef CToolTipCtrlT CToolTipCtrl; ///////////////////////////////////////////////////////////////////////////// // CHeaderCtrl template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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) 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) #if (_WIN32_IE >= 0x0500) 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) // 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) 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) }; typedef CHeaderCtrlT CHeaderCtrl; ///////////////////////////////////////////////////////////////////////////// // CListViewCtrl template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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); } void SetItemCount(int nItems) { ATLASSERT(::IsWindow(m_hWnd)); ::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; 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)); return SetItem(nItem, 0, LVIF_STATE, NULL, 0, nState, nStateMask, 0); } 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; memset(&lvi, 0, sizeof(LVITEM)); 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 #ifdef __ATLSTR_H__ int GetItemText(int nItem, int nSubItem, CString& strText) const { ATLASSERT(::IsWindow(m_hWnd)); LVITEM lvi; memset(&lvi, 0, sizeof(LVITEM)); lvi.iSubItem = nSubItem; strText.Empty(); int nRes = 0; for(int nLen = 256; ; nLen *= 2) { lvi.cchTextMax = nLen; lvi.pszText = strText.GetBufferSetLength(nLen); nRes = (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi); if(nRes < nLen - 1) break; } strText.ReleaseBuffer(); return nRes; } #endif //__ATLSTR_H__ int GetItemText(int nItem, int nSubItem, LPTSTR lpszText, int nLen) const { ATLASSERT(::IsWindow(m_hWnd)); LVITEM lvi; memset(&lvi, 0, sizeof(LVITEM)); 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; memset(&lvi, 0, sizeof(LVITEM)); lvi.iItem = nItem; lvi.mask = LVIF_PARAM; ::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)&lvi); return (DWORD_PTR)lvi.lParam; } 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, LV_COLUMN* pColumn) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, LVM_GETCOLUMN, nCol, (LPARAM)pColumn); } BOOL SetColumn(int nCol, const LV_COLUMN* 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); } 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); } 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); } // 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) 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); } 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); } 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); } void SetItemCountEx(int nItems, DWORD dwFlags) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(((GetStyle() & LVS_OWNERDATA) != 0) && (((GetStyle() & LVS_TYPEMASK) == LVS_REPORT) || ((GetStyle() & LVS_TYPEMASK) == LVS_LIST))); ::SendMessage(m_hWnd, LVM_SETITEMCOUNT, nItems, dwFlags); } 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_IE >= 0x0400) // Operations int InsertColumn(int nCol, const LV_COLUMN* pColumn) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, LVM_INSERTCOLUMN, nCol, (LPARAM)pColumn); } int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat, int nWidth, int nSubItem) { LV_COLUMN column; 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; } 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; 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(LV_FINDINFO* pFindInfo, int nStart) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, LVM_FINDITEM, nStart, (LPARAM)pFindInfo); } int HitTest(LV_HITTESTINFO* 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)); LV_HITTESTINFO hti; 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) { 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) { ATLASSERT(::IsWindow(m_hWnd)); LV_COLUMN lvc; lvc.mask = nMask; lvc.fmt = nFmt; lvc.pszText = (LPTSTR)strItem; lvc.cx = GetStringWidth(lvc.pszText) + 15; 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; 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) 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) // 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 CListViewCtrl; ///////////////////////////////////////////////////////////////////////////// // CTreeViewCtrl template 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, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::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(UINT nImageList) const { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_GETIMAGELIST, (UINT)nImageList, 0L)); } CImageList SetImageList(HIMAGELIST hImageList, int nImageListType) { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_SETIMAGELIST, (UINT)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; 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; 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; 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 #ifdef __ATLSTR_H__ BOOL GetItemText(HTREEITEM hItem, CString& strText) const { ATLASSERT(::IsWindow(m_hWnd)); TVITEM item; item.hItem = hItem; item.mask = TVIF_TEXT; strText.Empty(); BOOL bRet = FALSE; for(int nLen = 256; ; nLen *= 2) { item.pszText = strText.GetBufferSetLength(nLen); 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 //__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; 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)); TVITEM item; item.hItem = hItem; item.mask = TVIF_STATE; item.stateMask = nStateMask; item.state = 0; ::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item); return item.state; } 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; item.hItem = hItem; item.mask = TVIF_PARAM; ::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item); return (DWORD_PTR)item.lParam; } 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; item.hItem = hItem; item.mask = TVIF_CHILDREN; ::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item); return item.cChildren; } 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)); } 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) 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) #if (_WIN32_IE >= 0x0500) 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) // Operations HTREEITEM InsertItem(LPTV_INSERTSTRUCT 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)); TV_INSERTSTRUCT tvis; 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(TV_HITTESTINFO* pHitTestInfo) { ATLASSERT(::IsWindow(m_hWnd)); return (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo); } HTREEITEM HitTest(POINT pt, UINT* pFlags) { ATLASSERT(::IsWindow(m_hWnd)); TV_HITTESTINFO hti; 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) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TVM_SORTCHILDREN, 0, (LPARAM)hItem); } BOOL EnsureVisible(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TVM_ENSUREVISIBLE, 0, (LPARAM)hItem); } BOOL SortChildrenCB(LPTV_SORTCB pSort) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TVM_SORTCHILDRENCB, 0, (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) 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) }; typedef CTreeViewCtrlT CTreeViewCtrl; ///////////////////////////////////////////////////////////////////////////// // CTreeViewCtrlEx typedef CTreeViewCtrlExT CTreeViewCtrlEx; // forward declaration class CTreeItem { public: HTREEITEM m_hTreeItem; CTreeViewCtrlEx* m_pTreeView; // Construction CTreeItem(HTREEITEM hTreeItem = NULL, CTreeViewCtrlEx* pTreeView = NULL) : m_hTreeItem(hTreeItem), m_pTreeView(pTreeView) { } CTreeItem(const CTreeItem& posSrc) { *this = posSrc; } operator HTREEITEM() { return m_hTreeItem; } CTreeItem& operator =(const CTreeItem& itemSrc) { m_hTreeItem = itemSrc.m_hTreeItem; m_pTreeView = itemSrc.m_pTreeView; return *this; } // Attributes CTreeViewCtrlEx* 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 #ifdef __ATLSTR_H__ BOOL GetText(CString& strText) const; #endif //__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 CTreeItem InsertAfter(LPCTSTR lpstrItem, HTREEITEM hItemAfter, int nImageIndex) { return _Insert(lpstrItem, nImageIndex, hItemAfter); } CTreeItem AddHead(LPCTSTR lpstrItem, int nImageIndex) { return _Insert(lpstrItem, nImageIndex, TVI_FIRST); } CTreeItem AddTail(LPCTSTR lpstrItem, int nImageIndex) { return _Insert(lpstrItem, nImageIndex, TVI_LAST); } CTreeItem GetChild() const; CTreeItem GetNext(UINT nCode) const; CTreeItem GetNextSibling() const; CTreeItem GetPrevSibling() const; CTreeItem GetParent() const; CTreeItem GetFirstVisible() const; CTreeItem GetNextVisible() const; CTreeItem GetPrevVisible() const; CTreeItem GetSelected() const; CTreeItem GetDropHilight() const; CTreeItem 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 EnsureVisible(); CTreeItem _Insert(LPCTSTR lpstrItem, int nImageIndex, HTREEITEM hItemAfter); int GetImageIndex() const; #if (_WIN32_IE >= 0x0400) BOOL SetInsertMark(BOOL bAfter); #endif //(_WIN32_IE >= 0x0400) }; template 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) CTreeItem InsertItem(LPTV_INSERTSTRUCT lpInsertStruct) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)lpInsertStruct); return CTreeItem(hTreeItem, this); } CTreeItem 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); } CTreeItem InsertItem(LPCTSTR lpszItem, HTREEITEM hParent, HTREEITEM hInsertAfter) { ATLASSERT(::IsWindow(m_hWnd)); return InsertItem(TVIF_TEXT, lpszItem, 0, 0, 0, 0, 0, hParent, hInsertAfter); } CTreeItem GetNextItem(HTREEITEM hItem, UINT nCode) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, nCode, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetChildItem(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetNextSiblingItem(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetPrevSiblingItem(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUS, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetParentItem(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetFirstVisibleItem() { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_FIRSTVISIBLE, 0L); return CTreeItem(hTreeItem, this); } CTreeItem GetNextVisibleItem(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTVISIBLE, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetPrevVisibleItem(HTREEITEM hItem) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUSVISIBLE, (LPARAM)hItem); return CTreeItem(hTreeItem, this); } CTreeItem GetSelectedItem() { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CARET, 0L); return CTreeItem(hTreeItem, this); } CTreeItem GetDropHilightItem() { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_DROPHILITE, 0L); return CTreeItem(hTreeItem, this); } CTreeItem GetRootItem() { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_ROOT, 0L); return CTreeItem(hTreeItem, this); } CTreeItem HitTest(TV_HITTESTINFO* pHitTestInfo) { ATLASSERT(::IsWindow(m_hWnd)); HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo); return CTreeItem(hTreeItem, this); } CTreeItem InsertItem(UINT nMask, LPCTSTR lpszItem, int nImage, int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam, HTREEITEM hParent, HTREEITEM hInsertAfter) { ATLASSERT(::IsWindow(m_hWnd)); TV_INSERTSTRUCT tvis; 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 CTreeItem(hTreeItem, this); } CTreeItem HitTest(POINT pt, UINT* pFlags) { ATLASSERT(::IsWindow(m_hWnd)); TV_HITTESTINFO hti; hti.pt = pt; HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)&hti); if (pFlags != NULL) *pFlags = hti.flags; return CTreeItem(hTreeItem, this); } }; // CTreeItem inline methods inline BOOL CTreeItem::GetRect(LPRECT lpRect, BOOL bTextOnly) const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetItemRect(m_hTreeItem,lpRect,bTextOnly); } inline CTreeItem CTreeItem::GetNext(UINT nCode) const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetNextItem(m_hTreeItem,nCode); } inline CTreeItem CTreeItem::GetChild() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetChildItem(m_hTreeItem); } inline CTreeItem CTreeItem::GetNextSibling() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetNextSiblingItem(m_hTreeItem); } inline CTreeItem CTreeItem::GetPrevSibling() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetPrevSiblingItem(m_hTreeItem); } inline CTreeItem CTreeItem::GetParent() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetParentItem(m_hTreeItem); } inline CTreeItem CTreeItem::GetFirstVisible() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetFirstVisibleItem(); } inline CTreeItem CTreeItem::GetNextVisible() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetNextVisibleItem(m_hTreeItem); } inline CTreeItem CTreeItem::GetPrevVisible() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetPrevVisibleItem(m_hTreeItem); } inline CTreeItem CTreeItem::GetSelected() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetSelectedItem(); } inline CTreeItem CTreeItem::GetDropHilight() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetDropHilightItem(); } inline CTreeItem CTreeItem::GetRoot() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetRootItem(); } inline BOOL CTreeItem::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_ inline BOOL CTreeItem::GetText(BSTR& bstrText) const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetItemText(m_hTreeItem, bstrText); } #endif // _OLEAUTO_H_ #endif //!_ATL_NO_COM #ifdef __ATLSTR_H__ inline BOOL CTreeItem::GetText(CString& strText) const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetItemText(m_hTreeItem, strText); } #endif //__ATLSTR_H__ inline BOOL CTreeItem::GetImage(int& nImage, int& nSelectedImage) const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetItemImage(m_hTreeItem,nImage,nSelectedImage); } inline UINT CTreeItem::GetState(UINT nStateMask) const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetItemState(m_hTreeItem,nStateMask); } inline DWORD_PTR CTreeItem::GetData() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->GetItemData(m_hTreeItem); } inline BOOL CTreeItem::SetItem(UINT nMask, LPCTSTR lpszItem, int nImage, int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SetItem(m_hTreeItem, nMask, lpszItem, nImage, nSelectedImage, nState, nStateMask, lParam); } inline BOOL CTreeItem::SetText(LPCTSTR lpszItem) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SetItemText(m_hTreeItem,lpszItem); } inline BOOL CTreeItem::SetImage(int nImage, int nSelectedImage) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SetItemImage(m_hTreeItem,nImage,nSelectedImage); } inline BOOL CTreeItem::SetState(UINT nState, UINT nStateMask) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SetItemState(m_hTreeItem,nState,nStateMask); } inline BOOL CTreeItem::SetData(DWORD_PTR dwData) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SetItemData(m_hTreeItem,dwData); } inline BOOL CTreeItem::HasChildren() const { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->ItemHasChildren(m_hTreeItem); } inline BOOL CTreeItem::Delete() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->DeleteItem(m_hTreeItem); } inline BOOL CTreeItem::Expand(UINT nCode) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->Expand(m_hTreeItem,nCode); } inline BOOL CTreeItem::Select(UINT nCode) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->Select(m_hTreeItem,nCode); } inline BOOL CTreeItem::Select() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SelectItem(m_hTreeItem); } inline BOOL CTreeItem::SelectDropTarget() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SelectDropTarget(m_hTreeItem); } inline BOOL CTreeItem::SelectSetFirstVisible() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SelectSetFirstVisible(m_hTreeItem); } inline HWND CTreeItem::EditLabel() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->EditLabel(m_hTreeItem); } inline HIMAGELIST CTreeItem::CreateDragImage() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->CreateDragImage(m_hTreeItem); } inline BOOL CTreeItem::SortChildren() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SortChildren(m_hTreeItem); } inline BOOL CTreeItem::EnsureVisible() { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->EnsureVisible(m_hTreeItem); } inline CTreeItem CTreeItem::_Insert(LPCTSTR lpstrItem, int nImageIndex, HTREEITEM hItemAfter) { ATLASSERT(m_pTreeView != NULL); TV_INSERTSTRUCT ins; ins.hParent = m_hTreeItem; ins.hInsertAfter = hItemAfter; ins.item.mask = TVIF_TEXT; ins.item.pszText = (LPTSTR)lpstrItem; if(nImageIndex != -1) { ins.item.mask |= TVIF_IMAGE | TVIF_SELECTEDIMAGE; ins.item.iImage = nImageIndex; ins.item.iSelectedImage = nImageIndex; } return CTreeItem(m_pTreeView->InsertItem(&ins), m_pTreeView); } inline int CTreeItem::GetImageIndex() const { ATLASSERT(m_pTreeView != NULL); TVITEM item; item.mask = TVIF_HANDLE | TVIF_IMAGE; item.hItem = m_hTreeItem; m_pTreeView->GetItem(&item); return item.iImage; } #if (_WIN32_IE >= 0x0400) inline BOOL CTreeItem::SetInsertMark(BOOL bAfter) { ATLASSERT(m_pTreeView != NULL); return m_pTreeView->SetInsertMark(m_hTreeItem, bAfter); } #endif //(_WIN32_IE >= 0x0400) ///////////////////////////////////////////////////////////////////////////// // CToolBarCtrl template class CToolBarCtrlT : public TBase { public: // Construction CToolBarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CToolBarCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return TOOLBARCLASSNAME; } BOOL IsButtonEnabled(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONENABLED, nID, 0L); } BOOL IsButtonChecked(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONCHECKED, nID, 0L); } BOOL IsButtonPressed(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONPRESSED, nID, 0L); } BOOL IsButtonHidden(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return(BOOL) ::SendMessage(m_hWnd, TB_ISBUTTONHIDDEN, nID, 0L); } BOOL IsButtonIndeterminate(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONINDETERMINATE, nID, 0L); } int GetState(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETSTATE, nID, 0L); } BOOL SetState(int nID, UINT nState) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETSTATE, nID, MAKELPARAM(nState, 0)); } BOOL GetButton(int nIndex, LPTBBUTTON lpButton) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETBUTTON, nIndex, (LPARAM)lpButton); } int GetButtonCount() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_BUTTONCOUNT, 0, 0L); } BOOL GetItemRect(int nIndex, LPRECT lpRect) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETITEMRECT, nIndex, (LPARAM)lpRect); } void SetButtonStructSize(int nSize = sizeof(TBBUTTON)) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_BUTTONSTRUCTSIZE, nSize, 0L); } BOOL SetButtonSize(SIZE size) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONSIZE, 0, MAKELPARAM(size.cx, size.cy)); } BOOL SetButtonSize(int cx, int cy) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONSIZE, 0, MAKELPARAM(cx, cy)); } BOOL SetBitmapSize(SIZE size) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(size.cx, size.cy)); } BOOL SetBitmapSize(int cx, int cy) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(cx, cy)); } CToolTipCtrl GetToolTips() const { ATLASSERT(::IsWindow(m_hWnd)); return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TB_GETTOOLTIPS, 0, 0L)); } void SetToolTips(HWND hWndToolTip) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_SETTOOLTIPS, (WPARAM)hWndToolTip, 0L); } void SetNotifyWnd(HWND hWnd) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_SETPARENT, (WPARAM)hWnd, 0L); } int GetRows() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETROWS, 0, 0L); } void SetRows(int nRows, BOOL bLarger, LPRECT lpRect) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_SETROWS, MAKELPARAM(nRows, bLarger), (LPARAM)lpRect); } BOOL SetCmdID(int nIndex, UINT nID) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETCMDID, nIndex, nID); } DWORD GetBitmapFlags() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TB_GETBITMAPFLAGS, 0, 0L); } int GetBitmap(int nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETBITMAP, nID, 0L); } int GetButtonText(int nID, LPTSTR lpstrText) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETBUTTONTEXT, nID, (LPARAM)lpstrText); } CImageList GetImageList() const { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETIMAGELIST, 0, 0L)); } CImageList SetImageList(HIMAGELIST hImageList) { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETIMAGELIST, 0, (LPARAM)hImageList)); } CImageList GetDisabledImageList() const { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETDISABLEDIMAGELIST, 0, 0L)); } CImageList SetDisabledImageList(HIMAGELIST hImageList) { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETDISABLEDIMAGELIST, 0, (LPARAM)hImageList)); } CImageList GetHotImageList() const { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETHOTIMAGELIST, 0, 0L)); } CImageList SetHotImageList(HIMAGELIST hImageList) { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETHOTIMAGELIST, 0, (LPARAM)hImageList)); } DWORD GetStyle() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TB_GETSTYLE, 0, 0L); } void SetStyle(DWORD dwStyle) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_SETSTYLE, 0, dwStyle); } DWORD GetButtonSize() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TB_GETBUTTONSIZE, 0, 0L); } void GetButtonSize(SIZE& size) const { ATLASSERT(::IsWindow(m_hWnd)); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TB_GETBUTTONSIZE, 0, 0L); size.cx = LOWORD(dwRet); size.cy = HIWORD(dwRet); } BOOL GetRect(int nID, LPRECT lpRect) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETRECT, nID, (LPARAM)lpRect); } int GetTextRows() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETTEXTROWS, 0, 0L); } BOOL SetButtonWidth(int cxMin, int cxMax) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONWIDTH, 0, MAKELPARAM(cxMin, cxMax)); } BOOL SetIndent(int nIndent) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETINDENT, nIndent, 0L); } BOOL SetMaxTextRows(int nMaxTextRows) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, nMaxTextRows, 0L); } #if (_WIN32_IE >= 0x0400) BOOL GetAnchorHighlight() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETANCHORHIGHLIGHT, 0, 0L); } BOOL SetAnchorHighlight(BOOL bEnable = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETANCHORHIGHLIGHT, bEnable, 0L); } int GetButtonInfo(int nID, LPTBBUTTONINFO lptbbi) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETBUTTONINFO, nID, (LPARAM)lptbbi); } BOOL SetButtonInfo(int nID, LPTBBUTTONINFO lptbbi) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONINFO, nID, (LPARAM)lptbbi); } int GetHotItem() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETHOTITEM, 0, 0L); } int SetHotItem(int nItem) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_SETHOTITEM, nItem, 0L); } BOOL IsButtonHighlighted(int nButtonID) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONHIGHLIGHTED, nButtonID, 0L); } DWORD SetDrawTextFlags(DWORD dwMask, DWORD dwFlags) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TB_SETDRAWTEXTFLAGS, dwMask, dwFlags); } BOOL GetColorScheme(LPCOLORSCHEME lpcs) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETCOLORSCHEME, 0, (LPARAM)lpcs); } void SetColorScheme(LPCOLORSCHEME lpcs) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_SETCOLORSCHEME, 0, (LPARAM)lpcs); } DWORD GetExtendedStyle() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TB_GETEXTENDEDSTYLE, 0, 0L); } DWORD SetExtendedStyle(DWORD dwStyle) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TB_SETEXTENDEDSTYLE, 0, dwStyle); } void GetInsertMark(LPTBINSERTMARK lptbim) const { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_GETINSERTMARK, 0, (LPARAM)lptbim); } void SetInsertMark(LPTBINSERTMARK lptbim) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_SETINSERTMARK, 0, (LPARAM)lptbim); } COLORREF GetInsertMarkColor() const { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, TB_GETINSERTMARKCOLOR, 0, 0L); } COLORREF SetInsertMarkColor(COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, TB_SETINSERTMARKCOLOR, 0, (LPARAM)clr); } BOOL GetMaxSize(LPSIZE lpSize) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETMAXSIZE, 0, (LPARAM)lpSize); } void GetPadding(LPSIZE lpSizePadding) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(lpSizePadding != NULL); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TB_GETPADDING, 0, 0L); lpSizePadding->cx = GET_X_LPARAM(dwRet); lpSizePadding->cy = GET_Y_LPARAM(dwRet); } void SetPadding(int cx, int cy, LPSIZE lpSizePadding = NULL) { ATLASSERT(::IsWindow(m_hWnd)); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TB_SETPADDING, 0, MAKELPARAM(cx, cy)); if(lpSizePadding != NULL) { lpSizePadding->cx = GET_X_LPARAM(dwRet); lpSizePadding->cy = GET_Y_LPARAM(dwRet); } } BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) #if (_WIN32_IE >= 0x0500) int GetString(int nString, LPTSTR lpstrString, int cchMaxLen) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(cchMaxLen, nString), (LPARAM)lpstrString); } int GetStringBSTR(int nString, BSTR& bstrString) const { USES_CONVERSION; ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(bstrString == NULL); int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(0, nString), NULL)); if(nLength != -1) { LPTSTR lpszString = (LPTSTR)_alloca((nLength + 1) * sizeof(TCHAR)); nLength = (int)::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(nLength + 1, nString), (LPARAM)lpszString); if(nLength != -1) bstrString = ::SysAllocString(T2OLE(lpszString)); } return nLength; } #ifdef __ATLSTR_H__ int GetString(int nString, CString& str) const { ATLASSERT(::IsWindow(m_hWnd)); int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(0, nString), NULL)); if(nLength != -1) { nLength = (int)::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(nLength + 1, nString), (LPARAM)str.GetBufferSetLength(nLength+1)); str.ReleaseBuffer(); } return nLength; } #endif //__ATLSTR_H__ #endif //(_WIN32_IE >= 0x0500) // Operations BOOL EnableButton(int nID, BOOL bEnable = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ENABLEBUTTON, nID, MAKELPARAM(bEnable, 0)); } BOOL CheckButton(int nID, BOOL bCheck = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_CHECKBUTTON, nID, MAKELPARAM(bCheck, 0)); } BOOL PressButton(int nID, BOOL bPress = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_PRESSBUTTON, nID, MAKELPARAM(bPress, 0)); } BOOL HideButton(int nID, BOOL bHide = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_HIDEBUTTON, nID, MAKELPARAM(bHide, 0)); } BOOL Indeterminate(int nID, BOOL bIndeterminate = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_INDETERMINATE, nID, MAKELPARAM(bIndeterminate, 0)); } int AddBitmap(int nNumButtons, UINT nBitmapID) { ATLASSERT(::IsWindow(m_hWnd)); TBADDBITMAP tbab; tbab.hInst = _Module.GetResourceInstance(); ATLASSERT(tbab.hInst != NULL); tbab.nID = nBitmapID; return (int)::SendMessage(m_hWnd, TB_ADDBITMAP, (WPARAM)nNumButtons, (LPARAM)&tbab); } int AddBitmap(int nNumButtons, HBITMAP hBitmap) { ATLASSERT(::IsWindow(m_hWnd)); TBADDBITMAP tbab; tbab.hInst = NULL; tbab.nID = (UINT_PTR)hBitmap; return (int)::SendMessage(m_hWnd, TB_ADDBITMAP, (WPARAM)nNumButtons, (LPARAM)&tbab); } BOOL AddButtons(int nNumButtons, LPTBBUTTON lpButtons) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_ADDBUTTONS, nNumButtons, (LPARAM)lpButtons); } BOOL InsertButton(int nIndex, LPTBBUTTON lpButton) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_INSERTBUTTON, nIndex, (LPARAM)lpButton); } BOOL DeleteButton(int nIndex) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_DELETEBUTTON, nIndex, 0L); } UINT CommandToIndex(UINT nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, TB_COMMANDTOINDEX, nID, 0L); } void SaveState(HKEY hKeyRoot, LPCTSTR lpszSubKey, LPCTSTR lpszValueName) { ATLASSERT(::IsWindow(m_hWnd)); TBSAVEPARAMS tbs; tbs.hkr = hKeyRoot; tbs.pszSubKey = lpszSubKey; tbs.pszValueName = lpszValueName; ::SendMessage(m_hWnd, TB_SAVERESTORE, (WPARAM)TRUE, (LPARAM)&tbs); } void RestoreState(HKEY hKeyRoot, LPCTSTR lpszSubKey, LPCTSTR lpszValueName) { ATLASSERT(::IsWindow(m_hWnd)); TBSAVEPARAMS tbs; tbs.hkr = hKeyRoot; tbs.pszSubKey = lpszSubKey; tbs.pszValueName = lpszValueName; ::SendMessage(m_hWnd, TB_SAVERESTORE, (WPARAM)FALSE, (LPARAM)&tbs); } void Customize() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_CUSTOMIZE, 0, 0L); } int AddString(UINT nStringID) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_ADDSTRING, (WPARAM)_Module.GetResourceInstance(), (LPARAM)nStringID); } int AddStrings(LPCTSTR lpszStrings) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_ADDSTRING, 0, (LPARAM)lpszStrings); } void AutoSize() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TB_AUTOSIZE, 0, 0L); } BOOL ChangeBitmap(int nID, int nBitmap) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_CHANGEBITMAP, nID, MAKELPARAM(nBitmap, 0)); } int LoadImages(int nBitmapID) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_LOADIMAGES, nBitmapID, (LPARAM)_Module.GetResourceInstance()); } int LoadStdImages(int nBitmapID) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_LOADIMAGES, nBitmapID, (LPARAM)HINST_COMMCTRL); } BOOL ReplaceBitmap(LPTBREPLACEBITMAP ptbrb) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_REPLACEBITMAP, 0, (LPARAM)ptbrb); } #if (_WIN32_IE >= 0x0400) int HitTest(LPPOINT lpPoint) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TB_HITTEST, 0, (LPARAM)lpPoint); } BOOL InsertMarkHitTest(LPPOINT lpPoint, LPTBINSERTMARK lptbim) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_INSERTMARKHITTEST, (WPARAM)lpPoint, (LPARAM)lptbim); } BOOL InsertMarkHitTest(int x, int y, LPTBINSERTMARK lptbim) { ATLASSERT(::IsWindow(m_hWnd)); POINT pt = { x, y }; return (BOOL)::SendMessage(m_hWnd, TB_INSERTMARKHITTEST, (WPARAM)&pt, (LPARAM)lptbim); } BOOL MapAccelerator(TCHAR chAccel, int& nID) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_MAPACCELERATOR, (WPARAM)chAccel, (LPARAM)&nID); } BOOL MarkButton(int nID, BOOL bHighlight = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_MARKBUTTON, nID, MAKELPARAM(bHighlight, 0)); } BOOL MoveButton(int nOldPos, int nNewPos) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TB_MOVEBUTTON, nOldPos, nNewPos); } HRESULT GetObject(REFIID iid, LPVOID* ppvObject) { ATLASSERT(::IsWindow(m_hWnd)); return (HRESULT)::SendMessage(m_hWnd, TB_GETOBJECT, (WPARAM)&iid, (LPARAM)ppvObject); } #endif //(_WIN32_IE >= 0x0400) }; typedef CToolBarCtrlT CToolBarCtrl; ///////////////////////////////////////////////////////////////////////////// // CStatusBarCtrl template class CStatusBarCtrlT : public TBase { public: // Constructors CStatusBarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CStatusBarCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Methods static LPCTSTR GetWndClassName() { return STATUSCLASSNAME; } int GetParts(int nParts, int* pParts) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, SB_GETPARTS, nParts, (LPARAM)pParts); } BOOL SetParts(int nParts, int* pWidths) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, SB_SETPARTS, nParts, (LPARAM)pWidths); } int GetTextLength(int nPane, int* pType = NULL) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, SB_GETTEXTLENGTH, (WPARAM)nPane, 0L); if (pType != NULL) *pType = (int)(short)HIWORD(dwRet); return (int)(short)LOWORD(dwRet); } int GetText(int nPane, LPTSTR lpszText, int* pType = NULL) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, SB_GETTEXT, (WPARAM)nPane, (LPARAM)lpszText); if(pType != NULL) *pType = (int)(short)HIWORD(dwRet); return (int)(short)LOWORD(dwRet); } #ifndef _ATL_NO_COM BOOL GetTextBSTR(int nPane, BSTR& bstrText, int* pType = NULL) const { USES_CONVERSION; ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); ATLASSERT(bstrText == NULL); int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, SB_GETTEXTLENGTH, (WPARAM)nPane, 0L)); if(nLength == 0) return FALSE; LPTSTR lpszText = (LPTSTR)_alloca((nLength + 1) * sizeof(TCHAR)); if(!GetText(nPane, lpszText, pType)) return FALSE; bstrText = ::SysAllocString(T2OLE(lpszText)); return (bstrText != NULL) ? TRUE : FALSE; } #endif //!_ATL_NO_COM #ifdef __ATLSTR_H__ int GetText(int nPane, CString& strText, int* pType = NULL) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, SB_GETTEXTLENGTH, (WPARAM)nPane, 0L)); if(nLength == 0) return 0; return GetText(nPane, strText.GetBufferSetLength(nLength), pType); } #endif //__ATLSTR_H__ BOOL SetText(int nPane, LPCTSTR lpszText, int nType = 0) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); return (BOOL)::SendMessage(m_hWnd, SB_SETTEXT, (nPane | nType), (LPARAM)lpszText); } BOOL GetRect(int nPane, LPRECT lpRect) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); return (BOOL)::SendMessage(m_hWnd, SB_GETRECT, nPane, (LPARAM)lpRect); } BOOL GetBorders(int* pBorders) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, SB_GETBORDERS, 0, (LPARAM)pBorders); } BOOL GetBorders(int& nHorz, int& nVert, int& nSpacing) const { ATLASSERT(::IsWindow(m_hWnd)); int borders[3]; BOOL bResult = (BOOL)::SendMessage(m_hWnd, SB_GETBORDERS, 0, (LPARAM)&borders); if(bResult) { nHorz = borders[0]; nVert = borders[1]; nSpacing = borders[2]; } return bResult; } void SetMinHeight(int nMin) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, SB_SETMINHEIGHT, nMin, 0L); } BOOL SetSimple(BOOL bSimple = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, SB_SIMPLE, bSimple, 0L); } BOOL IsSimple() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, SB_ISSIMPLE, 0, 0L); } #if (_WIN32_IE >= 0x0400) COLORREF SetBkColor(COLORREF clrBk) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, SB_SETBKCOLOR, 0, (LPARAM)clrBk); } BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, SB_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, SB_SETUNICODEFORMAT, bUnicode, 0L); } void GetTipText(int nPane, LPTSTR lpstrText, int nSize) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); ::SendMessage(m_hWnd, SB_GETTIPTEXT, MAKEWPARAM(nPane, nSize), (LPARAM)lpstrText); } void SetTipText(int nPane, LPCTSTR lpstrText) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); ::SendMessage(m_hWnd, SB_SETTIPTEXT, nPane, (LPARAM)lpstrText); } HICON GetIcon(int nPane) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); return (HICON)::SendMessage(m_hWnd, SB_GETICON, nPane, 0L); } BOOL SetIcon(int nPane, HICON hIcon) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nPane < 256); return (BOOL)::SendMessage(m_hWnd, SB_SETICON, nPane, (LPARAM)hIcon); } #endif //(_WIN32_IE >= 0x0400) }; typedef CStatusBarCtrlT CStatusBarCtrl; ///////////////////////////////////////////////////////////////////////////// // CTabCtrl template class CTabCtrlT : public TBase { public: // Constructors CTabCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CTabCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return WC_TABCONTROL; } CImageList GetImageList() const { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TCM_GETIMAGELIST, 0, 0L)); } CImageList SetImageList(HIMAGELIST hImageList) { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TCM_SETIMAGELIST, 0, (LPARAM)hImageList)); } int GetItemCount() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_GETITEMCOUNT, 0, 0L); } BOOL GetItem(int nItem, LPTCITEM pTabCtrlItem) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_GETITEM, nItem, (LPARAM)pTabCtrlItem); } BOOL SetItem(int nItem, LPTCITEM pTabCtrlItem) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_SETITEM, nItem, (LPARAM)pTabCtrlItem); } BOOL GetItemRect(int nItem, LPRECT lpRect) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_GETITEMRECT, nItem, (LPARAM)lpRect); } int GetCurSel() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_GETCURSEL, 0, 0L); } int SetCurSel(int nItem) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_SETCURSEL, nItem, 0L); } SIZE SetItemSize(SIZE size) { ATLASSERT(::IsWindow(m_hWnd)); DWORD dwSize = (DWORD)::SendMessage(m_hWnd, TCM_SETITEMSIZE, 0, MAKELPARAM(size.cx, size.cy)); SIZE sizeRet = { GET_X_LPARAM(dwSize), GET_Y_LPARAM(dwSize) }; return sizeRet; } void SetPadding(SIZE size) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TCM_SETPADDING, 0, MAKELPARAM(size.cx, size.cy)); } int GetRowCount() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_GETROWCOUNT, 0, 0L); } CToolTipCtrl GetTooltips() const { ATLASSERT(::IsWindow(m_hWnd)); return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TCM_GETTOOLTIPS, 0, 0L)); } void SetTooltips(HWND hWndToolTip) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TCM_SETTOOLTIPS, (WPARAM)hWndToolTip, 0L); } int GetCurFocus() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_GETCURFOCUS, 0, 0L); } void SetCurFocus(int nItem) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TCM_SETCURFOCUS, nItem, 0L); } BOOL SetItemExtra(int cbExtra) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(GetItemCount() == 0); // must be empty return (BOOL)::SendMessage(m_hWnd, TCM_SETITEMEXTRA, cbExtra, 0L); } int SetMinTabWidth(int nWidth = -1) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_SETMINTABWIDTH, 0, nWidth); } #if (_WIN32_IE >= 0x0400) DWORD GetExtendedStyle() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TCM_GETEXTENDEDSTYLE, 0, 0L); } DWORD SetExtendedStyle(DWORD dwExMask, DWORD dwExStyle) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, TCM_SETEXTENDEDSTYLE, dwExMask, dwExStyle); } BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) // Operations BOOL InsertItem(int nItem, LPTCITEM pTabCtrlItem) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_INSERTITEM, nItem, (LPARAM)pTabCtrlItem); } BOOL DeleteItem(int nItem) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_DELETEITEM, nItem, 0L); } BOOL DeleteAllItems() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_DELETEALLITEMS, 0, 0L); } void AdjustRect(BOOL bLarger, LPRECT lpRect) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TCM_ADJUSTRECT, bLarger, (LPARAM)lpRect); } void RemoveImage(int nImage) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TCM_REMOVEIMAGE, nImage, 0L); } int HitTest(TC_HITTESTINFO* pHitTestInfo) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TCM_HITTEST, 0, (LPARAM)pHitTestInfo); } void DeselectAll(BOOL bExcludeFocus = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TCM_DESELECTALL, bExcludeFocus, 0L); } #if (_WIN32_IE >= 0x0400) BOOL HighlightItem(int nIndex, BOOL bHighlight = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TCM_HIGHLIGHTITEM, nIndex, MAKELPARAM(bHighlight, 0)); } #endif //(_WIN32_IE >= 0x0400) }; typedef CTabCtrlT CTabCtrl; ///////////////////////////////////////////////////////////////////////////// // CTrackBarCtrl template class CTrackBarCtrlT : public TBase { public: // Constructors CTrackBarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CTrackBarCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return TRACKBAR_CLASS; } int GetLineSize() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETLINESIZE, 0, 0L); } int SetLineSize(int nSize) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_SETLINESIZE, 0, nSize); } int GetPageSize() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETPAGESIZE, 0, 0L); } int SetPageSize(int nSize) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_SETPAGESIZE, 0, nSize); } int GetRangeMin() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETRANGEMIN, 0, 0L); } void SetRangeMin(int nMin, BOOL bRedraw = FALSE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETRANGEMIN, bRedraw, nMin); } int GetRangeMax() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETRANGEMAX, 0, 0L); } void SetRangeMax(int nMax, BOOL bRedraw = FALSE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETRANGEMAX, bRedraw, nMax); } void GetRange(int& nMin, int& nMax) const { nMin = GetRangeMin(); nMax = GetRangeMax(); } void SetRange(int nMin, int nMax, BOOL bRedraw = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETRANGE, bRedraw, MAKELPARAM(nMin, nMax)); } int GetSelStart() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETSELSTART, 0, 0L); } void SetSelStart(int nMin) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETSELSTART, 0, (LPARAM)nMin); } int GetSelEnd() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETSELEND, 0, 0L); } void SetSelEnd(int nMax) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETSELEND, 0, (LPARAM)nMax); } void GetSelection(int& nMin, int& nMax) const { nMin = GetSelStart(); nMax = GetSelEnd(); } void SetSelection(int nMin, int nMax) { SetSelStart(nMin); SetSelEnd(nMax); } void GetChannelRect(LPRECT lprc) const { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_GETCHANNELRECT, 0, (LPARAM)lprc); } void GetThumbRect(LPRECT lprc) const { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_GETTHUMBRECT, 0, (LPARAM)lprc); } int GetPos() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETPOS, 0, 0L); } void SetPos(int nPos) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETPOS, TRUE, nPos); } UINT GetNumTics() const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, TBM_GETNUMTICS, 0, 0L); } DWORD* GetTicArray() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD*)::SendMessage(m_hWnd, TBM_GETPTICS, 0, 0L); } int GetTic(int nTic) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETTIC, nTic, 0L); } BOOL SetTic(int nTic) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TBM_SETTIC, 0, nTic); } int GetTicPos(int nTic) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETTICPOS, nTic, 0L); } void SetTicFreq(int nFreq) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETTICFREQ, nFreq, 0L); } int GetThumbLength() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_GETTHUMBLENGTH, 0, 0L); } void SetThumbLength(int nLength) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETTHUMBLENGTH, nLength, 0L); } void SetSel(int nStart, int nEnd, BOOL bRedraw = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((GetStyle() & TBS_ENABLESELRANGE) != 0); ::SendMessage(m_hWnd, TBM_SETSEL, bRedraw, MAKELPARAM(nStart, nEnd)); } CWindow GetBuddy(BOOL bLeft = TRUE) const { ATLASSERT(::IsWindow(m_hWnd)); return CWindow((HWND)::SendMessage(m_hWnd, TBM_GETBUDDY, bLeft, 0L)); } CWindow SetBuddy(HWND hWndBuddy, BOOL bLeft = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return CWindow((HWND)::SendMessage(m_hWnd, TBM_SETBUDDY, bLeft, (LPARAM)hWndBuddy)); } CToolTipCtrl GetToolTips() const { ATLASSERT(::IsWindow(m_hWnd)); return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TBM_GETTOOLTIPS, 0, 0L)); } void SetToolTips(HWND hWndTT) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETTOOLTIPS, (WPARAM)hWndTT, 0L); } int SetTipSide(int nSide) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, TBM_SETTIPSIDE, nSide, 0L); } #if (_WIN32_IE >= 0x0400) BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TBM_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, TBM_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) // Operations void ClearSel(BOOL bRedraw = FALSE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_CLEARSEL, bRedraw, 0L); } void VerifyPos() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_SETPOS, FALSE, 0L); } void ClearTics(BOOL bRedraw = FALSE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, TBM_CLEARTICS, bRedraw, 0L); } }; typedef CTrackBarCtrlT CTrackBarCtrl; ///////////////////////////////////////////////////////////////////////////// // CUpDownCtrl template class CUpDownCtrlT : public TBase { public: // Constructors CUpDownCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CUpDownCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return UPDOWN_CLASS; } UINT GetAccel(int nAccel, UDACCEL* pAccel) const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)LOWORD(::SendMessage(m_hWnd, UDM_GETACCEL, nAccel, (LPARAM)pAccel)); } BOOL SetAccel(int nAccel, UDACCEL* pAccel) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)LOWORD(::SendMessage(m_hWnd, UDM_SETACCEL, nAccel, (LPARAM)pAccel)); } UINT GetBase() const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)LOWORD(::SendMessage(m_hWnd, UDM_GETBASE, 0, 0L)); } int SetBase(int nBase) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, UDM_SETBASE, nBase, 0L); } CWindow GetBuddy() const { ATLASSERT(::IsWindow(m_hWnd)); return CWindow((HWND)::SendMessage(m_hWnd, UDM_GETBUDDY, 0, 0L)); } CWindow SetBuddy(HWND hWndBuddy) { ATLASSERT(::IsWindow(m_hWnd)); return CWindow((HWND)::SendMessage(m_hWnd, UDM_SETBUDDY, (WPARAM)hWndBuddy, 0L)); } int GetPos() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, UDM_GETPOS, 0, 0L); } int SetPos(int nPos) { ATLASSERT(::IsWindow(m_hWnd)); return (int)(short)LOWORD(::SendMessage(m_hWnd, UDM_SETPOS, 0, MAKELPARAM(nPos, 0))); } DWORD GetRange() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, UDM_GETRANGE, 0, 0L); } void GetRange(int& nLower, int& nUpper) const { ATLASSERT(::IsWindow(m_hWnd)); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, UDM_GETRANGE, 0, 0L); nLower = (int)(short)HIWORD(dwRet); nUpper = (int)(short)LOWORD(dwRet); } void SetRange(int nLower, int nUpper) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, UDM_SETRANGE, 0, MAKELPARAM(nUpper, nLower)); } #if (_WIN32_IE >= 0x0400) void SetRange32(int nLower, int nUpper) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, UDM_SETRANGE32, nLower, nUpper); } void GetRange32(int& nLower, int& nUpper) const { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, UDM_GETRANGE32, (WPARAM)&nLower, (LPARAM)&nUpper); } BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, UDM_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, UDM_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) #if (_WIN32_IE >= 0x0500) int GetPos32(LPBOOL lpbError /*= NULL*/) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, UDM_GETPOS32, 0, (LPARAM)lpbError); } int SetPos32(int nPos) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, UDM_SETPOS32, 0, (LPARAM)nPos); } #endif //(_WIN32_IE >= 0x0500) }; typedef CUpDownCtrlT CUpDownCtrl; ///////////////////////////////////////////////////////////////////////////// // CProgressBarCtrl template class CProgressBarCtrlT : public TBase { public: // Constructors CProgressBarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CProgressBarCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return PROGRESS_CLASS; } DWORD SetRange(int nLower, int nUpper) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, PBM_SETRANGE, 0, MAKELPARAM(nLower, nUpper)); } int SetPos(int nPos) { ATLASSERT(::IsWindow(m_hWnd)); return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_SETPOS, nPos, 0L)); } int OffsetPos(int nPos) { ATLASSERT(::IsWindow(m_hWnd)); return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_DELTAPOS, nPos, 0L)); } int SetStep(int nStep) { ATLASSERT(::IsWindow(m_hWnd)); return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_SETSTEP, nStep, 0L)); } UINT GetPos() const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, PBM_GETPOS, 0, 0L); } void GetRange(PPBRANGE pPBRange) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(pPBRange != NULL); ::SendMessage(m_hWnd, PBM_GETRANGE, TRUE, (LPARAM)pPBRange); } int GetRangeLimit(BOOL bLimit) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PBM_GETRANGE, bLimit, (LPARAM)NULL); } DWORD SetRange32(int nMin, int nMax) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, PBM_SETRANGE32, nMin, nMax); } #if (_WIN32_IE >= 0x0400) COLORREF SetBarColor(COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, PBM_SETBARCOLOR, 0, (LPARAM)clr); } COLORREF SetBkColor(COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, PBM_SETBKCOLOR, 0, (LPARAM)clr); } #endif //(_WIN32_IE >= 0x0400) // Operations int StepIt() { ATLASSERT(::IsWindow(m_hWnd)); return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_STEPIT, 0, 0L)); } }; typedef CProgressBarCtrlT CProgressBarCtrl; ///////////////////////////////////////////////////////////////////////////// // CHotKeyCtrl template class CHotKeyCtrlT : public TBase { public: // Constructors CHotKeyCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CHotKeyCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return HOTKEY_CLASS; } DWORD GetHotKey() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, HKM_GETHOTKEY, 0, 0L); } void GetHotKey(WORD &wVirtualKeyCode, WORD &wModifiers) const { ATLASSERT(::IsWindow(m_hWnd)); DWORD dw = (DWORD)::SendMessage(m_hWnd, HKM_GETHOTKEY, 0, 0L); wVirtualKeyCode = LOBYTE(LOWORD(dw)); wModifiers = HIBYTE(LOWORD(dw)); } void SetHotKey(WORD wVirtualKeyCode, WORD wModifiers) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, HKM_SETHOTKEY, MAKEWORD(wVirtualKeyCode, wModifiers), 0L); } void SetRules(WORD wInvalidComb, WORD wModifiers) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, HKM_SETRULES, wInvalidComb, MAKELPARAM(wModifiers, 0)); } }; typedef CHotKeyCtrlT CHotKeyCtrl; ///////////////////////////////////////////////////////////////////////////// // CAnimateCtrl template class CAnimateCtrlT : public TBase { public: // Constructors CAnimateCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CAnimateCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return ANIMATE_CLASS; } // Operations BOOL Open(_U_STRINGorID FileName) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, ACM_OPEN, 0, (LPARAM)FileName.m_lpstr); } BOOL Play(UINT nFrom, UINT nTo, UINT nRep) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, ACM_PLAY, nRep, MAKELPARAM(nFrom, nTo)); } BOOL Stop() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, ACM_STOP, 0, 0L); } BOOL Close() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, ACM_OPEN, 0, 0L); } BOOL Seek(UINT nTo) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, ACM_PLAY, 0, MAKELPARAM(nTo, nTo)); } }; typedef CAnimateCtrlT CAnimateCtrl; ///////////////////////////////////////////////////////////////////////////// // CRichEditCtrl #ifdef _UNICODE #if (_RICHEDIT_VER == 0x0100) #undef RICHEDIT_CLASS #define RICHEDIT_CLASS L"RICHEDIT" #endif //(_RICHEDIT_VER == 0x0100) #endif //_UNICODE template class CRichEditCtrlT : public TBase { public: // Constructors CRichEditCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CRichEditCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return RICHEDIT_CLASS; } static LPCTSTR GetLibraryName() { #if (_RICHEDIT_VER >= 0x0200) return _T("RICHED20.DLL"); #else return _T("RICHED32.DLL"); #endif } 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 GetOptions() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, EM_GETOPTIONS, 0, 0L); } DWORD SetOptions(WORD wOperation, DWORD dwOptions) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, EM_SETOPTIONS, wOperation, dwOptions); } // 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)); *(LPINT)lpszBuffer = nMaxLength; return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer); } BOOL CanUndo() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L); } BOOL CanPaste(UINT nFormat = 0) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_CANPASTE, nFormat, 0L); } void GetSel(LONG& nStartChar, LONG& nEndChar) const { ATLASSERT(::IsWindow(m_hWnd)); CHARRANGE cr; ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr); nStartChar = cr.cpMin; nEndChar = cr.cpMax; } void GetSel(CHARRANGE &cr) const { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr); } int SetSel(LONG nStartChar, LONG nEndChar) { ATLASSERT(::IsWindow(m_hWnd)); CHARRANGE cr = { nStartChar, nEndChar }; return (int)::SendMessage(m_hWnd, EM_EXSETSEL, 0, (LPARAM)&cr); } int SetSel(CHARRANGE &cr) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_EXSETSEL, 0, (LPARAM)&cr); } int SetSelAll() { return SetSel(0, -1); } int SetSelNone() { return SetSel(-1, 0); } DWORD GetDefaultCharFormat(CHARFORMAT& cf) const { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT); return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 0, (LPARAM)&cf); } DWORD GetSelectionCharFormat(CHARFORMAT& cf) const { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT); return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 1, (LPARAM)&cf); } DWORD GetEventMask() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, EM_GETEVENTMASK, 0, 0L); } LONG GetLimitText() const { ATLASSERT(::IsWindow(m_hWnd)); return (LONG)::SendMessage(m_hWnd, EM_GETLIMITTEXT, 0, 0L); } DWORD GetParaFormat(PARAFORMAT& pf) const { ATLASSERT(::IsWindow(m_hWnd)); pf.cbSize = sizeof(PARAFORMAT); return (DWORD)::SendMessage(m_hWnd, EM_GETPARAFORMAT, 0, (LPARAM)&pf); } // richedit EM_GETSELTEXT is ANSI LONG GetSelText(LPSTR lpBuf) const { ATLASSERT(::IsWindow(m_hWnd)); return (LONG)::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpBuf); } #ifndef _ATL_NO_COM BOOL GetSelTextBSTR(BSTR& bstrText) const { USES_CONVERSION; ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(bstrText == NULL); CHARRANGE cr; cr.cpMin = cr.cpMax = 0; ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr); LPSTR lpstrText = (char*)_alloca((cr.cpMax - cr.cpMin + 1) * 2); lpstrText[0] = 0; if(::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrText) == 0) return FALSE; bstrText = ::SysAllocString(A2W(lpstrText)); return (bstrText != NULL) ? TRUE : FALSE; } #endif //!_ATL_NO_COM #ifdef __ATLSTR_H__ LONG GetSelText(CString& strText) const { ATLASSERT(::IsWindow(m_hWnd)); CHARRANGE cr; cr.cpMin = cr.cpMax = 0; ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr); LPSTR lpstrText = (char*)_alloca((cr.cpMax - cr.cpMin + 1) * 2); lpstrText[0] = 0; LONG lLen = (LONG)::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrText); if(lLen == 0) return 0; USES_CONVERSION; strText = A2T(lpstrText); return lLen; } #endif //__ATLSTR_H__ WORD GetSelectionType() const { ATLASSERT(::IsWindow(m_hWnd)); return (WORD)::SendMessage(m_hWnd, EM_SELECTIONTYPE, 0, 0L); } COLORREF SetBackgroundColor(COLORREF cr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, EM_SETBKGNDCOLOR, 0, cr); } COLORREF SetBackgroundColor() // sets to system background { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, EM_SETBKGNDCOLOR, 1, 0); } BOOL SetDefaultCharFormat(CHARFORMAT& cf) { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT); return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, 0, (LPARAM)&cf); } BOOL SetSelectionCharFormat(CHARFORMAT& cf) { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT); return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf); } BOOL SetWordCharFormat(CHARFORMAT& cf) { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT); return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD, (LPARAM)&cf); } DWORD SetEventMask(DWORD dwEventMask) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, EM_SETEVENTMASK, 0, dwEventMask); } BOOL SetParaFormat(PARAFORMAT& pf) { ATLASSERT(::IsWindow(m_hWnd)); pf.cbSize = sizeof(PARAFORMAT); return (BOOL)::SendMessage(m_hWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf); } BOOL SetTargetDevice(HDC hDC, int cxLineWidth) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_SETTARGETDEVICE, (WPARAM)hDC, cxLineWidth); } int GetTextLength() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, WM_GETTEXTLENGTH, 0, 0L); } BOOL SetReadOnly(BOOL bReadOnly = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_SETREADONLY, bReadOnly, 0L); } int GetFirstVisibleLine() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L); } int GetTextRange(TEXTRANGE* pTextRange) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_GETTEXTRANGE, 0, (LPARAM)pTextRange); } int GetTextRange(LONG nStartChar, LONG nEndChar, LPSTR lpstrText) const { ATLASSERT(::IsWindow(m_hWnd)); TEXTRANGE tr; tr.chrg.cpMin = nStartChar; tr.chrg.cpMax = nEndChar; tr.lpstrText = lpstrText; return (int)::SendMessage(m_hWnd, EM_GETTEXTRANGE, 0, (LPARAM)&tr); } EDITWORDBREAKPROCEX GetWordBreakProcEx() const { ATLASSERT(::IsWindow(m_hWnd)); return (EDITWORDBREAKPROCEX)::SendMessage(m_hWnd, EM_GETWORDBREAKPROCEX, 0, 0L); } EDITWORDBREAKPROCEX SetWordBreakProcEx(EDITWORDBREAKPROCEX pfnEditWordBreakProcEx) { ATLASSERT(::IsWindow(m_hWnd)); return (EDITWORDBREAKPROCEX)::SendMessage(m_hWnd, EM_SETWORDBREAKPROCEX, 0, (LPARAM)pfnEditWordBreakProcEx); } #if (_RICHEDIT_VER >= 0x0200) DWORD GetDefaultCharFormat(CHARFORMAT2& cf) const { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT2); return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 0, (LPARAM)&cf); } BOOL SetDefaultCharFormat(CHARFORMAT2& cf) { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT2); return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, 0, (LPARAM)&cf); } DWORD GetSelectionCharFormat(CHARFORMAT2& cf) const { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT2); return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 1, (LPARAM)&cf); } BOOL SetSelectionCharFormat(CHARFORMAT2& cf) { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT2); return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf); } BOOL SetWordCharFormat(CHARFORMAT2& cf) { ATLASSERT(::IsWindow(m_hWnd)); cf.cbSize = sizeof(CHARFORMAT2); return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD, (LPARAM)&cf); } DWORD GetParaFormat(PARAFORMAT2& pf) const { ATLASSERT(::IsWindow(m_hWnd)); pf.cbSize = sizeof(PARAFORMAT2); return (DWORD)::SendMessage(m_hWnd, EM_GETPARAFORMAT, 0, (LPARAM)&pf); } BOOL SetParaFormat(PARAFORMAT2& pf) { ATLASSERT(::IsWindow(m_hWnd)); pf.cbSize = sizeof(PARAFORMAT2); return (BOOL)::SendMessage(m_hWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf); } TEXTMODE GetTextMode() const { ATLASSERT(::IsWindow(m_hWnd)); return (TEXTMODE)::SendMessage(m_hWnd, EM_GETTEXTMODE, 0, 0L); } BOOL SetTextMode(TEXTMODE enumTextMode) { ATLASSERT(::IsWindow(m_hWnd)); return !(BOOL)::SendMessage(m_hWnd, EM_SETTEXTMODE, enumTextMode, 0L); } UNDONAMEID GetUndoName() const { ATLASSERT(::IsWindow(m_hWnd)); return (UNDONAMEID)::SendMessage(m_hWnd, EM_GETUNDONAME, 0, 0L); } UNDONAMEID GetRedoName() const { ATLASSERT(::IsWindow(m_hWnd)); return (UNDONAMEID)::SendMessage(m_hWnd, EM_GETREDONAME, 0, 0L); } BOOL CanRedo() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_CANREDO, 0, 0L); } BOOL GetAutoURLDetect() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_GETAUTOURLDETECT, 0, 0L); } BOOL SetAutoURLDetect(BOOL bAutoDetect = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return !(BOOL)::SendMessage(m_hWnd, EM_AUTOURLDETECT, bAutoDetect, 0L); } // this method is deprecated, please use SetAutoURLDetect BOOL EnableAutoURLDetect(BOOL bEnable = TRUE) { return SetAutoURLDetect(bEnable); } UINT SetUndoLimit(UINT uUndoLimit) { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, EM_SETUNDOLIMIT, uUndoLimit, 0L); } void SetPalette(HPALETTE hPalette) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_SETPALETTE, (WPARAM)hPalette, 0L); } int GetTextEx(GETTEXTEX* pGetTextEx, LPTSTR lpstrText) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_GETTEXTEX, (WPARAM)pGetTextEx, (LPARAM)lpstrText); } int GetTextEx(LPTSTR lpstrText, int nTextLen, DWORD dwFlags = GT_DEFAULT, UINT uCodePage = CP_ACP, LPCSTR lpDefaultChar = NULL, LPBOOL lpUsedDefChar = NULL) const { ATLASSERT(::IsWindow(m_hWnd)); GETTEXTEX gte; gte.cb = nTextLen * sizeof(TCHAR); gte.codepage = uCodePage; gte.flags = dwFlags; gte.lpDefaultChar = lpDefaultChar; gte.lpUsedDefChar = lpUsedDefChar; return (int)::SendMessage(m_hWnd, EM_GETTEXTEX, (WPARAM)>e, (LPARAM)lpstrText); } int GetTextLengthEx(GETTEXTLENGTHEX* pGetTextLengthEx) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_GETTEXTLENGTHEX, (WPARAM)pGetTextLengthEx, 0L); } int GetTextLengthEx(DWORD dwFlags = GTL_DEFAULT, UINT uCodePage = CP_ACP) const { ATLASSERT(::IsWindow(m_hWnd)); GETTEXTLENGTHEX gtle; gtle.codepage = uCodePage; gtle.flags = dwFlags; return (int)::SendMessage(m_hWnd, EM_GETTEXTLENGTHEX, (WPARAM)>le, 0L); } #endif //(_RICHEDIT_VER >= 0x0200) #if (_RICHEDIT_VER >= 0x0300) int SetTextEx(SETTEXTEX* pSetTextEx, LPCTSTR lpstrText) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_SETTEXTEX, (WPARAM)pSetTextEx, (LPARAM)lpstrText); } int SetTextEx(LPCTSTR lpstrText, DWORD dwFlags = ST_DEFAULT, UINT uCodePage = CP_ACP) { ATLASSERT(::IsWindow(m_hWnd)); SETTEXTEX ste; ste.flags = dwFlags; ste.codepage = uCodePage; return (int)::SendMessage(m_hWnd, EM_SETTEXTEX, (WPARAM)&ste, (LPARAM)lpstrText); } int GetEditStyle() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_GETEDITSTYLE, 0, 0L); } int SetEditStyle(int nStyle, int nMask = -1) { ATLASSERT(::IsWindow(m_hWnd)); if(nMask == -1) nMask = nStyle; // set everything specified return (int)::SendMessage(m_hWnd, EM_SETEDITSTYLE, nStyle, nMask); } BOOL SetFontSize(int nFontSizeDelta) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nFontSizeDelta >= -1637 && nFontSizeDelta <= 1638); return (BOOL)::SendMessage(m_hWnd, EM_SETFONTSIZE, nFontSizeDelta, 0L); } void GetScrollPos(LPPOINT lpPoint) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(lpPoint != NULL); ::SendMessage(m_hWnd, EM_GETSCROLLPOS, 0, (LPARAM)lpPoint); } void SetScrollPos(LPPOINT lpPoint) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(lpPoint != NULL); ::SendMessage(m_hWnd, EM_SETSCROLLPOS, 0, (LPARAM)lpPoint); } BOOL GetZoom(int& nNum, int& nDen) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_GETZOOM, (WPARAM)&nNum, (LPARAM)&nDen); } BOOL SetZoom(int nNum, int nDen) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nNum >= 0 && nNum <= 64); ATLASSERT(nDen >= 0 && nDen <= 64); return (BOOL)::SendMessage(m_hWnd, EM_SETZOOM, nNum, nDen); } BOOL SetZoomOff() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_SETZOOM, 0, 0L); } #endif //(_RICHEDIT_VER >= 0x0300) // Operations void LimitText(LONG nChars = 0) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_EXLIMITTEXT, 0, nChars); } int LineFromChar(LONG nIndex) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_EXLINEFROMCHAR, 0, nIndex); } POINT PosFromChar(LONG nChar) const { ATLASSERT(::IsWindow(m_hWnd)); POINT point; ::SendMessage(m_hWnd, EM_POSFROMCHAR, (WPARAM)&point, nChar); return point; } int CharFromPos(POINT pt) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, EM_CHARFROMPOS, 0, MAKELPARAM(pt.x, pt.y)); } void EmptyUndoBuffer() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_EMPTYUNDOBUFFER, 0, 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); } BOOL LineScroll(int nLines, int nChars = 0) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::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); } BOOL DisplayBand(LPRECT pDisplayRect) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_DISPLAYBAND, 0, (LPARAM)pDisplayRect); } LONG FindText(DWORD dwFlags, FINDTEXT& ft) const { ATLASSERT(::IsWindow(m_hWnd)); #if (_RICHEDIT_VER >= 0x0200) && defined(_UNICODE) return (LONG)::SendMessage(m_hWnd, EM_FINDTEXTW, dwFlags, (LPARAM)&ft); #else return (LONG)::SendMessage(m_hWnd, EM_FINDTEXT, dwFlags, (LPARAM)&ft); #endif } LONG FindText(DWORD dwFlags, FINDTEXTEX& ft) const { ATLASSERT(::IsWindow(m_hWnd)); #if (_RICHEDIT_VER >= 0x0200) && defined(_UNICODE) return (LONG)::SendMessage(m_hWnd, EM_FINDTEXTEXW, dwFlags, (LPARAM)&ft); #else return (LONG)::SendMessage(m_hWnd, EM_FINDTEXTEX, dwFlags, (LPARAM)&ft); #endif } LONG FormatRange(FORMATRANGE& fr, BOOL bDisplay = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (LONG)::SendMessage(m_hWnd, EM_FORMATRANGE, bDisplay, (LPARAM)&fr); } void HideSelection(BOOL bHide = TRUE, BOOL bChangeStyle = FALSE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_HIDESELECTION, bHide, bChangeStyle); } void PasteSpecial(UINT uClipFormat, DWORD dwAspect = 0, HMETAFILE hMF = 0) { ATLASSERT(::IsWindow(m_hWnd)); REPASTESPECIAL reps = { dwAspect, (DWORD_PTR)hMF }; ::SendMessage(m_hWnd, EM_PASTESPECIAL, uClipFormat, (LPARAM)&reps); } void RequestResize() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_REQUESTRESIZE, 0, 0L); } LONG StreamIn(UINT uFormat, EDITSTREAM& es) { ATLASSERT(::IsWindow(m_hWnd)); return (LONG)::SendMessage(m_hWnd, EM_STREAMIN, uFormat, (LPARAM)&es); } LONG StreamOut(UINT uFormat, EDITSTREAM& es) { ATLASSERT(::IsWindow(m_hWnd)); return (LONG)::SendMessage(m_hWnd, EM_STREAMOUT, uFormat, (LPARAM)&es); } DWORD FindWordBreak(int nCode, LONG nStartChar) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, EM_FINDWORDBREAK, nCode, nStartChar); } // Additional operations void ScrollCaret() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L); } int InsertText(long nInsertAfterChar, LPCTSTR lpstrText, BOOL bCanUndo = FALSE) { int nRet = SetSel(nInsertAfterChar, nInsertAfterChar); ReplaceSel(lpstrText, bCanUndo); return nRet; } int AppendText(LPCTSTR lpstrText, BOOL bCanUndo = FALSE) { return InsertText(GetWindowTextLength(), lpstrText, bCanUndo); } // 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); } // OLE support IRichEditOle* GetOleInterface() const { ATLASSERT(::IsWindow(m_hWnd)); IRichEditOle *pRichEditOle = NULL; ::SendMessage(m_hWnd, EM_GETOLEINTERFACE, 0, (LPARAM)&pRichEditOle); return pRichEditOle; } BOOL SetOleCallback(IRichEditOleCallback* pCallback) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_SETOLECALLBACK, 0, (LPARAM)pCallback); } #if (_RICHEDIT_VER >= 0x0200) BOOL Redo() { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, EM_REDO, 0, 0L); } void StopGroupTyping() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_STOPGROUPTYPING, 0, 0L); } void ShowScrollBar(int nBarType, BOOL bVisible = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, EM_SHOWSCROLLBAR, nBarType, bVisible); } #endif //(_RICHEDIT_VER >= 0x0200) }; typedef CRichEditCtrlT CRichEditCtrl; ///////////////////////////////////////////////////////////////////////////// // CRichEditCommands - message handlers for standard EDIT commands // Chain to CRichEditCommands message map. Your class must also derive from CRichEditCtrl. // Example: // class CMyRichEdit : public CWindowImpl, // public CRichEditCommands // { // public: // BEGIN_MSG_MAP(CMyRichEdit) // // your handlers... // CHAIN_MSG_MAP_ALT(CRichEditCommands, 1) // END_MSG_MAP() // // other stuff... // }; template class CRichEditCommands : public CEditCommands< T > { public: BEGIN_MSG_MAP(CRichEditCommands< T >) ALT_MSG_MAP(1) COMMAND_ID_HANDLER(ID_EDIT_CLEAR, CEditCommands< T >::OnEditClear) COMMAND_ID_HANDLER(ID_EDIT_CLEAR_ALL, CEditCommands< T >::OnEditClearAll) COMMAND_ID_HANDLER(ID_EDIT_COPY, CEditCommands< T >::OnEditCopy) COMMAND_ID_HANDLER(ID_EDIT_CUT, CEditCommands< T >::OnEditCut) COMMAND_ID_HANDLER(ID_EDIT_PASTE, CEditCommands< T >::OnEditPaste) COMMAND_ID_HANDLER(ID_EDIT_SELECT_ALL, CEditCommands< T >::OnEditSelectAll) COMMAND_ID_HANDLER(ID_EDIT_UNDO, CEditCommands< T >::OnEditUndo) #if (_RICHEDIT_VER >= 0x0200) COMMAND_ID_HANDLER(ID_EDIT_REDO, OnEditRedo) #endif //(_RICHEDIT_VER >= 0x0200) END_MSG_MAP() #if (_RICHEDIT_VER >= 0x0200) LRESULT OnEditRedo(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) { T* pT = static_cast(this); pT->Redo(); return 0; } #endif //(_RICHEDIT_VER >= 0x0200) // State (update UI) helpers BOOL CanCut() const { return HasSelection(); } BOOL CanCopy() const { return HasSelection(); } BOOL CanClear() const { return HasSelection(); } // Implementation BOOL HasSelection() const { const T* pT = static_cast(this); return (pT->GetSelectionType() != SEL_EMPTY); } }; ///////////////////////////////////////////////////////////////////////////// // CDragListBox template class CDragListBoxT : public CListBoxT< TBase > { public: // Constructors CDragListBoxT(HWND hWnd = NULL) : CListBoxT< TBase >(hWnd) { } CDragListBoxT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { HWND hWnd = CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); if(hWnd != NULL) MakeDragList(); return hWnd; } // Operations BOOL MakeDragList() { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) == 0); return ::MakeDragList(m_hWnd); } int LBItemFromPt(POINT pt, BOOL bAutoScroll = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return ::LBItemFromPt(m_hWnd, pt, bAutoScroll); } void DrawInsert(int nItem) { ATLASSERT(::IsWindow(m_hWnd)); ::DrawInsert(GetParent(), m_hWnd, nItem); } static UINT GetDragListMessage() { static UINT uDragListMessage = 0; if(uDragListMessage == 0) { ::EnterCriticalSection(&_Module.m_csStaticDataInit); if(uDragListMessage == 0) uDragListMessage = ::RegisterWindowMessage(DRAGLISTMSGSTRING); ::LeaveCriticalSection(&_Module.m_csStaticDataInit); } ATLASSERT(uDragListMessage != 0); return uDragListMessage; } }; typedef CDragListBoxT CDragListBox; template class CDragListNotifyImpl { public: BEGIN_MSG_MAP(CDragListNotifyImpl< T >) MESSAGE_HANDLER(CDragListBox::GetDragListMessage(), OnDragListNotify) END_MSG_MAP() LRESULT OnDragListNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) { uMsg; // avoid level 4 warning ATLASSERT(uMsg == CDragListBox::GetDragListMessage()); T* pT = static_cast(this); LPDRAGLISTINFO lpDragListInfo = (LPDRAGLISTINFO)lParam; LRESULT lRet = 0; switch(lpDragListInfo->uNotification) { case DL_BEGINDRAG: lRet = (LPARAM)pT->OnBeginDrag((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor); break; case DL_CANCELDRAG: pT->OnCancelDrag((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor); break; case DL_DRAGGING: lRet = (LPARAM)pT->OnDragging((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor); break; case DL_DROPPED: pT->OnDropped((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor); break; default: ATLTRACE2(atlTraceUI, 0, _T("Unknown DragListBox notification\n")); bHandled = FALSE; // don't handle it break; } return lRet; } // Overrideables BOOL OnBeginDrag(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/) { return TRUE; // allow dragging } void OnCancelDrag(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/) { // nothing to do } int OnDragging(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/) { return 0; // don't change cursor } void OnDropped(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/) { // nothing to do } }; ///////////////////////////////////////////////////////////////////////////// // CReBarCtrl template class CReBarCtrlT : public TBase { public: // Constructors CReBarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CReBarCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return REBARCLASSNAME; } UINT GetBandCount() const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, RB_GETBANDCOUNT, 0, 0L); } BOOL GetBandInfo(int nBand, LPREBARBANDINFO lprbbi) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_GETBANDINFO, nBand, (LPARAM)lprbbi); } BOOL SetBandInfo(int nBand, LPREBARBANDINFO lprbbi) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_SETBANDINFO, nBand, (LPARAM)lprbbi); } BOOL GetBarInfo(LPREBARINFO lprbi) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_GETBARINFO, 0, (LPARAM)lprbi); } BOOL SetBarInfo(LPREBARINFO lprbi) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_SETBARINFO, 0, (LPARAM)lprbi); } UINT GetRowCount() const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, RB_GETROWCOUNT, 0, 0L); } UINT GetRowHeight(int nBand) const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, RB_GETROWHEIGHT, nBand, 0L); } #if (_WIN32_IE >= 0x0400) COLORREF GetTextColor() const { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, RB_GETTEXTCOLOR, 0, 0L); } COLORREF SetTextColor(COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, RB_SETTEXTCOLOR, 0, (LPARAM)clr); } COLORREF GetBkColor() const { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, RB_GETBKCOLOR, 0, 0L); } COLORREF SetBkColor(COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, RB_SETBKCOLOR, 0, (LPARAM)clr); } UINT GetBarHeight() const { ATLASSERT(::IsWindow(m_hWnd)); return (UINT)::SendMessage(m_hWnd, RB_GETBARHEIGHT, 0, 0L); } BOOL GetRect(int nBand, LPRECT lpRect) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_GETRECT, nBand, (LPARAM)lpRect); } CToolTipCtrl GetToolTips() const { ATLASSERT(::IsWindow(m_hWnd)); return CToolTipCtrl((HWND)::SendMessage(m_hWnd, RB_GETTOOLTIPS, 0, 0L)); } void SetToolTips(HWND hwndToolTip) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_SETTOOLTIPS, (WPARAM)hwndToolTip, 0L); } void GetBandBorders(int nBand, LPRECT lpRect) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(lpRect != NULL); ::SendMessage(m_hWnd, RB_GETBANDBORDERS, nBand, (LPARAM)lpRect); } BOOL GetColorScheme(LPCOLORSCHEME lpColorScheme) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(lpColorScheme != NULL); return (BOOL)::SendMessage(m_hWnd, RB_GETCOLORSCHEME, 0, (LPARAM)lpColorScheme); } void SetColorScheme(LPCOLORSCHEME lpColorScheme) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(lpColorScheme != NULL); ::SendMessage(m_hWnd, RB_SETCOLORSCHEME, 0, (LPARAM)lpColorScheme); } HPALETTE GetPalette() const { ATLASSERT(::IsWindow(m_hWnd)); return (HPALETTE)::SendMessage(m_hWnd, RB_GETPALETTE, 0, 0L); } HPALETTE SetPalette(HPALETTE hPalette) { ATLASSERT(::IsWindow(m_hWnd)); return (HPALETTE)::SendMessage(m_hWnd, RB_SETPALETTE, 0, (LPARAM)hPalette); } BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) // Operations BOOL InsertBand(int nBand, LPREBARBANDINFO lprbbi) { ATLASSERT(::IsWindow(m_hWnd)); lprbbi->cbSize = sizeof(REBARBANDINFO); return (BOOL)::SendMessage(m_hWnd, RB_INSERTBAND, nBand, (LPARAM)lprbbi); } BOOL DeleteBand(int nBand) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_DELETEBAND, nBand, 0L); } CWindow SetNotifyWnd(HWND hWnd) { ATLASSERT(::IsWindow(m_hWnd)); return CWindow((HWND)::SendMessage(m_hWnd, RB_SETPARENT, (WPARAM)hWnd, 0L)); } #if (_WIN32_IE >= 0x0400) void BeginDrag(int nBand, DWORD dwPos) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_BEGINDRAG, nBand, dwPos); } void BeginDrag(int nBand, int xPos, int yPos) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_BEGINDRAG, nBand, MAKELPARAM(xPos, yPos)); } void EndDrag() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_ENDDRAG, 0, 0L); } void DragMove(DWORD dwPos) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_DRAGMOVE, 0, dwPos); } void DragMove(int xPos, int yPos) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_DRAGMOVE, 0, MAKELPARAM(xPos, yPos)); } void GetDropTarget(IDropTarget** ppDropTarget) const { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_GETDROPTARGET, 0, (LPARAM)ppDropTarget); } void MaximizeBand(int nBand) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_MAXIMIZEBAND, nBand, 0L); } void MinimizeBand(int nBand) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_MINIMIZEBAND, nBand, 0L); } BOOL SizeToRect(LPRECT lpRect) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_SIZETORECT, 0, (LPARAM)lpRect); } int IdToIndex(UINT uBandID) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, RB_IDTOINDEX, uBandID, 0L); } int HitTest(LPRBHITTESTINFO lprbht) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, RB_HITTEST, 0, (LPARAM)lprbht); } BOOL ShowBand(int nBand, BOOL bShow) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, RB_SHOWBAND, nBand, bShow); } BOOL MoveBand(int nBand, int nNewPos) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nNewPos >= 0 && nNewPos <= ((int)GetBandCount() - 1)); return (BOOL)::SendMessage(m_hWnd, RB_MOVEBAND, nBand, nNewPos); } #endif //(_WIN32_IE >= 0x0400) #if (_WIN32_IE >= 0x0500) void PushChevron(int nBand, LPARAM lAppValue) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, RB_PUSHCHEVRON, nBand, lAppValue); } #endif //(_WIN32_IE >= 0x0500) }; typedef CReBarCtrlT CReBarCtrl; ///////////////////////////////////////////////////////////////////////////// // CComboBoxEx template class CComboBoxExT : public CComboBoxT< TBase > { public: // Constructors CComboBoxExT(HWND hWnd = NULL) : CComboBoxT< TBase >(hWnd) { } CComboBoxExT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return WC_COMBOBOXEX; } CImageList GetImageList() const { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, CBEM_GETIMAGELIST, 0, 0L)); } CImageList SetImageList(HIMAGELIST hImageList) { ATLASSERT(::IsWindow(m_hWnd)); return CImageList((HIMAGELIST)::SendMessage(m_hWnd, CBEM_SETIMAGELIST, 0, (LPARAM)hImageList)); } #if (_WIN32_IE >= 0x0400) DWORD GetExtendedStyle() const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, CBEM_GETEXTENDEDSTYLE, 0, 0L); } DWORD SetExtendedStyle(DWORD dwExMask, DWORD dwExStyle) { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, CBEM_SETEXTENDEDSTYLE, dwExMask, dwExStyle); } BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, CBEM_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, CBEM_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) // Operations int InsertItem(const COMBOBOXEXITEM FAR* lpcCBItem) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, CBEM_INSERTITEM, 0, (LPARAM)lpcCBItem); } int DeleteItem(int nIndex) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, CBEM_DELETEITEM, nIndex, 0L); } BOOL GetItem(PCOMBOBOXEXITEM pCBItem) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, CBEM_GETITEM, 0, (LPARAM)pCBItem); } BOOL SetItem(const COMBOBOXEXITEM FAR* lpcCBItem) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, CBEM_SETITEM, 0, (LPARAM)lpcCBItem); } CComboBox GetComboCtrl() const { ATLASSERT(::IsWindow(m_hWnd)); return CComboBox((HWND)::SendMessage(m_hWnd, CBEM_GETCOMBOCONTROL, 0, 0L)); } CEdit GetEditCtrl() const { ATLASSERT(::IsWindow(m_hWnd)); return CEdit((HWND)::SendMessage(m_hWnd, CBEM_GETEDITCONTROL, 0, 0L)); } BOOL HasEditChanged() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, CBEM_HASEDITCHANGED, 0, 0L); } }; typedef CComboBoxExT CComboBoxEx; ///////////////////////////////////////////////////////////////////////////// // CMonthCalendarCtrl template class CMonthCalendarCtrlT : public TBase { public: // Constructors CMonthCalendarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CMonthCalendarCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return MONTHCAL_CLASS; } COLORREF GetColor(int nColorType) const { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, MCM_GETCOLOR, nColorType, 0L); } COLORREF SetColor(int nColorType, COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, MCM_SETCOLOR, nColorType, clr); } BOOL GetCurSel(LPSYSTEMTIME lpSysTime) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_GETCURSEL, 0, (LPARAM)lpSysTime); } BOOL SetCurSel(LPSYSTEMTIME lpSysTime) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_SETCURSEL, 0, (LPARAM)lpSysTime); } int GetFirstDayOfWeek(BOOL* pbLocaleVal = NULL) const { ATLASSERT(::IsWindow(m_hWnd)); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, MCM_GETFIRSTDAYOFWEEK, 0, 0L); if(pbLocaleVal != NULL) *pbLocaleVal = (BOOL)HIWORD(dwRet); return (int)(short)LOWORD(dwRet); } int SetFirstDayOfWeek(int nDay, BOOL* pbLocaleVal = NULL) { ATLASSERT(::IsWindow(m_hWnd)); DWORD dwRet = (DWORD)::SendMessage(m_hWnd, MCM_SETFIRSTDAYOFWEEK, 0, nDay); if(pbLocaleVal != NULL) *pbLocaleVal = (BOOL)HIWORD(dwRet); return (int)(short)LOWORD(dwRet); } int GetMaxSelCount() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, MCM_GETMAXSELCOUNT, 0, 0L); } BOOL SetMaxSelCount(int nMax) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_SETMAXSELCOUNT, nMax, 0L); } int GetMonthDelta() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, MCM_GETMONTHDELTA, 0, 0L); } int SetMonthDelta(int nDelta) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, MCM_SETMONTHDELTA, nDelta, 0L); } DWORD GetRange(LPSYSTEMTIME lprgSysTimeArray) const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, MCM_GETRANGE, 0, (LPARAM)lprgSysTimeArray); } BOOL SetRange(DWORD dwFlags, LPSYSTEMTIME lprgSysTimeArray) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_SETRANGE, dwFlags, (LPARAM)lprgSysTimeArray); } BOOL GetSelRange(LPSYSTEMTIME lprgSysTimeArray) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_GETSELRANGE, 0, (LPARAM)lprgSysTimeArray); } BOOL SetSelRange(LPSYSTEMTIME lprgSysTimeArray) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_SETSELRANGE, 0, (LPARAM)lprgSysTimeArray); } BOOL GetToday(LPSYSTEMTIME lpSysTime) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_GETTODAY, 0, (LPARAM)lpSysTime); } void SetToday(LPSYSTEMTIME lpSysTime) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, MCM_SETTODAY, 0, (LPARAM)lpSysTime); } BOOL GetMinReqRect(LPRECT lpRectInfo) const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_GETMINREQRECT, 0, (LPARAM)lpRectInfo); } int GetMonthRange() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, MCM_GETMAXTODAYWIDTH, 0, 0L); } #if (_WIN32_IE >= 0x0400) BOOL GetUnicodeFormat() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_GETUNICODEFORMAT, 0, 0L); } BOOL SetUnicodeFormat(BOOL bUnicode = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_SETUNICODEFORMAT, bUnicode, 0L); } #endif //(_WIN32_IE >= 0x0400) // Operations int GetMonthRange(DWORD dwFlags, LPSYSTEMTIME lprgSysTimeArray) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, MCM_GETMONTHRANGE, dwFlags, (LPARAM)lprgSysTimeArray); } BOOL SetDayState(int nMonths, LPMONTHDAYSTATE lpDayStateArray) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, MCM_SETDAYSTATE, nMonths, (LPARAM)lpDayStateArray); } DWORD HitTest(PMCHITTESTINFO pMCHitTest) const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, MCM_HITTEST, 0, (LPARAM)pMCHitTest); } }; typedef CMonthCalendarCtrlT CMonthCalendarCtrl; ///////////////////////////////////////////////////////////////////////////// // CDateTimePickerCtrl template class CDateTimePickerCtrlT : public TBase { public: // Constructors CDateTimePickerCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CDateTimePickerCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Operations static LPCTSTR GetWndClassName() { return DATETIMEPICK_CLASS; } BOOL SetFormat(LPTSTR lpszFormat) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, DTM_SETFORMAT, 0, (LPARAM)lpszFormat); } COLORREF GetMonthCalColor(int nColorType) const { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, DTM_GETMCCOLOR, nColorType, 0L); } COLORREF SetMonthCalColor(int nColorType, COLORREF clr) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, DTM_SETMCCOLOR, nColorType, clr); } DWORD GetRange(LPSYSTEMTIME lpSysTimeArray) const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, DTM_GETRANGE, 0, (LPARAM)lpSysTimeArray); } BOOL SetRange(DWORD dwFlags, LPSYSTEMTIME lpSysTimeArray) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, DTM_SETRANGE, dwFlags, (LPARAM)lpSysTimeArray); } DWORD GetSystemTime(LPSYSTEMTIME lpSysTime) const { ATLASSERT(::IsWindow(m_hWnd)); return (DWORD)::SendMessage(m_hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)lpSysTime); } BOOL SetSystemTime(DWORD dwFlags, LPSYSTEMTIME lpSysTime) { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, DTM_SETSYSTEMTIME, dwFlags, (LPARAM)lpSysTime); } CMonthCalendarCtrl GetMonthCal() const { ATLASSERT(::IsWindow(m_hWnd)); return CMonthCalendarCtrl((HWND)::SendMessage(m_hWnd, DTM_GETMONTHCAL, 0, 0L)); } #if (_WIN32_IE >= 0x0400) CFontHandle GetMonthCalFont() const { ATLASSERT(::IsWindow(m_hWnd)); return CFontHandle((HFONT)::SendMessage(m_hWnd, DTM_GETMCFONT, 0, 0L)); } void SetMonthCalFont(HFONT hFont, BOOL bRedraw = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, DTM_SETMCFONT, (WPARAM)hFont, MAKELPARAM(bRedraw, 0)); } #endif //(_WIN32_IE >= 0x0400) }; typedef CDateTimePickerCtrlT CDateTimePickerCtrl; ///////////////////////////////////////////////////////////////////////////// // CFlatScrollBarImpl - support for flat scroll bars #if (_WIN32_IE >= 0x0400) template class CFlatScrollBarImpl { public: // Initialization BOOL FlatSB_Initialize() { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::InitializeFlatSB(pT->m_hWnd); } HRESULT FlatSB_Uninitialize() { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::UninitializeFlatSB(pT->m_hWnd); } // Flat scroll bar properties BOOL FlatSB_GetScrollProp(UINT uIndex, LPINT lpnValue) const { const T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_GetScrollProp(pT->m_hWnd, uIndex, lpnValue); } BOOL FlatSB_SetScrollProp(UINT uIndex, int nValue, BOOL bRedraw = TRUE) { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_SetScrollProp(pT->m_hWnd, uIndex, nValue, bRedraw); } // Attributes int FlatSB_GetScrollPos(int nBar) const { const T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_GetScrollPos(pT->m_hWnd, nBar); } int FlatSB_SetScrollPos(int nBar, int nPos, BOOL bRedraw = TRUE) { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_SetScrollPos(pT->m_hWnd, nBar, nPos, bRedraw); } BOOL FlatSB_GetScrollRange(int nBar, LPINT lpMinPos, LPINT lpMaxPos) const { const T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_GetScrollRange(pT->m_hWnd, nBar, lpMinPos, lpMaxPos); } BOOL FlatSB_SetScrollRange(int nBar, int nMinPos, int nMaxPos, BOOL bRedraw = TRUE) { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_SetScrollRange(pT->m_hWnd, nBar, nMinPos, nMaxPos, bRedraw); } BOOL FlatSB_GetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo) const { const T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_GetScrollInfo(pT->m_hWnd, nBar, lpScrollInfo); } int FlatSB_SetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE) { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_SetScrollInfo(pT->m_hWnd, nBar, lpScrollInfo, bRedraw); } // Operations BOOL FlatSB_ShowScrollBar(UINT nBar, BOOL bShow = TRUE) { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_ShowScrollBar(pT->m_hWnd, nBar, bShow); } BOOL FlatSB_EnableScrollBar(UINT uSBFlags, UINT uArrowFlags = ESB_ENABLE_BOTH) { T* pT = static_cast(this); ATLASSERT(::IsWindow(pT->m_hWnd)); return ::FlatSB_EnableScrollBar(pT->m_hWnd, uSBFlags, uArrowFlags); } }; template class CFlatScrollBarT : public TBase, public CFlatScrollBarImpl > { public: CFlatScrollBarT(HWND hWnd = NULL) : TBase(hWnd) { } CFlatScrollBarT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } }; typedef CFlatScrollBarT CFlatScrollBar; #endif //(_WIN32_IE >= 0x0400) ///////////////////////////////////////////////////////////////////////////// // CIPAddressCtrl #if (_WIN32_IE >= 0x0400) template class CIPAddressCtrlT : public TBase { public: // Constructors CIPAddressCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CIPAddressCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Atteributes static LPCTSTR GetWndClassName() { return WC_IPADDRESS; } BOOL IsBlank() const { ATLASSERT(::IsWindow(m_hWnd)); return (BOOL)::SendMessage(m_hWnd, IPM_ISBLANK, 0, 0L); } int GetAddress(LPDWORD lpdwAddress) const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, IPM_GETADDRESS, 0, (LPARAM)lpdwAddress); } void SetAddress(DWORD dwAddress) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, IPM_SETADDRESS, 0, dwAddress); } void ClearAddress() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, IPM_CLEARADDRESS, 0, 0L); } void SetRange(int nField, WORD wRange) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, IPM_SETRANGE, nField, wRange); } void SetRange(int nField, BYTE nMin, BYTE nMax) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, IPM_SETRANGE, nField, MAKEIPRANGE(nMin, nMax)); } void SetFocus(int nField) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, IPM_SETFOCUS, nField, 0L); } }; typedef CIPAddressCtrlT CIPAddressCtrl; #endif //(_WIN32_IE >= 0x0400) ///////////////////////////////////////////////////////////////////////////// // CPagerCtrl #if (_WIN32_IE >= 0x0400) template class CPagerCtrlT : public TBase { public: // Constructors CPagerCtrlT(HWND hWnd = NULL) : TBase(hWnd) { } CPagerCtrlT< TBase >& operator=(HWND hWnd) { m_hWnd = hWnd; return *this; } HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL, DWORD dwStyle = 0, DWORD dwExStyle = 0, _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) { return CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); } // Attributes static LPCTSTR GetWndClassName() { return WC_PAGESCROLLER; } int GetButtonSize() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PGM_GETBUTTONSIZE, 0, 0L); } int SetButtonSize(int nButtonSize) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PGM_SETBUTTONSIZE, 0, nButtonSize); } DWORD GetButtonState(int nButton) const { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(nButton == PGB_TOPORLEFT || nButton == PGB_BOTTOMORRIGHT); return (DWORD)::SendMessage(m_hWnd, PGM_GETBUTTONSTATE, 0, nButton); } COLORREF GetBkColor() const { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, PGM_GETBKCOLOR, 0, 0L); } COLORREF SetBkColor(COLORREF clrBk) { ATLASSERT(::IsWindow(m_hWnd)); return (COLORREF)::SendMessage(m_hWnd, PGM_SETBKCOLOR, 0, (LPARAM)clrBk); } int GetBorder() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PGM_GETBORDER, 0, 0L); } int SetBorder(int nBorderSize) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PGM_SETBORDER, 0, nBorderSize); } int GetPos() const { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PGM_GETPOS, 0, 0L); } int SetPos(int nPos) { ATLASSERT(::IsWindow(m_hWnd)); return (int)::SendMessage(m_hWnd, PGM_SETPOS, 0, nPos); } // Operations void SetChild(HWND hWndChild) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PGM_SETCHILD, 0, (LPARAM)hWndChild); } void ForwardMouse(BOOL bForward = TRUE) { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PGM_FORWARDMOUSE, bForward, 0L); } void RecalcSize() { ATLASSERT(::IsWindow(m_hWnd)); ::SendMessage(m_hWnd, PGM_RECALCSIZE, 0, 0L); } void GetDropTarget(IDropTarget** ppDropTarget) { ATLASSERT(::IsWindow(m_hWnd)); ATLASSERT(ppDropTarget != NULL); ::SendMessage(m_hWnd, PGM_GETDROPTARGET, 0, (LPARAM)ppDropTarget); } }; typedef CPagerCtrlT CPagerCtrl; #endif //(_WIN32_IE >= 0x0400) ///////////////////////////////////////////////////////////////////////////// // CCustomDraw - MI class for custom-draw support template class CCustomDraw { public: #if !defined(_ATL_TMP_IMPL1) && !defined(_ATL_TMP_IMPL2) BOOL m_bHandledCD; BOOL IsMsgHandled() const { return m_bHandledCD; } void SetMsgHandled(BOOL bHandled) { m_bHandledCD = bHandled; } #endif //!defined(_ATL_TMP_IMPL1) && !defined(_ATL_TMP_IMPL2) // Message map and handlers BEGIN_MSG_MAP(CCustomDraw< T >) NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw) ALT_MSG_MAP(1) REFLECTED_NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw) END_MSG_MAP() // message handler LRESULT OnCustomDraw(int idCtrl, LPNMHDR pnmh, BOOL& bHandled) { T* pT = static_cast(this); pT->SetMsgHandled(TRUE); LPNMCUSTOMDRAW lpNMCustomDraw = (LPNMCUSTOMDRAW)pnmh; DWORD dwRet = 0; switch(lpNMCustomDraw->dwDrawStage) { case CDDS_PREPAINT: dwRet = pT->OnPrePaint(idCtrl, lpNMCustomDraw); break; case CDDS_POSTPAINT: dwRet = pT->OnPostPaint(idCtrl, lpNMCustomDraw); break; case CDDS_PREERASE: dwRet = pT->OnPreErase(idCtrl, lpNMCustomDraw); break; case CDDS_POSTERASE: dwRet = pT->OnPostErase(idCtrl, lpNMCustomDraw); break; case CDDS_ITEMPREPAINT: dwRet = pT->OnItemPrePaint(idCtrl, lpNMCustomDraw); break; case CDDS_ITEMPOSTPAINT: dwRet = pT->OnItemPostPaint(idCtrl, lpNMCustomDraw); break; case CDDS_ITEMPREERASE: dwRet = pT->OnItemPreErase(idCtrl, lpNMCustomDraw); break; case CDDS_ITEMPOSTERASE: dwRet = pT->OnItemPostErase(idCtrl, lpNMCustomDraw); break; default: pT->SetMsgHandled(FALSE); break; } bHandled = pT->IsMsgHandled(); return dwRet; } // Overrideables DWORD OnPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnPostPaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnPreErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnPostErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnItemPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnItemPostPaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnItemPreErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } DWORD OnItemPostErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/) { return CDRF_DODEFAULT; } }; }; //namespace WTL #endif // __ATLCTRLS_H__